Fix code block formatting in copilot instructions

Remove tests for uninitialized PacketHistory state due to undefined behavior
Add NodeDB layout v25 documentation and migration guidelines
2026-10-04 03:18:10 +10:00 · 2026-05-09 13:38:19 -05:00 · 2026-05-09 13:19:48 -05:00 · 2026-05-09 12:56:00 -05:00 · 2026-05-09 12:27:08 -05:00 · 2026-05-09 11:34:54 -05:00
169 changed files with 5632 additions and 1165 deletions
@@ -13,6 +13,7 @@ Meshtastic is an open-source LoRa mesh networking project for long-range, low-po
 - **RP2040/RP2350** - Raspberry Pi Pico variants
 - **STM32WL** - STM32 with integrated LoRa
 - **Linux/Portduino** - Native Linux builds (Raspberry Pi, etc.)
+- **macOS native** - Headless `meshtasticd` on Apple Silicon / x86_64; see `variants/native/portduino/platformio.ini` for Homebrew prereqs + CH341 LoRa setup

 ### Supported Radio Chips

@@ -134,6 +135,95 @@ 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

 ```
@@ -369,7 +459,7 @@ To reduce avoidable agent mistakes, assume these tools are available (or install
 - **Required CLI basics**: `bash`, `git`, `find`, `grep`, `sed`, `awk`, `xargs`
 - **Strongly recommended**: `rg` (ripgrep) for fast file/text search, `jq` for JSON processing
 - **Build/test tools**: `python3`, `pip`, virtualenv (`python3 -m venv`), `platformio` (`pio`)
- **Containerized native testing**: `docker` (especially important on macOS / non-Linux hosts)
+- **Containerized native testing**: `docker` (fallback for non-Linux hosts; macOS can also build natively via `pio run -e native-macos`)

 Fallback expectations for agents:

@@ -388,6 +478,7 @@ Build commands:
 pio run -e tbeam              # Build specific target
 pio run -e tbeam -t upload    # Build and upload
 pio run -e native             # Build native/Linux version
+pio run -e native-macos       # Build headless macOS meshtasticd (Homebrew prereqs in variants/native/portduino/platformio.ini)
 ```

 ### Build Manifest
@@ -573,6 +664,8 @@ Grouped by purpose. Full argument shapes in `mcp-server/README.md`; a few high-v

 `confirm=True` is a tool-level gate on top of whatever permission prompt your MCP host shows. **Don't bypass it** by asking the host to auto-approve — it exists specifically because MCP hosts sometimes remember "always allow this tool" and that's dangerous for `factory_reset`, `erase_and_flash`, `uhubctl_power(action='off')`, and `uhubctl_cycle`.

+**TCP / native-host nodes.** Setting `MESHTASTIC_MCP_TCP_HOST=<host[:port]>` makes `list_devices` surface a `meshtasticd` daemon (e.g. the `native-macos` build) as a synthetic `tcp://host:port` entry, and `connect()` routes through `meshtastic.tcp_interface.TCPInterface` instead of `SerialInterface`. Every read/write/admin tool that flows through `connect()` works against the daemon transparently. USB-only tools (`pio_flash`, `erase_and_flash`, `update_flash`, `touch_1200bps`, `serial_open`, `esptool_*`, `nrfutil_*`, `picotool_*`) raise a clear `ConnectionError` when handed a `tcp://` port; `pio_flash` against a `native*` env raises a `FlashError` (no upload step — use `build` and run the binary directly). The pytest harness still assumes USB-attached devices per role; TCP-aware fixtures are deferred. See `mcp-server/README.md` § "TCP / native-host nodes".
+
 ### Hardware test suite (`mcp-server/run-tests.sh`)

 The wrapper auto-detects connected devices (VID → role map: `0x239A` → `nrf52`, `0x303A`/`0x10C4` → `esp32s3`), maps each role to a PlatformIO env (`nrf52` → `rak4631`, `esp32s3` → `heltec-v3`, overridable via `MESHTASTIC_MCP_ENV_<ROLE>`), then invokes pytest. Zero pre-flight config needed from the operator.
@@ -32,10 +32,15 @@ jobs:
        shell: bash
        working-directory: meshtasticd
        run: |
+          # Build-tools (notably platformio) come from the Meshtastic project
+          # on the OpenSUSE Build Service:
+          # https://build.opensuse.org/project/show/network:Meshtastic:build-tools
+          echo 'deb http://download.opensuse.org/repositories/network:/Meshtastic:/build-tools/xUbuntu_24.04/ /' \
+            | sudo tee /etc/apt/sources.list.d/network:Meshtastic:build-tools.list
+          curl -fsSL https://download.opensuse.org/repositories/network:Meshtastic:build-tools/xUbuntu_24.04/Release.key \
+            | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/network_Meshtastic_build-tools.gpg >/dev/null
          sudo apt-get update -y --fix-missing
-          sudo apt-get install -y software-properties-common build-essential devscripts equivs
-          sudo add-apt-repository ppa:meshtastic/build-tools -y
-          sudo apt-get update -y --fix-missing
+          sudo apt-get install -y build-essential devscripts equivs
          sudo mk-build-deps --install --remove --tool='apt-get -o Debug::pkgProblemResolver=yes --no-install-recommends --yes' debian/control

      - name: Import GPG key
@@ -0,0 +1,51 @@
+name: Build MacOS Binary
+
+on:
+  workflow_call:
+    inputs:
+      macos_ver:
+        required: false
+        default: "26" # ARM64
+        type: string
+
+permissions:
+  contents: read
+
+jobs:
+  build-MacOS:
+    runs-on: macos-${{ inputs.macos_ver }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+        with:
+          submodules: recursive
+
+      - name: Install deps
+        shell: bash
+        run: |
+          brew update
+          brew install platformio yaml-cpp libuv openssl@3 libusb argp-standalone pkg-config ulfius
+
+      - name: Get release version string
+        run: |
+          echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
+        id: version
+
+      - name: Build for MacOS
+        run: |
+          platformio run -e native-macos
+        env:
+          PKG_VERSION: ${{ steps.version.outputs.long }}
+        # Errors in this step should not fail the entire workflow while MacOS support is in development.
+        continue-on-error: true
+
+      - name: List output files
+        run: ls -lah .pio/build/native-macos/
+
+      - name: Store binaries as an artifact
+        uses: actions/upload-artifact@v7
+        with:
+          name: firmware-macos-${{ inputs.macos_ver }}-${{ steps.version.outputs.long }}
+          overwrite: true
+          path: |
+            .pio/build/native-macos/meshtasticd
@@ -73,7 +73,9 @@ jobs:
      - name: Sanitize platform string
        id: sanitize_platform
        # Replace slashes with underscores
-        run: echo "cleaned_platform=${{ inputs.platform }}" | sed 's/\//_/g' >> $GITHUB_OUTPUT
+        env:
+          plat: ${{ inputs.platform }}
+        run: echo "cleaned_platform=${plat}" | sed 's/\//_/g' >> $GITHUB_OUTPUT

      - name: Docker login
        if: ${{ inputs.push }}
@@ -43,6 +43,15 @@ jobs:
      push: true
    secrets: inherit

+  docker-debian-riscv64:
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: debian
+      platform: linux/riscv64
+      runs-on: ubuntu-24.04-arm
+      push: true
+    secrets: inherit
+
  docker-alpine-amd64:
    uses: ./.github/workflows/docker_build.yml
    with:
@@ -70,16 +79,27 @@ jobs:
      push: true
    secrets: inherit

+  docker-alpine-riscv64:
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: alpine
+      platform: linux/riscv64
+      runs-on: ubuntu-24.04-arm
+      push: true
+    secrets: inherit
+
  docker-manifest:
    needs:
      # Debian
      - docker-debian-amd64
      - docker-debian-arm64
      - docker-debian-armv7
+      - docker-debian-riscv64
      # Alpine
      - docker-alpine-amd64
      - docker-alpine-arm64
      - docker-alpine-armv7
+      - docker-alpine-riscv64
    runs-on: ubuntu-24.04
    steps:
      - name: Checkout code
@@ -162,6 +182,7 @@ jobs:
            meshtastic/meshtasticd@${{ needs.docker-debian-amd64.outputs.digest }}
            meshtastic/meshtasticd@${{ needs.docker-debian-arm64.outputs.digest }}
            meshtastic/meshtasticd@${{ needs.docker-debian-armv7.outputs.digest }}
+            meshtastic/meshtasticd@${{ needs.docker-debian-riscv64.outputs.digest }}

      - name: Docker meta (Alpine)
        id: meta_alpine
@@ -182,3 +203,4 @@ jobs:
            meshtastic/meshtasticd@${{ needs.docker-alpine-amd64.outputs.digest }}
            meshtastic/meshtasticd@${{ needs.docker-alpine-arm64.outputs.digest }}
            meshtastic/meshtasticd@${{ needs.docker-alpine-armv7.outputs.digest }}
+            meshtastic/meshtasticd@${{ needs.docker-alpine-riscv64.outputs.digest }}
@@ -116,6 +116,20 @@ jobs:
      build_location: local
    secrets: inherit

+  MacOS:
+    strategy:
+      fail-fast: false
+      matrix:
+        macos_ver:
+          - "26" # ARM64
+          # - '26-intel' # x86_64
+          - "15" # ARM64
+          # - '15-intel' # x86_64
+    uses: ./.github/workflows/build_macos_bin.yml
+    with:
+      macos_ver: ${{ matrix.macos_ver }}
+    # secrets: inherit
+
  package-pio-deps-native-tft:
    if: ${{ github.repository == 'meshtastic/firmware' && github.event_name == 'workflow_dispatch' }}
    uses: ./.github/workflows/package_pio_deps.yml
@@ -286,6 +300,7 @@ jobs:
      - gather-artifacts
      - build-debian-src
      - package-pio-deps-native-tft
+      # - MacOS
    steps:
      - name: Checkout
        uses: actions/checkout@v6
@@ -4,19 +4,19 @@ cli:
 plugins:
  sources:
    - id: trunk
-      ref: v1.7.6
+      ref: v1.8.0
      uri: https://github.com/trunk-io/plugins
 lint:
  enabled:
-    - checkov@3.2.524
-    - renovate@43.141.0
+    - checkov@3.2.526
+    - renovate@43.150.0
    - prettier@3.8.3
    - trufflehog@3.95.2
    - yamllint@1.38.0
    - bandit@1.9.4
    - trivy@0.70.0
    - taplo@0.10.0
-    - ruff@0.15.11
+    - ruff@0.15.12
    - isort@8.0.1
    - markdownlint@0.48.0
    - oxipng@10.1.1
@@ -36,7 +36,7 @@ lint:
        - bin/**
 runtimes:
  enabled:
-    - python@3.10.8
+    - python@3.14.4
    - go@1.21.0
    - node@22.16.0
 actions:
@@ -10,17 +10,18 @@ This file (`AGENTS.md`) is a short pointer + quick reference for agents that don

 ## Quick command reference

-| Action                           | Command                                                                             |
-| -------------------------------- | ----------------------------------------------------------------------------------- |
-| Build a firmware variant         | `pio run -e <env>` (e.g. `pio run -e rak4631`, `pio run -e heltec-v3`)              |
-| Clean + rebuild                  | `pio run -e <env> -t clean && pio run -e <env>`                                     |
-| Flash a device                   | `pio run -e <env> -t upload --upload-port <port>` (or use the `pio_flash` MCP tool) |
-| Run firmware unit tests (native) | `pio test -e native`                                                                |
-| Run MCP hardware tests           | `./mcp-server/run-tests.sh`                                                         |
-| Live TUI test runner             | `mcp-server/.venv/bin/meshtastic-mcp-test-tui`                                      |
-| Format before commit             | `trunk fmt`                                                                         |
-| Regenerate protobuf bindings     | `bin/regen-protos.sh`                                                               |
-| Generate CI matrix               | `./bin/generate_ci_matrix.py all [--level pr]`                                      |
+| Action                           | Command                                                                                                       |
+| -------------------------------- | ------------------------------------------------------------------------------------------------------------- |
+| Build a firmware variant         | `pio run -e <env>` (e.g. `pio run -e rak4631`, `pio run -e heltec-v3`)                                        |
+| Build native macOS host binary   | `pio run -e native-macos` (Homebrew prereqs + CH341 LoRa setup in `variants/native/portduino/platformio.ini`) |
+| Clean + rebuild                  | `pio run -e <env> -t clean && pio run -e <env>`                                                               |
+| Flash a device                   | `pio run -e <env> -t upload --upload-port <port>` (or use the `pio_flash` MCP tool)                           |
+| Run firmware unit tests (native) | `pio test -e native`                                                                                          |
+| Run MCP hardware tests           | `./mcp-server/run-tests.sh`                                                                                   |
+| Live TUI test runner             | `mcp-server/.venv/bin/meshtastic-mcp-test-tui`                                                                |
+| Format before commit             | `trunk fmt`                                                                                                   |
+| Regenerate protobuf bindings     | `bin/regen-protos.sh`                                                                                         |
+| Generate CI matrix               | `./bin/generate_ci_matrix.py all [--level pr]`                                                                |

 ## MCP server (device + test automation)

@@ -121,19 +122,21 @@ Sequence these; don't parallelize on the same port.
 - **Device fully wedged (no DFU)?** `mcp__meshtastic__uhubctl_cycle(role="nrf52", confirm=True)` hard-power-cycles it via USB hub PPPS. Needs `uhubctl` installed (`brew install uhubctl` / `apt install uhubctl`); on Linux without udev rules, permission errors fail fast, so use `sudo uhubctl` yourself or configure udev access.
 - **Port busy?** `lsof <port>` to find the holder. Usually a stale `pio device monitor` or zombie `meshtastic_mcp` process. Kill it.
 - **Multiple MCP servers running?** `ps aux | grep meshtastic_mcp` — zombies hold ports. Kill all but the one your host spawned.
+- **macOS: `LIBUSB_ERROR_BUSY` on a CH341 LoRa adapter?** A third-party WCH `CH34xVCPDriver` is claiming interface 0. Find the bundle ID with `ioreg -p IOUSB -l -w 0 | grep -B2 -A30 0x5512`, then `sudo kmutil unload -b <bundleID>`. Apple's bundled CH34x kext targets the CH340 UART (PID 0x7523), not the SPI bridge — it's never the culprit.

 ## Environment variables (test harness)

-| Var                                  | Purpose                                                                                                                                        |
-| ------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------- |
-| `MESHTASTIC_MCP_ENV_<ROLE>`          | Override PlatformIO env for a role (e.g. `MESHTASTIC_MCP_ENV_NRF52=rak4631-dap`). Default map: `nrf52→rak4631`, `esp32s3→heltec-v3`.           |
-| `MESHTASTIC_MCP_SEED`                | PSK seed for the session test profile. Defaults to `mcp-<user>-<host>`.                                                                        |
-| `MESHTASTIC_MCP_FLASH_LOG`           | File path to tee pio/esptool/nrfutil/picotool output. `run-tests.sh` sets this to `tests/flash.log` so the TUI can stream live flash progress. |
-| `MESHTASTIC_UHUBCTL_BIN`             | Absolute path to `uhubctl` binary. Default: PATH lookup.                                                                                       |
-| `MESHTASTIC_UHUBCTL_LOCATION_<ROLE>` | Pin a role to a specific uhubctl hub location (e.g. `1-1.3`). Wins over VID auto-detection — use when multiple devices share a VID.            |
-| `MESHTASTIC_UHUBCTL_PORT_<ROLE>`     | Pin a role to a specific hub port number. Required alongside `LOCATION_<ROLE>`.                                                                |
-| `MESHTASTIC_UI_CAMERA_BACKEND`       | Camera backend for UI tier + `capture_screen` tool: `opencv` / `ffmpeg` / `null` / `auto` (default).                                           |
-| `MESHTASTIC_UI_CAMERA_DEVICE`        | Generic camera device (index or path). Used by the UI tier when no per-role var is set.                                                        |
-| `MESHTASTIC_UI_CAMERA_DEVICE_<ROLE>` | Per-role camera pinning (e.g. `MESHTASTIC_UI_CAMERA_DEVICE_ESP32S3=0` for the OLED-bearing heltec-v3).                                         |
-| `MESHTASTIC_UI_OCR_BACKEND`          | OCR engine selection: `easyocr` / `pytesseract` / `null` / `auto` (default).                                                                   |
-| `MESHTASTIC_UI_TUI_CAMERA`           | Set to `1` to mount the live camera-feed panel in `meshtastic-mcp-test-tui`.                                                                   |
+| Var                                  | Purpose                                                                                                                                                                                                    |
+| ------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `MESHTASTIC_MCP_ENV_<ROLE>`          | Override PlatformIO env for a role (e.g. `MESHTASTIC_MCP_ENV_NRF52=rak4631-dap`). Default map: `nrf52→rak4631`, `esp32s3→heltec-v3`.                                                                       |
+| `MESHTASTIC_MCP_SEED`                | PSK seed for the session test profile. Defaults to `mcp-<user>-<host>`.                                                                                                                                    |
+| `MESHTASTIC_MCP_FLASH_LOG`           | File path to tee pio/esptool/nrfutil/picotool output. `run-tests.sh` sets this to `tests/flash.log` so the TUI can stream live flash progress.                                                             |
+| `MESHTASTIC_MCP_TCP_HOST`            | `host` or `host:port` of a `meshtasticd` daemon (e.g. the `native-macos` build). Surfaces it in `list_devices` as `tcp://host:port` so `connect()`-based tools target it transparently. Default port 4403. |
+| `MESHTASTIC_UHUBCTL_BIN`             | Absolute path to `uhubctl` binary. Default: PATH lookup.                                                                                                                                                   |
+| `MESHTASTIC_UHUBCTL_LOCATION_<ROLE>` | Pin a role to a specific uhubctl hub location (e.g. `1-1.3`). Wins over VID auto-detection — use when multiple devices share a VID.                                                                        |
+| `MESHTASTIC_UHUBCTL_PORT_<ROLE>`     | Pin a role to a specific hub port number. Required alongside `LOCATION_<ROLE>`.                                                                                                                            |
+| `MESHTASTIC_UI_CAMERA_BACKEND`       | Camera backend for UI tier + `capture_screen` tool: `opencv` / `ffmpeg` / `null` / `auto` (default).                                                                                                       |
+| `MESHTASTIC_UI_CAMERA_DEVICE`        | Generic camera device (index or path). Used by the UI tier when no per-role var is set.                                                                                                                    |
+| `MESHTASTIC_UI_CAMERA_DEVICE_<ROLE>` | Per-role camera pinning (e.g. `MESHTASTIC_UI_CAMERA_DEVICE_ESP32S3=0` for the OLED-bearing heltec-v3).                                                                                                     |
+| `MESHTASTIC_UI_OCR_BACKEND`          | OCR engine selection: `easyocr` / `pytesseract` / `null` / `auto` (default).                                                                                                                               |
+| `MESHTASTIC_UI_TUI_CAMERA`           | Set to `1` to mount the live camera-feed panel in `meshtastic-mcp-test-tui`.                                                                                                                               |
@@ -3,15 +3,17 @@
 # trunk-ignore-all(hadolint/DL3008): Do not pin apt package versions
 # trunk-ignore-all(hadolint/DL3013): Do not pin pip package versions

-FROM python:3.14-slim-trixie AS builder
+FROM debian:trixie AS builder
 ARG PIO_ENV=native
 ENV DEBIAN_FRONTEND=noninteractive
 ENV TZ=Etc/UTC

 # Install Dependencies
 ENV PIP_ROOT_USER_ACTION=ignore
+ENV PIP_BREAK_SYSTEM_PACKAGES=1
 RUN apt-get update && apt-get install --no-install-recommends -y \
        curl wget g++ zip git ca-certificates pkg-config \
+        python3-pip python3-grpc-tools \
        libgpiod-dev libyaml-cpp-dev libbluetooth-dev libi2c-dev libuv1-dev \
        libusb-1.0-0-dev libulfius-dev liborcania-dev libssl-dev \
        libx11-dev libinput-dev libxkbcommon-x11-dev libsqlite3-dev libsdl2-dev \
@@ -3,12 +3,19 @@
 # trunk-ignore-all(hadolint/DL3018): Do not pin apk package versions
 # trunk-ignore-all(hadolint/DL3013): Do not pin pip package versions

-FROM python:3.14-alpine3.22 AS builder
+# Ensure the Alpine version is updated in both stages of the container!
+FROM alpine:3.23 AS builder
 ARG PIO_ENV=native
-ENV PIP_ROOT_USER_ACTION=ignore

+# Enable Alpine community repository (for 'py3-grpcio-tools')
+RUN echo "https://dl-cdn.alpinelinux.org/alpine/v$(cut -d. -f1,2 /etc/alpine-release)/community" >> /etc/apk/repositories
+
+# Install Dependencies
+ENV PIP_ROOT_USER_ACTION=ignore
+ENV PIP_BREAK_SYSTEM_PACKAGES=1
 RUN apk --no-cache add \
        bash g++ libstdc++-dev linux-headers zip git ca-certificates libbsd-dev \
+        py3-pip py3-grpcio-tools \
        libgpiod-dev yaml-cpp-dev bluez-dev \
        libusb-dev i2c-tools-dev libuv-dev openssl-dev pkgconf argp-standalone \
        libx11-dev libinput-dev libxkbcommon-dev sqlite-dev sdl2-dev \
@@ -60,4 +67,4 @@ EXPOSE 4403

 CMD [ "sh",  "-cx", "meshtasticd --fsdir=/var/lib/meshtasticd" ]

-HEALTHCHECK NONE
+HEALTHCHECK NONE
@@ -31,5 +31,6 @@ basename=meshtasticd-$1-$VERSION
 pio pkg install --environment "$PIO_ENV" || platformioFailed
 pio run --environment "$PIO_ENV" || platformioFailed

-cp "$BUILDDIR/meshtasticd" "$OUTDIR/meshtasticd_linux_$(uname -m)"
+os_name=$(uname -s | tr '[:upper:]' '[:lower:]')
+cp "$BUILDDIR/meshtasticd" "$OUTDIR/meshtasticd_${os_name}_$(uname -m)"
 cp bin/native-install.* $OUTDIR/
@@ -87,6 +87,9 @@
  </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>
@@ -0,0 +1,43 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "esp32s3_out.ld",
+      "partitions": "default_16MB.csv",
+      "memory_type": "qio_opi"
+    },
+    "core": "esp32",
+    "extra_flags": [
+      "-DBOARD_HAS_PSRAM",
+      "-DARDUINO_USB_CDC_ON_BOOT=1",
+      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_RUNNING_CORE=1",
+      "-DARDUINO_EVENT_RUNNING_CORE=1"
+    ],
+    "f_cpu": "240000000L",
+    "f_flash": "80000000L",
+    "flash_mode": "qio",
+    "psram_type": "opi",
+    "hwids": [["0x303A", "0x1001"]],
+    "mcu": "esp32s3",
+    "variant": "heltec_v4_r8"
+  },
+  "connectivity": ["wifi", "bluetooth", "lora"],
+  "debug": {
+    "default_tool": "esp-builtin",
+    "onboard_tools": ["esp-builtin"],
+    "openocd_target": "esp32s3.cfg"
+  },
+  "frameworks": ["arduino", "espidf"],
+  "name": "heltec_wifi_lora_32 v4 r8 (16 MB FLASH, 8 MB PSRAM)",
+  "upload": {
+    "flash_size": "16MB",
+    "maximum_ram_size": 327680,
+    "maximum_size": 16777216,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": true,
+    "require_upload_port": true,
+    "speed": 921600
+  },
+  "url": "https://heltec.org/",
+  "vendor": "heltec"
+}
@@ -1,3 +1,9 @@
+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
@@ -1,4 +1,5 @@
 #!/usr/bin/bash
+set -e
 export DEBEMAIL="jbennett@incomsystems.biz"
 export PLATFORMIO_LIBDEPS_DIR=pio/libdeps
 export PLATFORMIO_PACKAGES_DIR=pio/packages
@@ -166,15 +166,73 @@ rather than auto-`sudo`'ing mid-run.

 ## Environment variables

-| Var                        | Default                                                     | Purpose                                                             |
-| -------------------------- | ----------------------------------------------------------- | ------------------------------------------------------------------- |
-| `MESHTASTIC_FIRMWARE_ROOT` | walks up from cwd for `platformio.ini`                      | Pin the firmware repo                                               |
-| `MESHTASTIC_PIO_BIN`       | `~/.platformio/penv/bin/pio` → `$PATH` `pio` → `platformio` | Override `pio` location                                             |
-| `MESHTASTIC_ESPTOOL_BIN`   | `<firmware>/.venv/bin/esptool` → `$PATH`                    | Override esptool                                                    |
-| `MESHTASTIC_NRFUTIL_BIN`   | `$PATH`                                                     | Override nrfutil                                                    |
-| `MESHTASTIC_PICOTOOL_BIN`  | `$PATH`                                                     | Override picotool                                                   |
-| `MESHTASTIC_MCP_SEED`      | `mcp-<user>-<host>`                                         | PSK seed for test-harness session (CI override)                     |
-| `MESHTASTIC_MCP_FLASH_LOG` | `<mcp-server>/tests/flash.log`                              | Tee target for pio/esptool/nrfutil subprocess output (TUI tails it) |
+| Var                        | Default                                                     | Purpose                                                                                                          |
+| -------------------------- | ----------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
+| `MESHTASTIC_FIRMWARE_ROOT` | walks up from cwd for `platformio.ini`                      | Pin the firmware repo                                                                                            |
+| `MESHTASTIC_PIO_BIN`       | `~/.platformio/penv/bin/pio` → `$PATH` `pio` → `platformio` | Override `pio` location                                                                                          |
+| `MESHTASTIC_ESPTOOL_BIN`   | `<firmware>/.venv/bin/esptool` → `$PATH`                    | Override esptool                                                                                                 |
+| `MESHTASTIC_NRFUTIL_BIN`   | `$PATH`                                                     | Override nrfutil                                                                                                 |
+| `MESHTASTIC_PICOTOOL_BIN`  | `$PATH`                                                     | Override picotool                                                                                                |
+| `MESHTASTIC_MCP_SEED`      | `mcp-<user>-<host>`                                         | PSK seed for test-harness session (CI override)                                                                  |
+| `MESHTASTIC_MCP_FLASH_LOG` | `<mcp-server>/tests/flash.log`                              | Tee target for pio/esptool/nrfutil subprocess output (TUI tails it)                                              |
+| `MESHTASTIC_MCP_TCP_HOST`  | unset                                                       | `host` or `host:port` of a `meshtasticd` daemon to surface as a TCP device (see "TCP / native-host nodes" below) |
+
+## TCP / native-host nodes
+
+The `native-macos` and `native` PlatformIO envs build a headless `meshtasticd`
+binary that runs on the host (Apple Silicon / Intel macOS, or Linux Portduino).
+The daemon exposes the meshtastic TCP API on port `4403` rather than a USB
+serial endpoint — point the MCP server at it via `MESHTASTIC_MCP_TCP_HOST`:
+
+```bash
+# 1. Build + run a daemon on this host (see variants/native/portduino/platformio.ini
+#    for full Homebrew prereqs and CH341 LoRa-adapter setup).
+pio run -e native-macos
+~/.meshtasticd/meshtasticd
+
+# 2. Point the MCP server at it.
+export MESHTASTIC_MCP_TCP_HOST=localhost     # or host:port, default port 4403
+```
+
+**First-run gotcha — MAC address.** `meshtasticd` derives its MAC from the
+USB adapter's serial-number / product strings. Many cheap CH341 dongles
+(MeshStick included — VID 0x1A86 / PID 0x5512) ship with `iSerialNumber=0`
+and `iProduct=0`, so the daemon aborts on boot with `*** Blank MAC Address
+not allowed!`. Set the MAC explicitly in `config.yaml`:
+
+```yaml
+# Under General:
+MACAddress: 02:CA:FE:BA:BE:01
+```
+
+Use a locally-administered address (first byte's second-LSB set, e.g.
+`02:*` / `06:*` / `0A:*` / `0E:*`) to avoid colliding with a real OUI.
+
+There is also a `--hwid AA:BB:CC:DD:EE:FF` CLI flag visible in
+`meshtasticd --help`, but it is **currently broken** in
+`MAC_from_string()` (`src/platform/portduino/PortduinoGlue.cpp`): the
+function strips colons from its parameter but then reads bytes from the
+global `portduino_config.mac_address`, so `--hwid` is silently overridden
+when `MACAddress:` is also set, and crashes the daemon (uncaught
+`std::invalid_argument: stoi: no conversion`) when it isn't. Use the YAML
+form until that's fixed upstream.
+
+`list_devices` will surface the daemon as `tcp://localhost:4403` with
+`likely_meshtastic=True`, so `device_info`, `list_nodes`, `get_config`,
+`set_config`, `set_owner`, `send_text`, `userprefs_*`, and the admin RPCs
+auto-select it when no `port` is passed. Pass `port="tcp://other-host:9999"`
+explicitly to target a different daemon.
+
+**Tools that don't apply to a TCP/native node** (no USB hardware to operate
+on) raise a clear `ConnectionError` rather than failing mysteriously:
+`pio_flash`, `erase_and_flash`, `update_flash`, `touch_1200bps`,
+`serial_open` (use info/admin tools directly), and the vendor escape hatches
+`esptool_*`, `nrfutil_*`, `picotool_*`. `pio_flash` against a `native*` env
+similarly raises — there's no upload step; use `build` and run the binary
+directly.
+
+The pytest harness in `tests/` still assumes USB-attached devices per role —
+TCP-aware fixtures are not part of this surface yet.

 ## Hardware Test Suite

@@ -1,4 +1,4 @@
-"""Context manager for meshtastic.SerialInterface connections.
+"""Context manager for meshtastic interface connections (serial + TCP).

 Every info/admin tool goes through `connect(port)` so we have a single place
 that:
@@ -6,8 +6,16 @@ that:
  - fails fast if a serial_session is already holding the port,
  - guarantees `.close()` is called, even on exception.

-The `SerialInterface` blocks on construction waiting for the node database;
-that's fine for v1 since every tool is a short-lived request.
+Two transports:
+  - Serial: USB-attached firmware on `/dev/cu.*` / `/dev/ttyUSB*` / `COM*`.
+  - TCP: a `meshtasticd` daemon (e.g. the native macOS / Linux Portduino
+    headless build) addressed as `tcp://host[:port]` (default port 4403).
+    Surfaced by `devices.list_devices()` when `MESHTASTIC_MCP_TCP_HOST` is
+    set, so `resolve_port(None)` auto-selects it like a USB candidate.
+
+Both `SerialInterface` and `TCPInterface` block on construction waiting for
+the node database; that's fine for v1 since every tool is a short-lived
+request.
 """

 from __future__ import annotations
@@ -17,20 +25,107 @@ from typing import Iterator

 from . import devices, registry

+DEFAULT_TCP_PORT = 4403
+TCP_SCHEME = "tcp://"
+TCP_HOST_ENV = "MESHTASTIC_MCP_TCP_HOST"
+

 class ConnectionError(RuntimeError):
    pass


+def is_tcp_port(port: str | None) -> bool:
+    return bool(port) and port.startswith(TCP_SCHEME)
+
+
+def parse_tcp_port(port: str) -> tuple[str, int]:
+    """Parse `tcp://host[:port]` → (host, port). Defaults to 4403.
+
+    Validates host shape (non-empty, no path separators) and port range
+    (1..65535). Raises `ConnectionError` on malformed input — never lets
+    a raw `ValueError` bubble up to a tool surface.
+    """
+    if not port.startswith(TCP_SCHEME):
+        raise ConnectionError(
+            f"Invalid TCP endpoint {port!r}: expected '{TCP_SCHEME}host[:port]'."
+        )
+    rest = port[len(TCP_SCHEME) :]
+    if ":" in rest:
+        host, port_str = rest.rsplit(":", 1)
+        try:
+            tcp_port = int(port_str)
+        except ValueError as e:
+            raise ConnectionError(
+                f"Invalid TCP endpoint {port!r}: port {port_str!r} is not an integer."
+            ) from e
+    else:
+        host, tcp_port = rest, DEFAULT_TCP_PORT
+    if not host:
+        raise ConnectionError(f"Invalid TCP endpoint {port!r}: empty host.")
+    if any(c in host for c in ("/", "\\")):
+        raise ConnectionError(
+            f"Invalid TCP endpoint {port!r}: host {host!r} contains a path "
+            "separator. TCP hostnames cannot contain '/' or '\\' — did you "
+            "pass a serial port path or a Windows drive path by mistake?"
+        )
+    if not (1 <= tcp_port <= 65535):
+        raise ConnectionError(
+            f"Invalid TCP endpoint {port!r}: port {tcp_port} out of range "
+            "(must be 1..65535)."
+        )
+    return host, tcp_port
+
+
+def normalize_tcp_endpoint(endpoint: str) -> str:
+    r"""Normalize `host`, `host:port`, or `tcp://host[:port]` → canonical
+    `tcp://host:port` form. One place that owns the lock-key shape.
+
+    Defers all validation to `parse_tcp_port`, so path-like inputs
+    (`/dev/cu.foo`, `C:\Windows\…`), empty hosts, non-integer ports,
+    and out-of-range ports raise `ConnectionError` here too.
+    """
+    if endpoint.startswith(TCP_SCHEME):
+        canonical = endpoint
+    elif ":" in endpoint:
+        canonical = f"{TCP_SCHEME}{endpoint}"
+    else:
+        canonical = f"{TCP_SCHEME}{endpoint}:{DEFAULT_TCP_PORT}"
+    host, port = parse_tcp_port(canonical)
+    return f"{TCP_SCHEME}{host}:{port}"
+
+
+def reject_if_tcp(port: str | None, tool_name: str) -> None:
+    """Raise if `port` is a TCP endpoint — for tools that need real USB
+    hardware (flash, bootloader, vendor escape hatches, serial monitor).
+
+    Only checks the explicit arg; auto-selection via env var is the caller's
+    responsibility to handle if it matters.
+    """
+    if is_tcp_port(port):
+        raise ConnectionError(
+            f"{tool_name} is not applicable to TCP/native nodes ({port}). "
+            "This tool requires USB-attached hardware."
+        )
+
+
 def resolve_port(port: str | None) -> str:
-    """Pick a port: explicit > sole likely_meshtastic candidate > error."""
+    """Pick a port: explicit > sole likely_meshtastic candidate > error.
+
+    A `tcp://` string passes through (after canonicalization). When `port`
+    is None and no USB candidates are present, `MESHTASTIC_MCP_TCP_HOST`
+    is consulted via `devices.list_devices()`.
+    """
    if port:
+        if is_tcp_port(port):
+            return normalize_tcp_endpoint(port)
        return port
    candidates = [d for d in devices.list_devices() if d["likely_meshtastic"]]
    if not candidates:
        raise ConnectionError(
-            "No Meshtastic devices detected. Plug one in or pass `port` explicitly. "
-            "Run `list_devices` with include_unknown=True to see all serial ports."
+            "No Meshtastic devices detected. Plug one in, set "
+            f"{TCP_HOST_ENV}=<host[:port]> for a meshtasticd daemon, "
+            "or pass `port` explicitly. Run `list_devices` with "
+            "include_unknown=True to see all serial ports."
        )
    if len(candidates) > 1:
        ports = ", ".join(c["port"] for c in candidates)
@@ -43,17 +138,62 @@ def resolve_port(port: str | None) -> str:

@contextmanager
 def connect(port: str | None = None, timeout_s: float = 8.0) -> Iterator:
-    """Open a `meshtastic.SerialInterface` and always close it.
+    """Open a meshtastic interface (serial or TCP) and always close it.

-    Raises `ConnectionError` immediately if another serial session holds the
-    port (a `pio device monitor` in `serial_sessions/`, for instance).
+    For serial: raises `ConnectionError` immediately if another serial
+    session holds the port (a `pio device monitor` in `serial_sessions/`).
+    For TCP: no exclusive-access requirement, so the serial-session check
+    is skipped — but the `port_lock` still serializes parallel `connect()`
+    calls to the same daemon endpoint.
+
+    `timeout_s` is plumbed through to both `SerialInterface(timeout=...)`
+    and `TCPInterface(timeout=...)`. The meshtastic library uses the value
+    as the reply-wait deadline for `localNode.waitForConfig()` during
+    construction and for any subsequent admin RPC. `int()`-converted at
+    the boundary because the upstream API expects whole seconds.
    """
+    resolved = resolve_port(port)
+    timeout = int(timeout_s)
+
+    if is_tcp_port(resolved):
+        from meshtastic.tcp_interface import (
+            TCPInterface,  # type: ignore[import-untyped]
+        )
+
+        host, tcp_port = parse_tcp_port(resolved)
+        lock = registry.port_lock(resolved)
+        if not lock.acquire(blocking=False):
+            raise ConnectionError(
+                f"TCP endpoint {resolved} is busy — another device operation "
+                "is in flight. Retry shortly."
+            )
+
+        iface = None
+        try:
+            iface = TCPInterface(
+                hostname=host,
+                portNumber=tcp_port,
+                connectNow=True,
+                noProto=False,
+                timeout=timeout,
+            )
+            yield iface
+        finally:
+            if iface is not None:
+                try:
+                    iface.close()
+                except Exception:
+                    pass
+            try:
+                lock.release()
+            except RuntimeError:
+                pass
+        return
+
    from meshtastic.serial_interface import (
        SerialInterface,  # type: ignore[import-untyped]
    )

-    resolved = resolve_port(port)
-
    active = registry.active_session_for_port(resolved)
    if active is not None:
        raise ConnectionError(
@@ -70,7 +210,12 @@ def connect(port: str | None = None, timeout_s: float = 8.0) -> Iterator:

    iface = None
    try:
-        iface = SerialInterface(devPath=resolved, connectNow=True, noProto=False)
+        iface = SerialInterface(
+            devPath=resolved,
+            connectNow=True,
+            noProto=False,
+            timeout=timeout,
+        )
        yield iface
    finally:
        if iface is not None:
@@ -1,13 +1,18 @@
-"""USB/serial device discovery.
+"""USB/serial + TCP device discovery.

 Combines the canonical `meshtastic.util.findPorts()` allowlist/blocklist with
 the richer metadata (`serial.tools.list_ports.comports()`) so callers see
 VID/PID, descriptions, and manufacturer strings alongside the "is this likely
 a Meshtastic device" signal.
+
+If `MESHTASTIC_MCP_TCP_HOST=<host[:port]>` is set, a synthetic entry for the
+`meshtasticd` daemon at that endpoint is prepended to the result, so
+`resolve_port(None)` auto-selects it like a USB candidate.
 """

 from __future__ import annotations

+import os
 from typing import Any

 from serial.tools import list_ports
@@ -19,6 +24,45 @@ def _to_hex(value: int | None) -> str | None:
    return f"0x{value:04x}"


+def _tcp_endpoint_from_env() -> dict[str, Any] | None:
+    """Synthesize a TCP device entry from MESHTASTIC_MCP_TCP_HOST, if set.
+
+    If the env var is malformed (non-integer port, path-like host, etc.),
+    return an entry with `likely_meshtastic=False` and the parser error in
+    the description, rather than raising — `list_devices` is the diagnostic
+    tool a user reaches for when their env var isn't working, so it must
+    not crash on misconfiguration.
+    """
+    host = os.environ.get("MESHTASTIC_MCP_TCP_HOST")
+    if not host:
+        return None
+    # Lazy import to avoid a circular dependency (connection imports devices).
+    from . import connection
+
+    try:
+        port = connection.normalize_tcp_endpoint(host)
+        description = "meshtasticd (TCP)"
+        likely = True
+    except connection.ConnectionError as e:
+        # Surface the raw env-var value plus the parser's reason so the
+        # user can see exactly what they set and why it was rejected.
+        # Don't double the scheme if the user already prefixed `tcp://`.
+        port = host if host.startswith(connection.TCP_SCHEME) else f"tcp://{host}"
+        description = f"meshtasticd (TCP) — invalid MESHTASTIC_MCP_TCP_HOST: {e}"
+        likely = False
+    return {
+        "port": port,
+        "vid": None,
+        "pid": None,
+        "description": description,
+        "manufacturer": None,
+        "product": None,
+        "serial_number": None,
+        "likely_meshtastic": likely,
+        "blacklisted": False,
+    }
+
+
 def list_devices(include_unknown: bool = False) -> list[dict[str, Any]]:
    """Return enriched info for serial ports, flagging Meshtastic candidates.

@@ -70,6 +114,22 @@ def list_devices(include_unknown: bool = False) -> list[dict[str, Any]]:
            }
        )

-    # Stable ordering: likely_meshtastic first, then by port path
-    results.sort(key=lambda r: (not r["likely_meshtastic"], r["port"]))
+    # Append the TCP endpoint (if env var set) and sort everything together.
+    tcp_entry = _tcp_endpoint_from_env()
+    if tcp_entry is not None:
+        results.append(tcp_entry)
+
+    # Stable ordering: likely_meshtastic first; within rank, TCP wins over
+    # USB (explicit env-var configuration takes precedence over USB
+    # enumeration); then by port path. A misconfigured TCP entry has
+    # likely_meshtastic=False and lands among the other ignored entries —
+    # it does NOT pre-empt real USB devices at the top of the list.
+    results.sort(
+        key=lambda r: (
+            not r["likely_meshtastic"],
+            not r["port"].startswith("tcp://"),
+            r["port"],
+        )
+    )
+
    return results
@@ -17,7 +17,7 @@ from typing import Any

 import serial

-from . import boards, config, devices, pio, userprefs
+from . import boards, config, connection, devices, pio, userprefs

 # Meshtastic variants use both `esp32s3` and `esp32-s3` style names across
 # variants/*/platformio.ini (no consistency enforced). Accept both spellings.
@@ -46,6 +46,18 @@ def _require_confirm(confirm: bool, operation: str) -> None:
        )


+def _reject_native_env(env: str, operation: str) -> None:
+    """`native*` envs build a host executable, not firmware — there's no
+    upload step. The user wants `build` (or just runs the binary directly).
+    """
+    if env.startswith("native"):
+        raise FlashError(
+            f"{operation} is not applicable for env {env!r}: native envs "
+            "produce a host executable, not flashable firmware. Use `build` "
+            "instead, then run the resulting binary directly."
+        )
+
+
 def _artifacts_for(env: str) -> list[Path]:
    build_dir = config.firmware_root() / ".pio" / "build" / env
    if not build_dir.is_dir():
@@ -141,6 +153,8 @@ def flash(
    that pio performs will pick up the injected values.
    """
    _require_confirm(confirm, "flash")
+    _reject_native_env(env, "flash")
+    connection.reject_if_tcp(port, "flash")
    with userprefs.temporary_overrides(userprefs_overrides) as effective:
        result = pio.run(
            ["run", "-e", env, "-t", "upload", "--upload-port", port],
@@ -200,6 +214,7 @@ def erase_and_flash(
    in that case) since a cached factory.bin would not reflect the new prefs.
    """
    _require_confirm(confirm, "erase_and_flash")
+    connection.reject_if_tcp(port, "erase_and_flash")
    _check_esp32_env(env)

    if userprefs_overrides and skip_build:
@@ -257,6 +272,7 @@ def update_flash(
    overrides are provided we always force a rebuild.
    """
    _require_confirm(confirm, "update_flash")
+    connection.reject_if_tcp(port, "update_flash")
    _check_esp32_env(env)

    if userprefs_overrides and skip_build:
@@ -391,6 +407,7 @@ def touch_1200bps(

    Returns `{ok, former_port, new_port, new_port_vid_pid, attempts}`.
    """
+    connection.reject_if_tcp(port, "touch_1200bps")
    before_list = devices.list_devices(include_unknown=True)
    before_ports = {d["port"] for d in before_list}

@@ -16,7 +16,7 @@ import subprocess
 from pathlib import Path
 from typing import Any, Sequence

-from . import config, pio
+from . import config, connection, pio

 _TIMEOUT_SHORT = 30
 _TIMEOUT_LONG = 600
@@ -102,6 +102,7 @@ def _parse_esptool_chip_info(stdout: str) -> dict[str, Any]:


 def esptool_chip_info(port: str) -> dict[str, Any]:
+    connection.reject_if_tcp(port, "esptool_chip_info")
    binary = config.esptool_bin()
    # `chip_id` prints chip + mac + crystal + features. `flash_id` adds flash.
    combined = _run(binary, ["--port", port, "flash_id"], timeout=_TIMEOUT_SHORT)
@@ -116,6 +117,7 @@ def esptool_chip_info(port: str) -> dict[str, Any]:
 def esptool_erase_flash(port: str, confirm: bool = False) -> dict[str, Any]:
    """Full-chip erase. Leaves the device unbootable until reflashed."""
    _require_confirm(confirm, "esptool_erase_flash")
+    connection.reject_if_tcp(port, "esptool_erase_flash")
    binary = config.esptool_bin()
    # esptool v5 uses `erase-flash`, older uses `erase_flash`. Try the new name
    # first; if it fails with unknown command, retry old.
@@ -134,6 +136,7 @@ def esptool_raw(
    """Raw esptool passthrough. Destructive subcommands require confirm=True."""
    if not args:
        raise ToolError("args must not be empty")
+    connection.reject_if_tcp(port, "esptool_raw")
    # Find the first non-flag arg (the subcommand).
    subcommand = next((a for a in args if not a.startswith("-")), None)
    if subcommand and subcommand.replace("-", "_") in {
@@ -156,6 +159,7 @@ NRFUTIL_DESTRUCTIVE = {"dfu", "settings"}

 def nrfutil_dfu(port: str, package_path: str, confirm: bool = False) -> dict[str, Any]:
    _require_confirm(confirm, "nrfutil_dfu")
+    connection.reject_if_tcp(port, "nrfutil_dfu")
    pkg = Path(package_path).expanduser()
    if not pkg.is_file():
        raise ToolError(f"Package not found: {pkg}")
@@ -213,6 +217,7 @@ def _parse_picotool_info(stdout: str) -> dict[str, Any]:
 def picotool_info(port: str | None = None) -> dict[str, Any]:
    """Read device info from a Pico in BOOTSEL mode. `port` is informational
    only — picotool auto-detects."""
+    connection.reject_if_tcp(port, "picotool_info")
    binary = config.picotool_bin()
    res = _run(binary, ["info", "-a"], timeout=_TIMEOUT_SHORT)
    if res["exit_code"] != 0:
@@ -71,6 +71,10 @@ def open_session(
    If `env` is supplied, pio resolves baud and filters from platformio.ini.
    Otherwise uses the supplied `baud` and `filters` (default `['direct']`).
    """
+    # Lazy import to avoid circular: registry imports serial_session.
+    from . import connection
+
+    connection.reject_if_tcp(port, "serial_open")
    args = ["device", "monitor", "--port", port, "--no-reconnect"]
    effective_filters: list[str]
    effective_baud: int = baud
@@ -0,0 +1,383 @@
+"""TCP transport plumbing in connection.py + devices.py.
+
+Pure-Python tests — no real device or daemon required. Mocks `TCPInterface`
+when exercising `connect()`.
+"""
+
+from __future__ import annotations
+
+from unittest.mock import patch
+
+import pytest
+from meshtastic_mcp import connection, devices
+
+# ---------- helpers --------------------------------------------------------
+
+
+class TestIsTcpPort:
+    def test_tcp_scheme(self) -> None:
+        assert connection.is_tcp_port("tcp://localhost") is True
+        assert connection.is_tcp_port("tcp://localhost:4403") is True
+        assert connection.is_tcp_port("tcp://192.168.1.50:9999") is True
+
+    def test_serial_paths(self) -> None:
+        assert connection.is_tcp_port("/dev/cu.usbmodem1234") is False
+        assert connection.is_tcp_port("/dev/ttyUSB0") is False
+        assert connection.is_tcp_port("COM3") is False
+
+    def test_empty_or_none(self) -> None:
+        assert connection.is_tcp_port(None) is False
+        assert connection.is_tcp_port("") is False
+
+
+class TestParseTcpPort:
+    def test_default_port(self) -> None:
+        assert connection.parse_tcp_port("tcp://localhost") == ("localhost", 4403)
+
+    def test_explicit_port(self) -> None:
+        assert connection.parse_tcp_port("tcp://localhost:9999") == (
+            "localhost",
+            9999,
+        )
+
+    def test_ip_with_port(self) -> None:
+        assert connection.parse_tcp_port("tcp://192.168.1.50:4403") == (
+            "192.168.1.50",
+            4403,
+        )
+
+
+class TestNormalizeTcpEndpoint:
+    def test_bare_host(self) -> None:
+        assert connection.normalize_tcp_endpoint("localhost") == "tcp://localhost:4403"
+
+    def test_host_port(self) -> None:
+        assert (
+            connection.normalize_tcp_endpoint("localhost:5000")
+            == "tcp://localhost:5000"
+        )
+
+    def test_full_url(self) -> None:
+        assert (
+            connection.normalize_tcp_endpoint("tcp://1.2.3.4") == "tcp://1.2.3.4:4403"
+        )
+        assert (
+            connection.normalize_tcp_endpoint("tcp://1.2.3.4:9999")
+            == "tcp://1.2.3.4:9999"
+        )
+
+    def test_idempotent(self) -> None:
+        once = connection.normalize_tcp_endpoint("localhost:4403")
+        twice = connection.normalize_tcp_endpoint(once)
+        assert once == twice == "tcp://localhost:4403"
+
+    def test_path_like_endpoint_rejected(self) -> None:
+        # Serial port paths and Windows drive paths are common config typos
+        # (someone passes a serial path to MESHTASTIC_MCP_TCP_HOST). Reject
+        # rather than producing a nonsense `tcp:///dev/cu.foo:4403` URL.
+        with pytest.raises(connection.ConnectionError, match="path separator"):
+            connection.normalize_tcp_endpoint("/dev/cu.foo")
+        with pytest.raises(connection.ConnectionError):
+            connection.normalize_tcp_endpoint("tcp:///dev/cu.foo:4403")
+        with pytest.raises(connection.ConnectionError):
+            connection.normalize_tcp_endpoint(r"C:\Windows\System32")
+
+    def test_non_integer_port_rejected(self) -> None:
+        with pytest.raises(connection.ConnectionError, match="not an integer"):
+            connection.normalize_tcp_endpoint("tcp://host:notaport")
+        with pytest.raises(connection.ConnectionError, match="not an integer"):
+            connection.normalize_tcp_endpoint("host:notaport")
+
+    def test_empty_host_rejected(self) -> None:
+        with pytest.raises(connection.ConnectionError, match="empty host"):
+            connection.normalize_tcp_endpoint("tcp://:4403")
+
+    def test_port_out_of_range_rejected(self) -> None:
+        with pytest.raises(connection.ConnectionError, match="out of range"):
+            connection.normalize_tcp_endpoint("tcp://host:0")
+        with pytest.raises(connection.ConnectionError, match="out of range"):
+            connection.normalize_tcp_endpoint("tcp://host:65536")
+        with pytest.raises(connection.ConnectionError, match="out of range"):
+            connection.normalize_tcp_endpoint("host:99999")
+
+
+class TestParseTcpPortValidation:
+    def test_missing_scheme_rejected(self) -> None:
+        # parse_tcp_port is a low-level helper that requires the scheme.
+        # Misuse should fail loudly rather than silently mis-parsing.
+        with pytest.raises(connection.ConnectionError, match="expected"):
+            connection.parse_tcp_port("localhost:4403")
+
+    def test_negative_port_rejected(self) -> None:
+        with pytest.raises(connection.ConnectionError, match="out of range"):
+            connection.parse_tcp_port("tcp://host:-1")
+
+
+# ---------- reject_if_tcp --------------------------------------------------
+
+
+class TestRejectIfTcp:
+    def test_rejects_tcp(self) -> None:
+        with pytest.raises(connection.ConnectionError, match="not applicable"):
+            connection.reject_if_tcp("tcp://localhost", "esptool_chip_info")
+
+    def test_passes_through_serial(self) -> None:
+        connection.reject_if_tcp("/dev/cu.usbmodem1", "esptool_chip_info")  # no raise
+
+    def test_passes_through_none(self) -> None:
+        # None means "auto-detect"; not the explicit-arg case we guard.
+        connection.reject_if_tcp(None, "esptool_chip_info")  # no raise
+
+
+# ---------- resolve_port ---------------------------------------------------
+
+
+class TestResolvePort:
+    def test_explicit_serial_passthrough(self) -> None:
+        assert connection.resolve_port("/dev/cu.usbmodem999") == "/dev/cu.usbmodem999"
+
+    def test_explicit_tcp_normalized(self) -> None:
+        assert connection.resolve_port("tcp://localhost") == "tcp://localhost:4403"
+
+    def test_no_port_no_devices_errors(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.delenv("MESHTASTIC_MCP_TCP_HOST", raising=False)
+        with patch.object(devices, "list_devices", return_value=[]):
+            with pytest.raises(
+                connection.ConnectionError, match="No Meshtastic devices"
+            ):
+                connection.resolve_port(None)
+
+    def test_no_port_one_candidate_selected(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.delenv("MESHTASTIC_MCP_TCP_HOST", raising=False)
+        fake = [{"port": "/dev/cu.usbmodem1", "likely_meshtastic": True}]
+        with patch.object(devices, "list_devices", return_value=fake):
+            assert connection.resolve_port(None) == "/dev/cu.usbmodem1"
+
+    def test_no_port_multiple_candidates_errors(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.delenv("MESHTASTIC_MCP_TCP_HOST", raising=False)
+        fake = [
+            {"port": "/dev/cu.usbmodem1", "likely_meshtastic": True},
+            {"port": "/dev/cu.usbmodem2", "likely_meshtastic": True},
+        ]
+        with patch.object(devices, "list_devices", return_value=fake):
+            with pytest.raises(connection.ConnectionError, match="Multiple"):
+                connection.resolve_port(None)
+
+    def test_env_var_surfaces_tcp_via_devices(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.setenv("MESHTASTIC_MCP_TCP_HOST", "localhost")
+        # Don't patch list_devices — let the real env-var path run, but stub
+        # the USB enumeration to keep the test hermetic.
+        with patch("meshtastic_mcp.devices.list_ports.comports", return_value=[]):
+            assert connection.resolve_port(None) == "tcp://localhost:4403"
+
+
+# ---------- devices.list_devices TCP entry --------------------------------
+
+
+class TestDevicesTcpEntry:
+    def test_no_env_var_no_tcp_entry(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.delenv("MESHTASTIC_MCP_TCP_HOST", raising=False)
+        with patch("meshtastic_mcp.devices.list_ports.comports", return_value=[]):
+            ds = devices.list_devices()
+        assert all(not d["port"].startswith("tcp://") for d in ds)
+
+    def test_env_var_adds_tcp_entry(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setenv("MESHTASTIC_MCP_TCP_HOST", "myhost:9999")
+        with patch("meshtastic_mcp.devices.list_ports.comports", return_value=[]):
+            ds = devices.list_devices()
+        tcp = [d for d in ds if d["port"].startswith("tcp://")]
+        assert len(tcp) == 1
+        assert tcp[0]["port"] == "tcp://myhost:9999"
+        assert tcp[0]["likely_meshtastic"] is True
+        assert tcp[0]["description"] == "meshtasticd (TCP)"
+
+    def test_tcp_entry_first_in_results(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setenv("MESHTASTIC_MCP_TCP_HOST", "localhost")
+        with patch("meshtastic_mcp.devices.list_ports.comports", return_value=[]):
+            ds = devices.list_devices()
+        assert ds, "expected at least the TCP entry"
+        assert ds[0]["port"].startswith("tcp://")
+
+    def test_invalid_env_var_does_not_break_list_devices(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        # `list_devices` is the diagnostic tool reached for when an env var
+        # isn't working — it must not throw on misconfiguration.
+        monkeypatch.setenv("MESHTASTIC_MCP_TCP_HOST", "host:notaport")
+        with patch("meshtastic_mcp.devices.list_ports.comports", return_value=[]):
+            ds = devices.list_devices(include_unknown=True)
+        tcp = [d for d in ds if "TCP" in (d["description"] or "")]
+        assert len(tcp) == 1
+        assert tcp[0]["likely_meshtastic"] is False
+        assert "invalid MESHTASTIC_MCP_TCP_HOST" in tcp[0]["description"]
+        assert "not an integer" in tcp[0]["description"]
+
+    def test_invalid_env_var_excluded_from_resolve_port_autodetect(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        # `likely_meshtastic=False` keeps the bad TCP entry out of the
+        # auto-select path — `resolve_port(None)` should still report
+        # "no Meshtastic devices" rather than picking a broken endpoint.
+        monkeypatch.setenv("MESHTASTIC_MCP_TCP_HOST", "host:notaport")
+        with patch("meshtastic_mcp.devices.list_ports.comports", return_value=[]):
+            with pytest.raises(connection.ConnectionError, match="No Meshtastic"):
+                connection.resolve_port(None)
+
+    def test_invalid_env_var_does_not_double_tcp_scheme(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        # If a user mistakenly sets `MESHTASTIC_MCP_TCP_HOST=tcp://host:bad`,
+        # the diagnostic entry must surface the raw value as-is rather than
+        # producing `tcp://tcp://host:bad`.
+        monkeypatch.setenv("MESHTASTIC_MCP_TCP_HOST", "tcp://host:notaport")
+        with patch("meshtastic_mcp.devices.list_ports.comports", return_value=[]):
+            ds = devices.list_devices(include_unknown=True)
+        tcp = [d for d in ds if "TCP" in (d["description"] or "")]
+        assert len(tcp) == 1
+        assert tcp[0]["port"] == "tcp://host:notaport"
+        assert "tcp://tcp://" not in tcp[0]["port"]
+
+    def test_invalid_env_var_does_not_pre_empt_real_usb_devices(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        # Sort ordering: a misconfigured TCP env var must NOT take position 0
+        # ahead of real USB candidates. Position 0 is reserved for the highest
+        # rank (likely_meshtastic=True), with TCP-before-USB as a tiebreaker
+        # within rank.
+        monkeypatch.setenv("MESHTASTIC_MCP_TCP_HOST", "host:notaport")
+
+        # Stub a USB Meshtastic candidate (Espressif VID, port present in
+        # findPorts).
+        class FakeInfo:
+            def __init__(self, device: str, vid: int, pid: int) -> None:
+                self.device = device
+                self.vid = vid
+                self.pid = pid
+                self.description = "Heltec V3"
+                self.manufacturer = "Espressif"
+                self.product = "USB JTAG/serial"
+                self.serial_number = "abc"
+
+        fake_port = FakeInfo("/dev/cu.usbmodem4201", 0x303A, 0x1001)
+        with patch(
+            "meshtastic_mcp.devices.list_ports.comports", return_value=[fake_port]
+        ), patch(
+            "meshtastic.util.findPorts",
+            return_value=["/dev/cu.usbmodem4201"],
+        ):
+            ds = devices.list_devices(include_unknown=True)
+
+        assert ds, "expected at least the USB + TCP entries"
+        # Real USB candidate must be at position 0 — it's likely_meshtastic.
+        assert ds[0]["port"] == "/dev/cu.usbmodem4201"
+        assert ds[0]["likely_meshtastic"] is True
+        # The malformed TCP entry exists but lands among the unlikely entries.
+        tcp = [d for d in ds if "TCP" in (d["description"] or "")]
+        assert len(tcp) == 1
+        assert tcp[0]["likely_meshtastic"] is False
+        assert ds.index(tcp[0]) > 0
+
+    def test_likely_tcp_entry_wins_tiebreak_over_usb(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        # Conversely, a *valid* TCP env var should sort ahead of USB
+        # candidates of equal likely_meshtastic rank — explicit env-var
+        # configuration is a precedence signal.
+        monkeypatch.setenv("MESHTASTIC_MCP_TCP_HOST", "localhost:4403")
+
+        class FakeInfo:
+            def __init__(self, device: str, vid: int, pid: int) -> None:
+                self.device = device
+                self.vid = vid
+                self.pid = pid
+                self.description = "Heltec V3"
+                self.manufacturer = "Espressif"
+                self.product = "USB JTAG/serial"
+                self.serial_number = "abc"
+
+        fake_port = FakeInfo("/dev/cu.usbmodem4201", 0x303A, 0x1001)
+        with patch(
+            "meshtastic_mcp.devices.list_ports.comports", return_value=[fake_port]
+        ), patch(
+            "meshtastic.util.findPorts",
+            return_value=["/dev/cu.usbmodem4201"],
+        ):
+            ds = devices.list_devices()
+
+        assert ds[0]["port"] == "tcp://localhost:4403"
+        assert ds[0]["likely_meshtastic"] is True
+
+
+# ---------- connect() routing ---------------------------------------------
+
+
+class TestConnectRoutesTcp:
+    def test_connect_uses_tcp_interface_for_tcp_port(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Verify the TCP branch instantiates `TCPInterface(hostname, portNumber)`
+        and never touches `SerialInterface`."""
+        # Make sure the env var doesn't leak in and confuse resolve_port.
+        monkeypatch.delenv("MESHTASTIC_MCP_TCP_HOST", raising=False)
+
+        with patch("meshtastic.tcp_interface.TCPInterface") as mock_tcp, patch(
+            "meshtastic.serial_interface.SerialInterface"
+        ) as mock_serial:
+            mock_tcp.return_value.close.return_value = None
+            with connection.connect(port="tcp://example.com:1234", timeout_s=12.0):
+                pass
+
+        mock_tcp.assert_called_once_with(
+            hostname="example.com",
+            portNumber=1234,
+            connectNow=True,
+            noProto=False,
+            timeout=12,
+        )
+        mock_serial.assert_not_called()
+
+    def test_connect_plumbs_timeout_to_serial_interface(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Verify the serial branch also propagates `timeout_s` so callers
+        passing a custom timeout to `device_info` / `list_nodes` / etc. don't
+        silently get the library default."""
+        monkeypatch.delenv("MESHTASTIC_MCP_TCP_HOST", raising=False)
+
+        with patch("meshtastic.serial_interface.SerialInterface") as mock_serial, patch(
+            "meshtastic.tcp_interface.TCPInterface"
+        ) as mock_tcp:
+            mock_serial.return_value.close.return_value = None
+            with connection.connect(port="/dev/cu.fake", timeout_s=20.0):
+                pass
+
+        mock_serial.assert_called_once_with(
+            devPath="/dev/cu.fake",
+            connectNow=True,
+            noProto=False,
+            timeout=20,
+        )
+        mock_tcp.assert_not_called()
+
+    def test_connect_releases_lock_on_tcp_failure(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.delenv("MESHTASTIC_MCP_TCP_HOST", raising=False)
+        with patch("meshtastic.tcp_interface.TCPInterface") as mock_tcp:
+            mock_tcp.side_effect = RuntimeError("boom")
+            with pytest.raises(RuntimeError, match="boom"):
+                with connection.connect(port="tcp://locktest:4403"):
+                    pass
+
+        # Lock should be released — a second connect attempt must not fail
+        # with "busy".
+        with patch("meshtastic.tcp_interface.TCPInterface") as mock_tcp:
+            mock_tcp.return_value.close.return_value = None
+            with connection.connect(port="tcp://locktest:4403"):
+                pass
@@ -120,12 +120,12 @@ lib_deps =
 [radiolib_base]
 lib_deps =
 	# renovate: datasource=github-tags depName=RadioLib packageName=jgromes/RadioLib
-	https://github.com/jgromes/RadioLib/archive/refs/tags/7.6.0.zip
+	https://github.com/jgromes/RadioLib/archive/afe72ae46a343e15e3cac7f26ac585c7f98bffe5.zip

 [device-ui_base]
 lib_deps =
 	# renovate: datasource=git-refs depName=meshtastic/device-ui packageName=https://github.com/meshtastic/device-ui gitBranch=master
-	https://github.com/meshtastic/device-ui/archive/56e1da4e7d30abcd746a2092a30e422f8cf5fc2b.zip
+	https://github.com/meshtastic/device-ui/archive/4bf593a82100b911ff816dddf7158ffdee2114cd.zip

 ; Common libs for environmental measurements in telemetry module
 [environmental_base]
@@ -170,8 +170,8 @@ lib_deps =
 	https://github.com/EmotiBit/EmotiBit_MLX90632/archive/refs/tags/v1.0.8.zip
 	# renovate: datasource=github-tags depName=Adafruit MLX90614 packageName=adafruit/Adafruit_MLX90614
 	https://github.com/adafruit/Adafruit-MLX90614-Library/archive/refs/tags/2.1.6.zip
-	# renovate: datasource=git-refs depName=INA3221 packageName=https://github.com/sgtwilko/INA3221 gitBranch=FixOverflow
-	https://github.com/sgtwilko/INA3221/archive/bb03d7e9bfcc74fc798838a54f4f99738f29fc6a.zip
+	# renovate: datasource=github-tags depName=INA3221_RT packageName=RobTillaart/INA3221_RT
+	https://github.com/RobTillaart/INA3221_RT/archive/refs/tags/0.4.2.zip
 	# renovate: datasource=github-tags depName=QMC5883L Compass packageName=mprograms/QMC5883LCompass
 	https://github.com/mprograms/QMC5883LCompass/archive/refs/tags/v1.2.3.zip
 	# renovate: datasource=github-tags depName=DFRobot_RTU packageName=dfrobot/DFRobot_RTU
@@ -26,6 +26,8 @@ SOFTWARE.*/

 #include "DebugConfiguration.h"

+#include <memory>
+
 #ifdef ARCH_PORTDUINO
 #include "platform/portduino/PortduinoGlue.h"
 #endif
@@ -119,27 +121,22 @@ 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)
 {
-    char *message;
-    size_t initialLen;
-    size_t len;
-    bool result;
+    // 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);

-    initialLen = strlen(fmt);
+    if (needed < 0)
+        return false; // encoding error

-    message = new char[initialLen + 1];
+    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;

-    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;
+    return this->_sendLog(pri, appName, message.get());
 }

 inline bool Syslog::_sendLog(uint16_t pri, const char *appName, const char *message)
@@ -79,28 +79,46 @@ bool copyFile(const char *from, const char *to)
 bool renameFile(const char *pathFrom, const char *pathTo)
 {
 #ifdef FSCom
-
-#ifdef ARCH_ESP32
-    // take SPI Lock
    spiLock->lock();
-    // rename was fixed for ESP32 IDF LittleFS in April
    bool result = FSCom.rename(pathFrom, pathTo);
    spiLock->unlock();
    return result;
 #else
-    // copyFile does its own locking.
-    if (copyFile(pathFrom, pathTo) && FSCom.remove(pathFrom)) {
-        return true;
-    } else {
-        return false;
-    }
-#endif
-
+    return false;
 #endif
 }

 #include <vector>

+/**
+ * @brief Platform-agnostic filesystem format / wipe.
+ *
+ * On embedded targets (ESP32, NRF52, STM32WL, RP2040) this calls the
+ * native FSCom.format() which erases and reinitialises the LittleFS
+ * partition.
+ *
+ * On Portduino the fs::FS backend has no format() method. We instead
+ * delete /prefs (the only meshtastic data directory written at runtime)
+ * and return. rmDir("/prefs") is already called unconditionally by
+ * factoryReset() so this is a proven primitive on Portduino.
+ * FSBegin() is a no-op (#define FSBegin() true) on Portduino.
+ *
+ * @return true on success, false on failure or if no filesystem is configured.
+ */
+bool fsFormat()
+{
+#ifdef FSCom
+#if defined(ARCH_PORTDUINO)
+    rmDir("/prefs");
+    return FSBegin();
+#else
+    return FSCom.format();
+#endif
+#else
+    return false;
+#endif
+}
+
 /**
 * @brief Get the list of files in a directory.
 *
@@ -123,23 +141,21 @@ std::vector<meshtastic_FileInfo> getFiles(const char *dirname, uint8_t levels)

    File file = root.openNextFile();
    while (file) {
+#ifdef ARCH_ESP32
+        const char *filepath = file.path();
+#else
+        const char *filepath = file.name();
+#endif
        if (file.isDirectory() && !String(file.name()).endsWith(".")) {
            if (levels) {
-#ifdef ARCH_ESP32
-                std::vector<meshtastic_FileInfo> subDirFilenames = getFiles(file.path(), levels - 1);
-#else
-                std::vector<meshtastic_FileInfo> subDirFilenames = getFiles(file.name(), levels - 1);
-#endif
+                std::vector<meshtastic_FileInfo> subDirFilenames = getFiles(filepath, levels - 1);
                filenames.insert(filenames.end(), subDirFilenames.begin(), subDirFilenames.end());
                file.close();
            }
        } else {
            meshtastic_FileInfo fileInfo = {"", static_cast<uint32_t>(file.size())};
-#ifdef ARCH_ESP32
-            strcpy(fileInfo.file_name, file.path());
-#else
-            strcpy(fileInfo.file_name, file.name());
-#endif
+            strncpy(fileInfo.file_name, filepath, sizeof(fileInfo.file_name) - 1);
+            fileInfo.file_name[sizeof(fileInfo.file_name) - 1] = '\0';
            if (!String(fileInfo.file_name).endsWith(".")) {
                filenames.push_back(fileInfo);
            }
@@ -163,98 +179,59 @@ std::vector<meshtastic_FileInfo> getFiles(const char *dirname, uint8_t levels)
 void listDir(const char *dirname, uint8_t levels, bool del)
 {
 #ifdef FSCom
-#if (defined(ARCH_ESP32) || defined(ARCH_RP2040) || defined(ARCH_PORTDUINO))
    char buffer[255];
-#endif
    File root = FSCom.open(dirname, FILE_O_READ);
-    if (!root) {
+    if (!root || !root.isDirectory())
        return;
-    }
-    if (!root.isDirectory()) {
-        return;
-    }

    File file = root.openNextFile();
-    while (
-        file &&
-        file.name()[0]) { // This file.name() check is a workaround for a bug in the Adafruit LittleFS nrf52 glue (see issue 4395)
+    while (file && file.name()[0]) { // file.name()[0] check: workaround for Adafruit LittleFS nRF52 bug #4395
+#ifdef ARCH_ESP32
+        const char *filepath = file.path();
+#else
+        const char *filepath = file.name();
+#endif
        if (file.isDirectory() && !String(file.name()).endsWith(".")) {
            if (levels) {
-#ifdef ARCH_ESP32
-                listDir(file.path(), levels - 1, del);
+                listDir(filepath, levels - 1, del);
                if (del) {
-                    LOG_DEBUG("Remove %s", file.path());
-                    strncpy(buffer, file.path(), sizeof(buffer));
+                    LOG_DEBUG("Remove %s", filepath);
+                    strncpy(buffer, filepath, sizeof(buffer) - 1);
+                    buffer[sizeof(buffer) - 1] = '\0';
                    file.close();
                    FSCom.rmdir(buffer);
                } else {
                    file.close();
                }
-#elif (defined(ARCH_RP2040) || defined(ARCH_PORTDUINO))
-                listDir(file.name(), levels - 1, del);
-                if (del) {
-                    LOG_DEBUG("Remove %s", file.name());
-                    strncpy(buffer, file.name(), sizeof(buffer));
-                    file.close();
-                    FSCom.rmdir(buffer);
-                } else {
-                    file.close();
-                }
-#else
-                LOG_DEBUG(" %s (directory)", file.name());
-                listDir(file.name(), levels - 1, del);
-                file.close();
-#endif
            }
        } else {
-#ifdef ARCH_ESP32
            if (del) {
-                LOG_DEBUG("Delete %s", file.path());
-                strncpy(buffer, file.path(), sizeof(buffer));
+                LOG_DEBUG("Delete %s", filepath);
+                strncpy(buffer, filepath, sizeof(buffer) - 1);
+                buffer[sizeof(buffer) - 1] = '\0';
                file.close();
                FSCom.remove(buffer);
            } else {
-                LOG_DEBUG(" %s (%i Bytes)", file.path(), file.size());
+                LOG_DEBUG(" %s (%i Bytes)", filepath, file.size());
                file.close();
            }
-#elif (defined(ARCH_RP2040) || defined(ARCH_PORTDUINO))
-            if (del) {
-                LOG_DEBUG("Delete %s", file.name());
-                strncpy(buffer, file.name(), sizeof(buffer));
-                file.close();
-                FSCom.remove(buffer);
-            } else {
-                LOG_DEBUG(" %s (%i Bytes)", file.name(), file.size());
-                file.close();
-            }
-#else
-            LOG_DEBUG("   %s (%i Bytes)", file.name(), file.size());
-            file.close();
-#endif
        }
        file = root.openNextFile();
    }
 #ifdef ARCH_ESP32
-    if (del) {
-        LOG_DEBUG("Remove %s", root.path());
-        strncpy(buffer, root.path(), sizeof(buffer));
-        root.close();
-        FSCom.rmdir(buffer);
-    } else {
-        root.close();
-    }
-#elif (defined(ARCH_RP2040) || defined(ARCH_PORTDUINO))
-    if (del) {
-        LOG_DEBUG("Remove %s", root.name());
-        strncpy(buffer, root.name(), sizeof(buffer));
-        root.close();
-        FSCom.rmdir(buffer);
-    } else {
-        root.close();
-    }
+    const char *rootpath = root.path();
 #else
-    root.close();
+    const char *rootpath = root.name();
 #endif
+    if (del) {
+        LOG_DEBUG("Remove %s", rootpath);
+        strncpy(buffer, rootpath, sizeof(buffer) - 1);
+        buffer[sizeof(buffer) - 1] = '\0';
+        root.close();
+        FSCom.rmdir(buffer);
+    } else {
+        root.close();
+    }
 #endif
 }

@@ -268,14 +245,7 @@ void listDir(const char *dirname, uint8_t levels, bool del)
 void rmDir(const char *dirname)
 {
 #ifdef FSCom
-
-#if (defined(ARCH_ESP32) || defined(ARCH_RP2040) || defined(ARCH_PORTDUINO))
    listDir(dirname, 10, true);
-#elif defined(ARCH_NRF52)
-    // nRF52 implementation of LittleFS has a recursive delete function
-    FSCom.rmdir_r(dirname);
-#endif
-
 #endif
 }

@@ -52,6 +52,7 @@ void fsInit();
 void fsListFiles();
 bool copyFile(const char *from, const char *to);
 bool renameFile(const char *pathFrom, const char *pathTo);
+bool fsFormat();
 std::vector<meshtastic_FileInfo> getFiles(const char *dirname, uint8_t levels);
 void listDir(const char *dirname, uint8_t levels, bool del = false);
 void rmDir(const char *dirname);
@@ -53,8 +53,7 @@ class GPSStatus : public Status
    int32_t getLatitude() const
    {
        if (config.position.fixed_position) {
-            meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
-            return node->position.latitude_i;
+            return localPosition.latitude_i;
        } else {
            return p.latitude_i;
        }
@@ -63,8 +62,7 @@ class GPSStatus : public Status
    int32_t getLongitude() const
    {
        if (config.position.fixed_position) {
-            meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
-            return node->position.longitude_i;
+            return localPosition.longitude_i;
        } else {
            return p.longitude_i;
        }
@@ -73,8 +71,7 @@ class GPSStatus : public Status
    int32_t getAltitude() const
    {
        if (config.position.fixed_position) {
-            meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
-            return node->position.altitude;
+            return localPosition.altitude;
        } else {
            return p.altitude;
        }
@@ -781,8 +781,10 @@ void Power::reboot()
    rp2040.reboot();
 #elif defined(ARCH_PORTDUINO)
    deInitApiServer();
+#ifdef __linux__
    if (aLinuxInputImpl)
        aLinuxInputImpl->deInit();
+#endif
    SPI.end();
    Wire.end();
    Serial1.end();
@@ -1,8 +1,8 @@
 #pragma once

 #include "../freertosinc.h"
+#include "Print.h"
 #include "mesh/generated/meshtastic/mesh.pb.h"
-#include <Print.h>
 #include <stdarg.h>
 #include <string>

@@ -7,10 +7,6 @@ static File openFile(const char *filename, bool fullAtomic)
 {
    concurrency::LockGuard g(spiLock);
    LOG_DEBUG("Opening %s, fullAtomic=%d", filename, fullAtomic);
-#ifdef ARCH_NRF52
-    FSCom.remove(filename);
-    return FSCom.open(filename, FILE_O_WRITE);
-#endif
    if (!fullAtomic) {
        FSCom.remove(filename); // Nuke the old file to make space (ignore if it !exists)
    }
@@ -67,9 +63,6 @@ bool SafeFile::close()
    f.close();
    spiLock->unlock();

-#ifdef ARCH_NRF52
-    return true;
-#endif
    if (!testReadback())
        return false;

@@ -14,6 +14,11 @@ Lock::Lock() : handle(xSemaphoreCreateBinary())
    }
 }

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

+Lock::~Lock() {}
+
 void Lock::lock() {}

 void Lock::unlock() {}
@@ -12,6 +12,7 @@ class Lock
 {
  public:
    Lock();
+    ~Lock();

    Lock(const Lock &) = delete;
    Lock &operator=(const Lock &) = delete;
@@ -80,7 +80,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.

 // Pre-hop drop handling (compile-time flag).
 #ifndef MESHTASTIC_PREHOP_DROP
-#define MESHTASTIC_PREHOP_DROP 0
+#define MESHTASTIC_PREHOP_DROP 1
 #endif

 /// Convert a preprocessor name into a quoted string
@@ -162,6 +162,9 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #elif defined(HELTEC_MESH_NODE_T096)
 #define NUM_PA_POINTS 22
 #define TX_GAIN_LORA 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 13, 13, 13, 12, 11, 10, 9, 8, 7
+#elif defined(HELTEC_V4_R8)
+#define NUM_PA_POINTS 22
+#define TX_GAIN_LORA 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 12, 12, 11, 11, 10, 9, 8, 7
 #else
 // If a board enables USE_KCT8103L_PA but does not match a known variant and has
 // not already provided a PA curve, fail at compile time to avoid unsafe defaults.
@@ -11,7 +11,8 @@ enum LoRaRadioType {
    SX1280_RADIO,
    LR1110_RADIO,
    LR1120_RADIO,
-    LR1121_RADIO
+    LR1121_RADIO,
+    LR2021_RADIO
 };

 extern LoRaRadioType radioType;
@@ -1025,10 +1025,13 @@ void GPS::up()
    setPowerState(GPS_ACTIVE);
 }

-// We've got a GPS lock. Enter a low power state, potentially.
+// We've finished a GPS search cycle (lock or timeout). Enter a low power state, potentially.
 void GPS::down()
 {
-    scheduling.informGotLock();
+    if (hasValidLocation)
+        scheduling.informGotLock();
+    else
+        scheduling.informSearchFailed();
    uint32_t predictedSearchDuration = scheduling.predictedSearchDurationMs();
    uint32_t sleepTime = scheduling.msUntilNextSearch();
    uint32_t updateInterval = Default::getConfiguredOrDefaultMs(config.position.gps_update_interval);
@@ -1553,7 +1556,12 @@ std::unique_ptr<GPS> GPS::createGps()
        _en_gpio = PIN_GPS_EN;
 #endif
 #ifdef ARCH_PORTDUINO
-    if (!portduino_config.has_gps)
+    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
        return nullptr;
 #endif
    if (!_rx_gpio || !_serial_gps) // Configured to have no GPS at all
@@ -15,6 +15,19 @@ 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.
@@ -25,6 +38,7 @@ void GPSUpdateScheduling::reset()
    searchEndedMs = 0;
    searchCount = 0;
    predictedMsToGetLock = 0;
+    consecutiveFailures = 0;
 }

 // How many milliseconds before we should next search for GPS position
@@ -36,6 +50,20 @@ 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;
@@ -70,20 +98,29 @@ bool GPSUpdateScheduling::isUpdateDue()
 // Have we been searching for a GPS position for too long?
 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
+    uint32_t elapsed = elapsedSearchMs();
+
+    // Anything over 15 minutes is too long, regardless of the broadcast interval.
+    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);
-    // If broadcast interval set to max, no such thing as "too long"
-    if (maxSearchMs == UINT32_MAX)
-        return false;

    // If we've been searching longer than our position broadcast interval: that's too long
-    else if (elapsedSearchMs() > maxSearchMs)
+    if (elapsed > maxSearchMs)
        return true;

    // Otherwise, not too long yet!
-    else
-        return false;
+    return false;
 }

 // Updates the predicted time-to-get-lock, by exponentially smoothing the latest observation
@@ -8,7 +8,8 @@ class GPSUpdateScheduling
  public:
    // Marks the time of these events, for calculation use
    void informSearching();
-    void informGotLock(); // Predicted lock-time is recalculated here
+    void informGotLock();      // Predicted lock-time is recalculated here
+    void informSearchFailed(); // Search ended without a fix; prediction is left untouched

    void reset();           // Reset the prediction - after GPS::disable() / GPS::enable()
    bool isUpdateDue();     // Is it time to begin searching for a GPS position?
@@ -24,6 +25,7 @@ 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".
 };
@@ -524,6 +524,11 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
            delay(100);
 #endif
 #if !ARCH_PORTDUINO
+#if defined(USE_ST7789) && defined(VTFT_CTRL)
+            // Ensure panel power rail is enabled before sending wake commands.
+            pinMode(VTFT_CTRL, OUTPUT);
+            digitalWrite(VTFT_CTRL, LOW);
+#endif
            dispdev->displayOn();
 #endif

@@ -545,10 +550,6 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
            ui->init();
 #endif
 #if defined(USE_ST7789) && defined(VTFT_LEDA)
-#ifdef VTFT_CTRL
-            pinMode(VTFT_CTRL, OUTPUT);
-            digitalWrite(VTFT_CTRL, LOW);
-#endif
            ui->init();
 #ifdef ESP_PLATFORM
            analogWrite(VTFT_LEDA, BRIGHTNESS_DEFAULT);
@@ -589,23 +590,22 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
 #endif
 #ifdef USE_ST7789
            SPI1.end();
-#if defined(ARCH_ESP32)
+            // Keep TFT control pins in deterministic states while timed-off.
+            // Floating/default pin states can corrupt panel edge rows on wake.
 #ifdef VTFT_LEDA
-            pinMode(VTFT_LEDA, ANALOG);
+            pinMode(VTFT_LEDA, OUTPUT);
+            digitalWrite(VTFT_LEDA, !TFT_BACKLIGHT_ON);
 #endif
 #ifdef VTFT_CTRL
-            pinMode(VTFT_CTRL, ANALOG);
-#endif
-            pinMode(ST7789_RESET, ANALOG);
-            pinMode(ST7789_RS, ANALOG);
-            pinMode(ST7789_NSS, ANALOG);
-#else
-            nrf_gpio_cfg_default(VTFT_LEDA);
-            nrf_gpio_cfg_default(VTFT_CTRL);
-            nrf_gpio_cfg_default(ST7789_RESET);
-            nrf_gpio_cfg_default(ST7789_RS);
-            nrf_gpio_cfg_default(ST7789_NSS);
+            pinMode(VTFT_CTRL, OUTPUT);
+            digitalWrite(VTFT_CTRL, HIGH);
 #endif
+            pinMode(ST7789_RESET, OUTPUT);
+            digitalWrite(ST7789_RESET, HIGH);
+            pinMode(ST7789_RS, OUTPUT);
+            digitalWrite(ST7789_RS, HIGH);
+            pinMode(ST7789_NSS, OUTPUT);
+            digitalWrite(ST7789_NSS, HIGH);
 #endif
 #ifdef USE_ST7796
            SPI1.end();
@@ -1285,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() && n->is_favorite) {
+            if (n && n->num != nodeDB->getNodeNum() && nodeInfoLiteIsFavorite(n)) {
                favoriteFrames.push_back(graphics::UIRenderer::drawFavoriteNode);
            }
        }
@@ -1670,7 +1670,7 @@ int Screen::handleTextMessage(const meshtastic_MeshPacket *packet)
            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 *longName = nodeInfoLiteHasUser(node) ? node->long_name : nullptr;

            const char *msgRaw = reinterpret_cast<const char *>(packet->decoded.payload.bytes);

@@ -422,7 +422,7 @@ static LGFX *tft = nullptr;

 #elif defined(ST7789_CS)
 #include <LovyanGFX.hpp> // Graphics and font library for ST7735 driver chip
-#ifdef HELTEC_V4_TFT
+#if defined(HELTEC_V4_TFT) || defined(HELTEC_V4_R8_TFT)
 #include "chsc6x.h"
 #include "lgfx/v1/Touch.hpp"
 namespace lgfx
@@ -444,7 +444,11 @@ class TOUCH_CHSC6X : public ITouch
    bool init(void) override
    {
        if (chsc6xTouch == nullptr) {
+#if (TOUCH_I2C_PORT == 1)
            chsc6xTouch = new chsc6x(&Wire1, TOUCH_SDA_PIN, TOUCH_SCL_PIN, TOUCH_INT_PIN, TOUCH_RST_PIN);
+#else
+            chsc6xTouch = new chsc6x(&Wire, TOUCH_SDA_PIN, TOUCH_SCL_PIN, TOUCH_INT_PIN, TOUCH_RST_PIN);
+#endif
        }
        chsc6xTouch->chsc6x_init();
        return true;
@@ -481,7 +485,7 @@ class LGFX : public lgfx::LGFX_Device
 #if HAS_TOUCHSCREEN
 #if defined(T_WATCH_S3) || defined(ELECROW)
    lgfx::Touch_FT5x06 _touch_instance;
-#elif defined(HELTEC_V4_TFT)
+#elif defined(HELTEC_V4_TFT) || defined(HELTEC_V4_R8_TFT)
    lgfx::TOUCH_CHSC6X _touch_instance;
 #else
    lgfx::Touch_GT911 _touch_instance;
@@ -500,7 +504,11 @@ class LGFX : public lgfx::LGFX_Device
            cfg.freq_write = SPI_FREQUENCY; // SPI clock for transmission (up to 80MHz, rounded to the value obtained by dividing
                                            // 80MHz by an integer)
            cfg.freq_read = SPI_READ_FREQUENCY; // SPI clock when receiving
-            cfg.spi_3wire = false;
+#ifdef SPI_3_WIRE
+            cfg.spi_3wire = SPI_3_WIRE;
+#else
+            cfg.spi_3wire = true;                      // Set to true if reception is done on the MOSI pin
+#endif
            cfg.use_lock = true;               // Set to true to use transaction locking
            cfg.dma_channel = SPI_DMA_CH_AUTO; // SPI_DMA_CH_AUTO; // Set DMA channel to use (0=not use DMA / 1=1ch / 2=ch /
                                               // SPI_DMA_CH_AUTO=auto setting)
@@ -550,8 +558,11 @@ class LGFX : public lgfx::LGFX_Device
            cfg.rgb_order = false;                        // Set to true if the panel's red and blue are swapped
            cfg.dlen_16bit =
                false;             // Set to true for panels that transmit data length in 16-bit units with 16-bit parallel or SPI
+#if defined(HAS_SDCARD)
            cfg.bus_shared = true; // If the bus is shared with the SD card, set to true (bus control with drawJpgFile etc.)
-
+#else
+            cfg.bus_shared = false;
+#endif
            // Set the following only when the display is shifted with a driver with a variable number of pixels, such as the
            // ST7735 or ILI9163.
            // cfg.memory_width = TFT_WIDTH;   // Maximum width supported by the driver IC
@@ -845,10 +845,10 @@ void menuHandler::messageViewModeMenu()
    // Encode peers
    for (size_t i = 0; i < uniquePeers.size(); ++i) {
        uint32_t peer = uniquePeers[i];
-        auto node = nodeDB->getMeshNode(peer);
+        const auto *node = nodeDB->getMeshNode(peer);
        std::string name;
-        if (node && node->has_user)
-            name = sanitizeString(node->user.long_name).substr(0, 15);
+        if (nodeInfoLiteHasUser(node))
+            name = sanitizeString(node->long_name).substr(0, 15);
        else {
            char buf[20];
            snprintf(buf, sizeof(buf), "Node %08X", peer);
@@ -1355,14 +1355,14 @@ void menuHandler::manageNodeMenu()
    static int optionsEnumArray[enumEnd] = {Back};
    int options = 1;

-    if (node->is_favorite) {
+    if (nodeInfoLiteIsFavorite(node)) {
        optionsArray[options] = "Unfavorite";
    } else {
        optionsArray[options] = "Favorite";
    }
    optionsEnumArray[options++] = Favorite;

-    bool isMuted = (node->bitfield & NODEINFO_BITFIELD_IS_MUTED_MASK) != 0;
+    bool isMuted = nodeInfoLiteIsMuted(node);
    if (isMuted) {
        optionsArray[options] = "Unmute Notifications";
    } else {
@@ -1376,7 +1376,7 @@ void menuHandler::manageNodeMenu()
    optionsArray[options] = "Key Verification";
    optionsEnumArray[options++] = KeyVerification;

-    if (node->is_ignored) {
+    if (nodeInfoLiteIsIgnored(node)) {
        optionsArray[options] = "Unignore Node";
    } else {
        optionsArray[options] = "Ignore Node";
@@ -1386,8 +1386,8 @@ void menuHandler::manageNodeMenu()
    BannerOverlayOptions bannerOptions;

    std::string title = "";
-    if (node->has_user && node->user.long_name && node->user.long_name[0]) {
-        title += sanitizeString(node->user.long_name).substr(0, 15);
+    if (nodeInfoLiteHasUser(node) && node->long_name[0]) {
+        title += sanitizeString(node->long_name).substr(0, 15);
    } else {
        char buf[20];
        snprintf(buf, sizeof(buf), "%08X", (unsigned int)node->num);
@@ -1409,7 +1409,7 @@ void menuHandler::manageNodeMenu()
            if (!n) {
                return;
            }
-            if (n->is_favorite) {
+            if (nodeInfoLiteIsFavorite(n)) {
                LOG_INFO("Removing node %08X from favorites", menuHandler::pickedNodeNum);
                nodeDB->set_favorite(false, menuHandler::pickedNodeNum);
            } else {
@@ -1426,13 +1426,9 @@ void menuHandler::manageNodeMenu()
                return;
            }

-            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);
-            }
+            const bool wasMuted = nodeInfoLiteIsMuted(n);
+            nodeInfoLiteSetBit(n, NODEINFO_BITFIELD_IS_MUTED_MASK, !wasMuted);
+            LOG_INFO(wasMuted ? "Unmuted node %08X" : "Muted node %08X", menuHandler::pickedNodeNum);
            nodeDB->notifyObservers(true);
            nodeDB->saveToDisk();
            screen->setFrames(graphics::Screen::FOCUS_PRESERVE);
@@ -1461,11 +1457,11 @@ void menuHandler::manageNodeMenu()
                return;
            }

-            if (n->is_ignored) {
-                n->is_ignored = false;
+            if (nodeInfoLiteIsIgnored(n)) {
+                nodeInfoLiteSetBit(n, NODEINFO_BITFIELD_IS_IGNORED_MASK, false);
                LOG_INFO("Unignoring node %08X", menuHandler::pickedNodeNum);
            } else {
-                n->is_ignored = true;
+                nodeInfoLiteSetBit(n, NODEINFO_BITFIELD_IS_IGNORED_MASK, true);
                LOG_INFO("Ignoring node %08X", menuHandler::pickedNodeNum);
            }
            nodeDB->notifyObservers(true);
@@ -2079,9 +2075,9 @@ void menuHandler::removeFavoriteMenu()
    static const char *optionsArray[] = {"Back", "Yes"};
    BannerOverlayOptions bannerOptions;
    std::string message = "Unfavorite This Node?\n";
-    auto node = nodeDB->getMeshNode(graphics::UIRenderer::currentFavoriteNodeNum);
-    if (node && node->has_user) {
-        message += sanitizeString(node->user.long_name).substr(0, 15);
+    const auto *node = nodeDB->getMeshNode(graphics::UIRenderer::currentFavoriteNodeNum);
+    if (nodeInfoLiteHasUser(node)) {
+        message += sanitizeString(node->long_name).substr(0, 15);
    }
    bannerOptions.message = message.c_str();
    bannerOptions.optionsArrayPtr = optionsArray;
@@ -462,8 +462,8 @@ void drawTextMessageFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
    }
    case ThreadMode::DIRECT: {
        meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(currentPeer);
-        if (node && node->has_user && node->user.short_name[0]) {
-            snprintf(titleStr, sizeof(titleStr), "@%s", node->user.short_name);
+        if (nodeInfoLiteHasUser(node) && node->short_name[0]) {
+            snprintf(titleStr, sizeof(titleStr), "@%s", node->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 (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);
+        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);
            }
            senderName[sizeof(senderName) - 1] = '\0';
        }
@@ -599,18 +599,17 @@ 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 && node_recipient && node_recipient->has_user) {
-            if (node_recipient->user.long_name[0]) {
-                strncpy(senderName, node_recipient->user.long_name, sizeof(senderName) - 1);
+        if (mine && nodeInfoLiteHasUser(node_recipient)) {
+            if (node_recipient->long_name[0]) {
+                strncpy(senderName, node_recipient->long_name, sizeof(senderName) - 1);
                senderName[sizeof(senderName) - 1] = '\0';
-            } else if (node_recipient->user.short_name[0]) {
-                strncpy(senderName, node_recipient->user.short_name, sizeof(senderName) - 1);
+            } else if (node_recipient->short_name[0]) {
+                strncpy(senderName, node_recipient->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 && (!node_recipient || !node_recipient->has_user ||
-                     (!node_recipient->user.long_name[0] && !node_recipient->user.short_name[0]))) {
+        if (mine && (!nodeInfoLiteHasUser(node_recipient) || (!node_recipient->long_name[0] && !node_recipient->short_name[0]))) {
            snprintf(senderName, sizeof(senderName), "(%08x)", m.dest);
        }

@@ -1073,12 +1072,12 @@ void handleNewMessage(OLEDDisplay *display, const StoredMessage &sm, const mesht
        // Banner logic
        const meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(packet.from);
        char longName[64] = "?";
-        if (node && node->has_user) {
-            if (node->user.long_name[0]) {
-                strncpy(longName, node->user.long_name, sizeof(longName) - 1);
+        if (nodeInfoLiteHasUser(node)) {
+            if (node->long_name[0]) {
+                strncpy(longName, node->long_name, sizeof(longName) - 1);
                longName[sizeof(longName) - 1] = '\0';
-            } else if (node->user.short_name[0]) {
-                strncpy(longName, node->user.short_name, sizeof(longName) - 1);
+            } else if (node->short_name[0]) {
+                strncpy(longName, node->short_name, sizeof(longName) - 1);
                longName[sizeof(longName) - 1] = '\0';
            }
        }
@@ -98,29 +98,23 @@ 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
+#if !MESHTASTIC_EXCLUDE_STATUS && !MESHTASTIC_EXCLUDE_STATUSDB
    // If long-name mode is enabled, and we have a recent status for this node,
-    // prefer "(short_name) statusText" as the raw candidate.
+    // prefer "(short_name) statusText" as the raw candidate. Pull straight out
+    // of NodeDB's per-NodeNum cache instead of scanning a FIFO.
    std::string composedFromStatus;
-    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());
+    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);
            composedFromStatus += "(";
            if (shortName && *shortName) {
                composedFromStatus += shortName;
            }
            composedFromStatus += ") ";
-            composedFromStatus += found->statusText;
+            composedFromStatus += cachedStatus.status;

            raw = composedFromStatus.c_str(); // safe for now; we'll sanitize immediately into std::string
        }
@@ -129,8 +123,8 @@ std::string getSafeNodeName(OLEDDisplay *display, meshtastic_NodeInfoLite *node,

    // If we didn't compose from status, use normal long/short selection
    if (!raw) {
-        if (node && node->has_user) {
-            raw = config.display.use_long_node_name ? node->user.long_name : node->user.short_name;
+        if (nodeInfoLiteHasUser(node)) {
+            raw = config.display.use_long_node_name ? node->long_name : node->short_name;
        }
    }

@@ -218,7 +212,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 || !node->is_favorite || !isTFTColoringEnabled() || !nodeName) {
+    if (!display || !node || !nodeInfoLiteIsFavorite(node) || !isTFTColoringEnabled() || !nodeName) {
        return;
    }

@@ -259,7 +253,7 @@ void drawEntryLastHeard(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int
 #if GRAPHICS_TFT_COLORING_ENABLED
    applyFavoriteNodeNameColor(display, node, nodeName, nameX, y, nameMaxWidth);
 #endif
-    bool isMuted = (node->bitfield & NODEINFO_BITFIELD_IS_MUTED_MASK) != 0;
+    bool isMuted = nodeInfoLiteIsMuted(node);

    char timeStr[10];
    uint32_t seconds = sinceLastSeen(node);
@@ -279,14 +273,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 (node->is_favorite) {
+    if (nodeInfoLiteIsFavorite(node)) {
        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 (node->is_ignored || isMuted) {
+    if (nodeInfoLiteIsIgnored(node) || isMuted) {
        if (currentResolution == ScreenResolution::High) {
            display->drawLine(x + 8, y + 8, (isLeftCol ? 0 : x - 4) + nameMaxWidth - 17, y + 8);
        } else {
@@ -321,20 +315,20 @@ void drawEntryHopSignal(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int
 #if GRAPHICS_TFT_COLORING_ENABLED
    applyFavoriteNodeNameColor(display, node, nodeName, nameX, y, nameMaxWidth);
 #endif
-    bool isMuted = (node->bitfield & NODEINFO_BITFIELD_IS_MUTED_MASK) != 0;
+    bool isMuted = nodeInfoLiteIsMuted(node);

    display->setTextAlignment(TEXT_ALIGN_LEFT);
    display->setFont(FONT_SMALL);

    UIRenderer::drawStringWithEmotes(display, nameX, y, nodeName, FONT_HEIGHT_SMALL, 1, false);
-    if (node->is_favorite) {
+    if (nodeInfoLiteIsFavorite(node)) {
        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 (node->is_ignored || isMuted) {
+    if (nodeInfoLiteIsIgnored(node) || isMuted) {
        if (currentResolution == ScreenResolution::High) {
            display->drawLine(x + 8, y + 8, (isLeftCol ? 0 : x - 4) + nameMaxWidth - 17, y + 8);
        } else {
@@ -401,15 +395,19 @@ void drawNodeDistance(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16
 #if GRAPHICS_TFT_COLORING_ENABLED
    applyFavoriteNodeNameColor(display, node, nodeName, nameX, y, nameMaxWidth);
 #endif
-    bool isMuted = (node->bitfield & NODEINFO_BITFIELD_IS_MUTED_MASK) != 0;
+    bool isMuted = nodeInfoLiteIsMuted(node);
    char distStr[10] = "";

-    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;
+    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;

        double earthRadiusKm = 6371.0;
        double dLat = (lat2 - lat1) * DEG_TO_RAD;
@@ -455,14 +453,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 (node->is_favorite) {
+    if (nodeInfoLiteIsFavorite(node)) {
        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 (node->is_ignored || isMuted) {
+    if (nodeInfoLiteIsIgnored(node) || isMuted) {
        if (currentResolution == ScreenResolution::High) {
            display->drawLine(x + 8, y + 8, (isLeftCol ? 0 : x - 4) + nameMaxWidth - 17, y + 8);
        } else {
@@ -509,19 +507,19 @@ void drawEntryCompass(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16
 #if GRAPHICS_TFT_COLORING_ENABLED
    applyFavoriteNodeNameColor(display, node, nodeName, nameX, y, nameMaxWidth);
 #endif
-    bool isMuted = (node->bitfield & NODEINFO_BITFIELD_IS_MUTED_MASK) != 0;
+    bool isMuted = nodeInfoLiteIsMuted(node);

    display->setTextAlignment(TEXT_ALIGN_LEFT);
    display->setFont(FONT_SMALL);
    UIRenderer::drawStringWithEmotes(display, nameX, y, nodeName, FONT_HEIGHT_SMALL, 1, false);
-    if (node->is_favorite) {
+    if (nodeInfoLiteIsFavorite(node)) {
        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 (node->is_ignored || isMuted) {
+    if (nodeInfoLiteIsIgnored(node) || isMuted) {
        if (currentResolution == ScreenResolution::High) {
            display->drawLine(x + 8, y + 8, (isLeftCol ? 0 : x - 4) + nameMaxWidth - 17, y + 8);
        } else {
@@ -542,8 +540,11 @@ void drawCompassArrow(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16
    int centerX = x + columnWidth - arrowXOffset;
    int centerY = y + FONT_HEIGHT_SMALL / 2;

-    double nodeLat = node->position.latitude_i * 1e-7;
-    double nodeLon = node->position.longitude_i * 1e-7;
+    meshtastic_PositionLite nodePos;
+    if (!nodeDB->copyNodePosition(node->num, nodePos))
+        return;
+    double nodeLat = nodePos.latitude_i * 1e-7;
+    double nodeLon = nodePos.longitude_i * 1e-7;
    float bearing = GeoCoord::bearing(userLat, userLon, nodeLat, nodeLon);
    float relativeBearing = CompassRenderer::adjustBearingForCompassMode(bearing, myHeadingRadian);
    float relativeBearingDeg = CompassRenderer::radiansToDegrees360(relativeBearing);
@@ -652,7 +653,7 @@ void drawNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t
            continue;
        if (n->num == nodeDB->getNodeNum())
            continue;
-        if (locationScreen && !n->has_position)
+        if (locationScreen && !nodeDB->hasNodePosition(n->num))
            continue;

        drawList.push_back(n->num);
@@ -883,14 +884,15 @@ void drawDistanceScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t
 void drawNodeListWithCompasses(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
    float headingRadian = 0.0f;
-    auto ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
-    if (!ourNode || !nodeDB->hasValidPosition(ourNode)) {
+    const auto *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    meshtastic_PositionLite ourSelfPos;
+    if (!ourNode || !nodeDB->hasValidPosition(ourNode) || !nodeDB->copyNodePosition(ourNode->num, ourSelfPos)) {
        drawNodeListScreen(display, state, x, y, "Bearings", drawEntryCompass, drawCompassUnknown, headingRadian, 0.0, 0.0);
        return;
    }

-    double lat = DegD(ourNode->position.latitude_i);
-    double lon = DegD(ourNode->position.longitude_i);
+    double lat = DegD(ourSelfPos.latitude_i);
+    double lon = DegD(ourSelfPos.longitude_i);

 #if defined(M5STACK_UNITC6L)
    display->clear();
@@ -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 (node && node->has_user) {
+        if (nodeInfoLiteHasUser(node)) {
            const char *rawName = nullptr;
-            if (node->user.long_name[0]) {
-                rawName = node->user.long_name;
-            } else if (node->user.short_name[0]) {
-                rawName = node->user.short_name;
+            if (node->long_name[0]) {
+                rawName = node->long_name;
+            } else if (node->short_name[0]) {
+                rawName = node->short_name;
            }
            if (rawName) {
                const int arrowWidth = (currentResolution == ScreenResolution::High)
@@ -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 std::string &statusText)
+static void drawTruncatedStatusLine(OLEDDisplay *display, int16_t x, int16_t y, const char *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.c_str());
+    snprintf(rawStatus, sizeof(rawStatus), " Status: %s", statusText ? statusText : "");

    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 (n->is_favorite)
+        if (nodeInfoLiteIsFavorite(n))
            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() || !node->is_favorite)
+    if (!node || node->num == nodeDB->getNodeNum() || !nodeInfoLiteIsFavorite(node))
        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 = (node->has_user && node->user.short_name[0]) ? node->user.short_name : "Node";
+    const char *shortName = (nodeInfoLiteHasUser(node) && node->short_name[0]) ? node->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 = (node->has_user && node->user.long_name[0]) ? node->user.short_name : nullptr;
+        username = (nodeInfoLiteHasUser(node) && node->long_name[0]) ? node->short_name : nullptr;
    } else {
-        username = (node->has_user && node->user.long_name[0]) ? node->user.long_name : nullptr;
+        username = (nodeInfoLiteHasUser(node) && node->long_name[0]) ? node->long_name : nullptr;
    }

    // Print node's long name (e.g. "Backpack Node")
@@ -796,23 +796,14 @@ void UIRenderer::drawFavoriteNode(OLEDDisplay *display, OLEDDisplayUiState *stat
        UIRenderer::drawStringWithEmotes(display, x, getTextPositions(display)[line++], username, FONT_HEIGHT_SMALL, 1, false);
    }

-#if !MESHTASTIC_EXCLUDE_STATUS
+#if !MESHTASTIC_EXCLUDE_STATUS && !MESHTASTIC_EXCLUDE_STATUSDB
    // === Optional: Last received StatusMessage line for this node ===
-    // 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);
+    // 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);
        }
    }
 #endif
@@ -971,25 +962,30 @@ void UIRenderer::drawFavoriteNode(OLEDDisplay *display, OLEDDisplayUiState *stat
 #if !defined(M5STACK_UNITC6L)
    // === 4. Uptime (only show if metric is present) ===
    char uptimeStr[32] = "";
-    if (node->has_device_metrics && node->device_metrics.has_uptime_seconds) {
+    meshtastic_DeviceMetrics nodeMetrics;
+    const bool haveNodeMetrics = nodeDB->copyNodeTelemetry(node->num, nodeMetrics);
+    if (haveNodeMetrics && nodeMetrics.has_uptime_seconds) {
        char upPrefix[12]; // enough for leftSideSpacing + "Up:"
        snprintf(upPrefix, sizeof(upPrefix), "%sUp:", leftSideSpacing);
-        getUptimeStr(node->device_metrics.uptime_seconds * 1000, upPrefix, uptimeStr, sizeof(uptimeStr));
+        getUptimeStr(nodeMetrics.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) ===
-    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    const meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
    char distStr[24] = ""; // Make buffer big enough for any string
    bool haveDistance = false;

-    if (nodeDB->hasValidPosition(ourNode) && nodeDB->hasValidPosition(node)) {
+    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) {
        // Use shared meter conversion, then format display units with lightweight integer rounding.
-        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));
+        const float distanceMeters = GeoCoord::latLongToMeter(DegD(nodePos.latitude_i), DegD(nodePos.longitude_i),
+                                                              DegD(ourPos.latitude_i), DegD(ourPos.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) {
@@ -1024,19 +1020,19 @@ void UIRenderer::drawFavoriteNode(OLEDDisplay *display, OLEDDisplayUiState *stat
    char batLine[32] = "";
    bool haveBatLine = false;

-    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;
+    if (haveNodeMetrics) {
+        bool hasPct = nodeMetrics.has_battery_level;
+        bool hasVolt = nodeMetrics.has_voltage && nodeMetrics.voltage > 0.001f;

        int pct = 0;
        float volt = 0.0f;

        if (hasPct) {
-            pct = (int)node->device_metrics.battery_level;
+            pct = (int)nodeMetrics.battery_level;
        }

        if (hasVolt) {
-            volt = node->device_metrics.voltage;
+            volt = nodeMetrics.voltage;
        }

        if (hasPct && pct > 0 && pct <= 100) {
@@ -1076,11 +1072,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) {
-        const auto &op = ourNode->position;
+    if (hasOwnPositionFix && hasNodePositionFix && haveOurPos && haveNodePos) {
+        const auto &op = ourPos;
        showCompass = CompassRenderer::getHeadingRadians(DegD(op.latitude_i), DegD(op.longitude_i), myHeading);
        if (showCompass) {
-            const auto &p = node->position;
+            const auto &p = nodePos;
            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 {
@@ -1130,7 +1126,7 @@ void UIRenderer::drawDeviceFocused(OLEDDisplay *display, OLEDDisplayUiState *sta
    display->setTextAlignment(TEXT_ALIGN_LEFT);
    display->setFont(FONT_SMALL);
    int line = 1;
-    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    const meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());

    // === Header ===
    if (currentResolution == ScreenResolution::UltraLow) {
@@ -1270,7 +1266,7 @@ void UIRenderer::drawDeviceFocused(OLEDDisplay *display, OLEDDisplayUiState *sta
    int textWidth = 0;
    int nameX = 0;
    int yOffset = (currentResolution == ScreenResolution::High) ? 0 : 5;
-    const char *longName = (ourNode && ourNode->has_user && ourNode->user.long_name[0]) ? ourNode->user.long_name : "";
+    const char *longName = (nodeInfoLiteHasUser(ourNode) && ourNode->long_name[0]) ? ourNode->long_name : "";
    const char *shortName = owner.short_name ? owner.short_name : "";
    char combinedName[96];
    if (longName[0] && shortName[0]) {
@@ -1597,7 +1593,7 @@ void UIRenderer::drawCompassAndLocationScreen(OLEDDisplay *display, OLEDDisplayU
    geoCoord.updateCoords(int32_t(gpsStatus->getLatitude()), int32_t(gpsStatus->getLongitude()),
                          int32_t(gpsStatus->getAltitude()));

-    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    const 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));
@@ -1613,9 +1609,11 @@ void UIRenderer::drawCompassAndLocationScreen(OLEDDisplay *display, OLEDDisplayU
            headingLat = DegD(gpsStatus->getLatitude());
            headingLon = DegD(gpsStatus->getLongitude());
        } else if (hasOwnPositionFix) {
-            const auto &op = ourNode->position;
-            headingLat = DegD(op.latitude_i);
-            headingLon = DegD(op.longitude_i);
+            meshtastic_PositionLite ownPos;
+            if (nodeDB->copyNodePosition(ourNode->num, ownPos)) {
+                headingLat = DegD(ownPos.latitude_i);
+                headingLon = DegD(ownPos.longitude_i);
+            }
        }
        validHeading = CompassRenderer::getHeadingRadians(headingLat, headingLon, heading);
    }
@@ -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 (node->has_user) {
-        std::string parsed = parse(node->user.short_name);
+    if (nodeInfoLiteHasUser(node)) {
+        std::string parsed = parse(node->short_name);
        if (isPrintable(parsed))
            return parsed;
    }
@@ -136,9 +136,10 @@ 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
-    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);
+    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);

        int16_t centerX = X(0.5) + (self.eastMeters * metersToPx);
        int16_t centerY = Y(0.5) - (self.northMeters * metersToPx);
@@ -168,10 +169,11 @@ 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
-    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;
+    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;
    } else {
        // Find mean lat long coords
        // ============================
@@ -201,9 +203,13 @@ 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 = node->position.latitude_i * (1e-7) * DEG_TO_RAD;
-            float lngRad = node->position.longitude_i * (1e-7) * DEG_TO_RAD;
+            float latRad = pos.latitude_i * (1e-7) * DEG_TO_RAD;
+            float lngRad = pos.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
@@ -300,13 +306,17 @@ 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 = node->position.latitude_i * 1e-7;
+        float latNode = pos.latitude_i * 1e-7;
        northernmost = max(northernmost, latNode);
        southernmost = min(southernmost, latNode);

        // Longitude is trickier
-        float lngNode = node->position.longitude_i * 1e-7;
+        float lngNode = pos.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)
@@ -372,10 +382,13 @@ void InkHUD::MapApplet::drawLabeledMarker(meshtastic_NodeInfoLite *node)
 {
    // Find x and y position based on node's position in nodeDB
    assert(nodeDB->hasValidPosition(node));
-    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
+    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
    );

    // Convert to pixel coords
@@ -516,13 +529,16 @@ 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(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
-                            ));
+        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
+                                          ));
    }
 }

@@ -50,21 +50,23 @@ ProcessMessage InkHUD::NodeListApplet::handleReceived(const meshtastic_MeshPacke
    c.signal = getSignalStrength(mp.rx_snr, mp.rx_rssi);

    // Assemble info: from nodeDB (needed to detect changes)
-    meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(c.nodeNum);
-    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    const meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(c.nodeNum);
+    const 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)) {
-            // 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;
+            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;

-            c.distanceMeters = (int32_t)GeoCoord::latLongToMeter(theirLat, theirLong, ourLat, ourLong);
+                c.distanceMeters = (int32_t)GeoCoord::latLongToMeter(theirLat, theirLong, ourLat, ourLong);
+            }
        }
    }

@@ -179,8 +181,8 @@ void InkHUD::NodeListApplet::onRender(bool full)
        // -- Longname --
        // Parse special chars in long name
        // Use node id if unknown
-        if (node && node->has_user)
-            longName = parse(node->user.long_name); // Found in nodeDB
+        if (nodeInfoLiteHasUser(node))
+            longName = parse(node->long_name); // Found in nodeDB
        else {
            // Not found in nodeDB, show a hex nodeid instead
            longName = hexifyNodeNum(nodeNum);
@@ -2090,7 +2090,7 @@ void InkHUD::MenuApplet::populateRecipientPage()

    // Count favorites
    for (uint32_t i = 0; i < nodeCount; i++) {
-        if (nodeDB->getMeshNodeByIndex(i)->is_favorite)
+        if (nodeInfoLiteIsFavorite(nodeDB->getMeshNodeByIndex(i)))
            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++) {
-            meshtastic_NodeInfoLite *node = nodeDB->getMeshNodeByIndex(i);
+            const meshtastic_NodeInfoLite *node = nodeDB->getMeshNodeByIndex(i);

            // Skip node if not a favorite
-            if (!node->is_favorite)
+            if (!nodeInfoLiteIsFavorite(node))
                continue;

            CannedMessages::RecipientItem r;
@@ -2111,8 +2111,8 @@ void InkHUD::MenuApplet::populateRecipientPage()

            // Set a label for the menu item
            r.label = "DM: ";
-            if (node->has_user)
-                r.label += parse(node->user.long_name);
+            if (nodeInfoLiteHasUser(node))
+                r.label += parse(node->long_name);
            else
                r.label += hexifyNodeNum(node->num); // Unsure if it's possible to favorite a node without NodeInfo?

@@ -241,7 +241,7 @@ std::string InkHUD::NotificationApplet::getNotificationText(uint16_t widthAvaila
        text += msgIsBroadcast ? "From:" : "DM: ";

        // Sender id
-        if (node && node->has_user)
+        if (nodeInfoLiteHasUser(node))
            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 (node && node->has_user)
+            if (nodeInfoLiteHasUser(node))
                text += parseShortName(node);
            else
                text += hexifyNodeNum(message->sender);
@@ -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 (sender && sender->has_user) {
+    if (nodeInfoLiteHasUser(sender)) {
        header += parseShortName(sender); // May be last-four of node if unprintable (emoji, etc)
        header += " (";
-        header += parse(sender->user.long_name);
+        header += parse(sender->long_name);
        header += ")";
    } else
        header += hexifyNodeNum(message->sender);
@@ -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 (sender && sender->has_user) {
+    if (nodeInfoLiteHasUser(sender)) {
        header += parseShortName(sender); // May be last-four of node if unprintable (emoji, etc)
        header += " (";
-        header += parse(sender->user.long_name);
+        header += parse(sender->long_name);
        header += ")";
    } else
        header += hexifyNodeNum(latestMessage->dm.sender);
@@ -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() || node->is_favorite);
+    return node && (node->num == nodeDB->getNodeNum() || nodeInfoLiteIsFavorite(node));
 }

 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 && node->is_favorite && nodeDB->hasValidPosition(node) && enoughMarkers())
+    if (node && nodeInfoLiteIsFavorite(node) && 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 (!sender || !sender->is_favorite)
+        if (!nodeInfoLiteIsFavorite(sender))
            return ProcessMessage::CONTINUE;

        // Check if this position is from someone different than our previous position packet.
@@ -80,8 +80,8 @@ void InkHUD::HeardApplet::populateFromNodeDB()
        ordered.resize(maxCards());

    // Create card info for these (stale) node observations
-    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
-    for (meshtastic_NodeInfoLite *node : ordered) {
+    const meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    for (const meshtastic_NodeInfoLite *node : ordered) {
        CardInfo c;
        c.nodeNum = node->num;

@@ -89,14 +89,16 @@ void InkHUD::HeardApplet::populateFromNodeDB()
            c.hopsAway = node->hops_away;

        if (nodeDB->hasValidPosition(node) && nodeDB->hasValidPosition(ourNode)) {
-            // 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;
+            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;

-            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)
@@ -122,4 +124,4 @@ std::string InkHUD::HeardApplet::getHeaderText()
    return text;
 }

-#endif
+#endif
@@ -390,8 +390,11 @@ void InputBroker::Init()
                seesawRotary = nullptr;
            }
        }
+#ifdef __linux__
+        // Linux evdev keyboard input only — macOS has no <linux/input.h>.
        aLinuxInputImpl = new LinuxInputImpl();
        aLinuxInputImpl->init();
+#endif
    }
 #endif
 #if !MESHTASTIC_EXCLUDE_INPUTBROKER && HAS_TRACKBALL
@@ -1,5 +1,8 @@
 #pragma once
-#if ARCH_PORTDUINO
+// Linux evdev keyboard input. Only compiled on Linux portduino targets;
+// macOS / non-Linux builds have no <linux/input.h> or epoll, and the
+// headless build doesn't need real keyboards anyway.
+#if ARCH_PORTDUINO && defined(__linux__)
 #include "InputBroker.h"
 #include "concurrency/OSThread.h"
 #include <assert.h>
@@ -1,4 +1,5 @@
-#ifdef ARCH_PORTDUINO
+// Linux evdev impl. Same Linux-only gating as LinuxInput.h.
+#if defined(ARCH_PORTDUINO) && defined(__linux__)
 #pragma once
 #include "LinuxInput.h"
 #include "main.h"
@@ -13,7 +13,6 @@ RotaryEncoderImpl *rotaryEncoderImpl;

 RotaryEncoderImpl::RotaryEncoderImpl()
 {
-    rotary = nullptr;
 #ifdef ARCH_ESP32
    isFirstInit = true;
 #endif
@@ -23,11 +22,6 @@ RotaryEncoderImpl::~RotaryEncoderImpl()
 {
    LOG_DEBUG("RotaryEncoderImpl destructor");
    detachRotaryEncoderInterrupts();
-
-    if (rotary != nullptr) {
-        delete rotary;
-        rotary = nullptr;
-    }
 }

 bool RotaryEncoderImpl::init()
@@ -43,8 +37,9 @@ bool RotaryEncoderImpl::init()
    eventPressed = static_cast<input_broker_event>(moduleConfig.canned_message.inputbroker_event_press);

    if (rotary == nullptr) {
-        rotary = new RotaryEncoder(moduleConfig.canned_message.inputbroker_pin_a, moduleConfig.canned_message.inputbroker_pin_b,
-                                   moduleConfig.canned_message.inputbroker_pin_press);
+        rotary.reset(new RotaryEncoder(moduleConfig.canned_message.inputbroker_pin_a,
+                                       moduleConfig.canned_message.inputbroker_pin_b,
+                                       moduleConfig.canned_message.inputbroker_pin_press));
    }

    attachRotaryEncoderInterrupts();
@@ -5,6 +5,7 @@
 #include "InputBroker.h"
 #include "concurrency/OSThread.h"
 #include "mesh/NodeDB.h"
+#include <memory>

 class RotaryEncoder;

@@ -28,7 +29,7 @@ class RotaryEncoderImpl final : public InputPollable
    input_broker_event eventCcw = INPUT_BROKER_NONE;
    input_broker_event eventPressed = INPUT_BROKER_NONE;

-    RotaryEncoder *rotary;
+    std::unique_ptr<RotaryEncoder> rotary;

  private:
 #ifdef ARCH_ESP32
@@ -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_UserLite_public_key_t remotePublic,
+bool CryptoEngine::encryptCurve25519(uint32_t toNode, uint32_t fromNode, meshtastic_NodeInfoLite_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_UserLite_public_key_t remotePublic, uint64_t packetNum,
+bool CryptoEngine::decryptCurve25519(uint32_t fromNode, meshtastic_NodeInfoLite_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?
@@ -40,9 +40,12 @@ class CryptoEngine

 #endif
    void setDHPrivateKey(uint8_t *_private_key);
-    virtual bool encryptCurve25519(uint32_t toNode, uint32_t fromNode, meshtastic_UserLite_public_key_t remotePublic,
+    // 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,
                                   uint64_t packetNum, size_t numBytes, const uint8_t *bytes, uint8_t *bytesOut);
-    virtual bool decryptCurve25519(uint32_t fromNode, meshtastic_UserLite_public_key_t remotePublic, uint64_t packetNum,
+    virtual bool decryptCurve25519(uint32_t fromNode, meshtastic_NodeInfoLite_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);
@@ -2,18 +2,21 @@

 #include "meshUtils.h"

+// Convert seconds to ms, clamping at INT32_MAX (~24.86 days)
+static inline uint32_t secondsToMsClamped(uint32_t secs)
+{
+    constexpr uint32_t MAX_MS = static_cast<uint32_t>(INT32_MAX);
+    return (secs > MAX_MS / 1000U) ? MAX_MS : secs * 1000U;
+}
+
 uint32_t Default::getConfiguredOrDefaultMs(uint32_t configuredInterval, uint32_t defaultInterval)
 {
-    if (configuredInterval > 0)
-        return configuredInterval * 1000;
-    return defaultInterval * 1000;
+    return secondsToMsClamped(configuredInterval > 0 ? configuredInterval : defaultInterval);
 }

 uint32_t Default::getConfiguredOrDefaultMs(uint32_t configuredInterval)
 {
-    if (configuredInterval > 0)
-        return configuredInterval * 1000;
-    return default_broadcast_interval_secs * 1000;
+    return secondsToMsClamped(configuredInterval > 0 ? configuredInterval : default_broadcast_interval_secs);
 }

 uint32_t Default::getConfiguredOrDefault(uint32_t configured, uint32_t defaultValue)
@@ -47,7 +50,14 @@ uint32_t Default::getConfiguredOrDefaultMsScaled(uint32_t configured, uint32_t d
                  meshtastic_Config_DeviceConfig_Role_TAK_TRACKER))
        return getConfiguredOrDefaultMs(configured, defaultValue);

-    return getConfiguredOrDefaultMs(configured, defaultValue) * congestionScalingCoefficient(numOnlineNodes);
+    // Saturate at INT32_MAX to match secondsToMsClamped: float→uint32_t when
+    // out of range is UB, and the result is consumed as an int32_t downstream.
+    constexpr uint32_t MAX_MS = static_cast<uint32_t>(INT32_MAX);
+    uint32_t base = getConfiguredOrDefaultMs(configured, defaultValue);
+    float coef = congestionScalingCoefficient(numOnlineNodes);
+    if (static_cast<double>(base) * static_cast<double>(coef) >= static_cast<double>(MAX_MS))
+        return MAX_MS;
+    return base * coef;
 }

 uint32_t Default::getConfiguredOrMinimumValue(uint32_t configured, uint32_t minValue)
@@ -66,4 +76,4 @@ uint8_t Default::getConfiguredOrDefaultHopLimit(uint8_t configured)
 #else
    return (configured >= HOP_MAX) ? HOP_MAX : config.lora.hop_limit;
 #endif
-}
+}
@@ -19,8 +19,12 @@ extern Adafruit_nRFCrypto nRFCrypto;
 #include <Arduino.h>
 #elif defined(ARCH_PORTDUINO)
 #include <random>
-#include <sys/random.h>
 #include <unistd.h>
+#ifdef __linux__
+#include <sys/random.h> // getrandom()
+#else
+#include <stdlib.h> // arc4random_buf() on Darwin/BSD
+#endif
 #endif

 namespace HardwareRNG
@@ -119,10 +123,16 @@ bool fill(uint8_t *buffer, size_t length, bool useRadioEntropy)
    filled = true;
 #elif defined(ARCH_PORTDUINO)
    // Prefer the host OS RNG first when running under Portduino.
+#ifdef __linux__
    ssize_t generated = ::getrandom(buffer, length, 0);
    if (generated == static_cast<ssize_t>(length)) {
        filled = true;
    }
+#else
+    // arc4random_buf is available on Darwin/BSD and cannot fail.
+    ::arc4random_buf(buffer, length);
+    filled = true;
+#endif

    if (!filled) {
        fillWithRandomDevice(buffer, length);
@@ -1,5 +1,9 @@
+#include "configuration.h"
+
 #include "LR11x0Interface.cpp"
 #include "LR11x0Interface.h"
+#include "LR20x0Interface.cpp"
+#include "LR20x0Interface.h"
 #include "SX126xInterface.cpp"
 #include "SX126xInterface.h"
 #include "SX128xInterface.cpp"
@@ -21,6 +25,9 @@ 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
@@ -57,16 +57,19 @@ 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)
+#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
    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();
@@ -101,6 +104,17 @@ 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)
@@ -198,7 +212,7 @@ template <typename T> bool LR11x0Interface<T>::reconfigure()

    startReceive(); // restart receiving

-    return RADIOLIB_ERR_NONE;
+    return true;
 }

 template <typename T> void LR11x0Interface<T>::disableInterrupt()
@@ -0,0 +1,18 @@
+#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
@@ -0,0 +1,15 @@
+#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
@@ -0,0 +1,399 @@
+#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
@@ -0,0 +1,75 @@
+#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
@@ -6,8 +6,11 @@
 #include "configuration.h"
 #include "detect/LoRaRadioType.h"

-// Sentinel marking the end of a modem preset array
-static constexpr meshtastic_Config_LoRaConfig_ModemPreset MODEM_PRESET_END =
+// Sentinel marking the end of a modem preset array. Declared `const` rather
+// than `constexpr` because the cast from 0xFF to the enum is out-of-range and
+// therefore not a valid constant expression on Clang 16+ (Apple Clang on
+// macOS). The value is only ever compared at runtime, so static-init is fine.
+static const meshtastic_Config_LoRaConfig_ModemPreset MODEM_PRESET_END =
    static_cast<meshtastic_Config_LoRaConfig_ModemPreset>(0xFF);

 // Region profile: bundles the preset list with regulatory parameters shared across regions
@@ -94,8 +94,9 @@ 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 && !nodeDB->getMeshNode(mp->from)->has_user &&
-               nodeInfoModule && !isPreferredRebroadcaster && !nodeDB->isFull()) {
+    } else if (mp->which_payload_variant == meshtastic_MeshPacket_decoded_tag &&
+               !nodeInfoLiteHasUser(nodeDB->getMeshNode(mp->from)) && 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)) {
@@ -392,19 +393,16 @@ 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

-    position.time = getValidTime(RTCQualityFromNet);
+#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

    if (powerStatus->getHasBattery() == 1) {
        updateBatteryLevel(powerStatus->getBatteryChargePercent());
@@ -432,7 +430,9 @@ 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");
-        pos = TypeConversions::ConvertToPosition(node->position);
+        meshtastic_PositionLite fixedSlot;
+        if (nodeDB->copyNodePosition(node->num, fixedSlot))
+            pos = TypeConversions::ConvertToPosition(fixedSlot);
    }

    // Add a fresh timestamp
@@ -22,6 +22,7 @@
 #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>
@@ -151,24 +152,103 @@ 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_iter_t *field)
+bool meshtastic_NodeDatabase_callback(pb_istream_t *istream, pb_ostream_t *ostream, const pb_field_t *field)
 {
-    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);
+    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 (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;
    }
-    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);
+    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;
    }
-    return true;
 }

 /** The current change # for radio settings.  Starts at 0 on boot and any time the radio settings
@@ -298,8 +378,7 @@ NodeDB::NodeDB()
 #endif
    // Include our owner in the node db under our nodenum
    meshtastic_NodeInfoLite *info = getOrCreateMeshNode(getNodeNum());
-    info->user = TypeConversions::ConvertToUserLite(owner);
-    info->has_user = true;
+    TypeConversions::CopyUserToNodeInfoLite(info, owner);

    // If node database has not been saved for the first time, save it now
 #ifdef FSCom
@@ -442,8 +521,12 @@ 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;
-        info->has_position = true;
-        info->position = TypeConversions::ConvertToPositionLite(fixedGPS);
+#if !MESHTASTIC_EXCLUDE_POSITIONDB
+        {
+            concurrency::LockGuard guard(&satelliteMutex);
+            nodePositions[info->num] = TypeConversions::ConvertToPositionLite(fixedGPS);
+        }
+#endif
        nodeDB->setLocalPosition(fixedGPS);
        config.position.fixed_position = true;
 #endif
@@ -479,6 +562,29 @@ 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) {
@@ -548,6 +654,19 @@ 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)
@@ -688,7 +807,7 @@ void NodeDB::installDefaultConfig(bool preserveKey = false)
    strncpy(config.network.ntp_server, "meshtastic.pool.ntp.org", 32);

 #if (defined(T_DECK) || defined(T_WATCH_S3) || defined(UNPHONE) || defined(PICOMPUTER_S3) || defined(SENSECAP_INDICATOR) ||      \
-     defined(ELECROW_PANEL) || defined(HELTEC_V4_TFT)) &&                                                                        \
+     defined(ELECROW_PANEL) || defined(HELTEC_V4_TFT) || defined(HELTEC_V4_R8_TFT)) &&                                           \
    HAS_TFT
    // switch BT off by default; use TFT programming mode or hotkey to enable
    config.bluetooth.enabled = false;
@@ -1019,12 +1138,14 @@ 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 && !node.is_favorite) {
+            if (i > 0 && !nodeInfoLiteIsFavorite(&node)) {
+                eraseNodeSatellites(node.num);
                node = meshtastic_NodeInfoLite();
            } else {
                numMeshNodes += 1;
@@ -1032,8 +1153,14 @@ 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();
@@ -1054,36 +1181,173 @@ 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()
 {
-    meshtastic_NodeInfoLite *node = getMeshNode(nodeDB->getNodeNum());
-    node->position.latitude_i = 0;
-    node->position.longitude_i = 0;
-    node->position.altitude = 0;
-    node->position.time = 0;
+#if !MESHTASTIC_EXCLUDE_POSITIONDB
+    concurrency::LockGuard guard(&satelliteMutex);
+    nodePositions.erase(getNodeNum());
+#endif
    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++) {
-        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;
+        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 (newPos != i)
-                meshNodes->at(newPos++) = meshNodes->at(i);
+                meshNodes->at(newPos++) = n;
            else
                newPos++;
        } else {
+            // No user info - drop this node and its satellites
+            const NodeNum gone = n.num;
+            if (gone)
+                eraseNodeSatellites(gone);
            removed++;
        }
    }
@@ -1141,14 +1405,22 @@ 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)) && memcmp(found->user.macaddr, ourMacAddr, sizeof(ourMacAddr)) != 0) ||
+    while (((found = getMeshNode(nodeNum)) && !isOurOwnEntry(found)) ||
           (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, 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);
+            LOG_WARN("NOTE! Our desired nodenum 0x%x is invalid or in use, picking 0x%x", nodeNum, candidate);
        nodeNum = candidate;
    }
    LOG_DEBUG("Use nodenum 0x%x ", nodeNum);
@@ -1169,7 +1441,8 @@ 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) // contains a vector object
+        if (fields != &meshtastic_NodeDatabase_msg &&
+            fields != &meshtastic_NodeDatabase_Legacy_msg) // both NodeDatabase descriptors contain std::vector members
            memset(dest_struct, 0, objSize);
        if (!pb_decode(&stream, fields, dest_struct)) {
            LOG_ERROR("Error: can't decode protobuf %s", PB_GET_ERROR(&stream));
@@ -1205,11 +1478,11 @@ void NodeDB::loadFromDisk()
    spiLock->unlock();
 #endif
 #ifdef FSCom
-#ifdef FACTORY_INSTALL
+#if defined(FACTORY_INSTALL) && !defined(ARCH_PORTDUINO)
    spiLock->lock();
    if (!FSCom.exists("/prefs/" xstr(BUILD_EPOCH))) {
        LOG_WARN("Factory Install Reset!");
-        FSCom.format();
+        rmDir("/prefs");
        FSCom.mkdir("/prefs");
        File f2 = FSCom.open("/prefs/" xstr(BUILD_EPOCH), FILE_O_WRITE);
        if (f2) {
@@ -1242,9 +1515,57 @@ 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());
    }

@@ -1272,16 +1593,16 @@ void NodeDB::loadFromDisk()

        // Attempt recovery of owner fields from our own NodeDB entry if available.
        meshtastic_NodeInfoLite *us = getMeshNode(getNodeNum());
-        if (us && us->has_user) {
+        if (nodeInfoLiteHasUser(us)) {
            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->user.long_name, sizeof(owner.long_name));
+            memcpy(owner.long_name, us->long_name, sizeof(owner.long_name));
            owner.long_name[sizeof(owner.long_name) - 1] = '\0';
-            memcpy(owner.short_name, us->user.short_name, sizeof(owner.short_name));
+            memcpy(owner.short_name, us->short_name, sizeof(owner.short_name));
            owner.short_name[sizeof(owner.short_name) - 1] = '\0';
-            owner.is_licensed = us->user.is_licensed;
-            owner.has_is_unmessagable = us->user.has_is_unmessagable;
-            owner.is_unmessagable = us->user.is_unmessagable;
+            owner.is_licensed = nodeInfoLiteIsLicensed(us);
+            owner.has_is_unmessagable = nodeInfoLiteHasIsUnmessagable(us);
+            owner.is_unmessagable = nodeInfoLiteIsUnmessagable(us);

            // Save the recovered owner to device state on disk
            saveToDisk(SEGMENT_DEVICESTATE);
@@ -1528,9 +1849,75 @@ 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);
-    return saveProto(nodeDatabaseFileName, nodeDatabaseSize, &meshtastic_NodeDatabase_msg, &nodeDatabase, false);
+    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;
 }

 bool NodeDB::saveToDiskNoRetry(int saveWhat)
@@ -1611,12 +1998,10 @@ bool NodeDB::saveToDisk(int saveWhat)

    if (!success) {
        LOG_ERROR("Failed to save to disk, retrying");
-#ifdef ARCH_NRF52 // @geeksville is not ready yet to say we should do this on other platforms.  See bug #4184 discussion
        spiLock->lock();
-        FSCom.format();
+        fsFormat();
        spiLock->unlock();

-#endif
        success = saveToDiskNoRetry(saveWhat);

        RECORD_CRITICALERROR(success ? meshtastic_CriticalErrorCode_FLASH_CORRUPTION_RECOVERABLE
@@ -1701,7 +2086,7 @@ size_t NodeDB::getNumOnlineMeshNodes(bool localOnly)

    // FIXME this implementation is kinda expensive
    for (int i = 0; i < numMeshNodes; i++) {
-        if (localOnly && meshNodes->at(i).via_mqtt)
+        if (localOnly && nodeInfoLiteViaMqtt(&meshNodes->at(i)))
            continue;
        if (sinceLastSeen(&meshNodes->at(i)) < NUM_ONLINE_SECS)
            numseen++;
@@ -1738,62 +2123,94 @@ 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) {
-        // 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,
+        LOG_INFO("updatePosition LOCAL (PositionDB excluded) time=%u lat=%d lon=%d alt=%d", 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;
    }
-    info->has_position = true;
+    (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;
+        }
+    }
    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
- *  We only care about device telemetry here
+/** 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.
 */
 void NodeDB::updateTelemetry(uint32_t nodeId, const meshtastic_Telemetry &t, RxSource src)
 {
    meshtastic_NodeInfoLite *info = getOrCreateMeshNode(nodeId);
-    // Environment metrics should never go to NodeDb but we'll safegaurd anyway
-    if (!info || t.which_variant != meshtastic_Telemetry_device_metrics_tag) {
+    if (!info)
        return;
-    }

-    if (src == RX_SRC_LOCAL) {
-        // Local packet, fully authoritative
-        LOG_DEBUG("updateTelemetry LOCAL");
+    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 {
-        LOG_DEBUG("updateTelemetry REMOTE node=0x%x ", nodeId);
+        return; // air_quality / power / local_stats / health: not stored per-node
    }
-    info->device_metrics = t.variant.device_metrics;
-    info->has_device_metrics = true;
    updateGUIforNode = info;
-    notifyObservers(true); // Force an update whether or not our node counts have changed
+    notifyObservers(true);
 }

 /**
@@ -1808,24 +2225,22 @@ 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 ((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) {
+    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) {
            return;
        }
    }
    info->num = contact.node_num;
-    info->has_user = true;
-    info->user = TypeConversions::ConvertToUserLite(contact.user);
+    TypeConversions::CopyUserToNodeInfoLite(info, 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
-        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));
+        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));
    } 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!
@@ -1844,12 +2259,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).
-            info->is_favorite = true;
+            nodeInfoLiteSetBit(info, NODEINFO_BITFIELD_IS_FAVORITE_MASK, 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) {
-            info->bitfield |= NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_MASK;
+            nodeInfoLiteSetBit(info, NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_MASK, true);
        }
        // Mark the node's key as manually verified to indicate trustworthiness.
        updateGUIforNode = info;
@@ -1889,9 +2304,9 @@ bool NodeDB::updateUser(uint32_t nodeId, meshtastic_User &p, uint8_t channelInde
            return false;
        }
    }
-    if (info->user.public_key.size == 32) { // if we have a key for this user already, don't overwrite with a new one
+    if (info->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->user.public_key.bytes, 32) != 0)) {
+        if (p.public_key.size != 32 || (memcmp(p.public_key.bytes, info->public_key.bytes, 32) != 0)) {
            LOG_WARN("Public Key mismatch, dropping NodeInfo");
            return false;
        }
@@ -1904,19 +2319,22 @@ 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);

-    // 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);
+    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);

-    info->user = lite;
-    if (info->user.public_key.size == 32) {
-        printBytes("Saved Pubkey: ", info->user.public_key.bytes, 32);
+    if (info->public_key.size == 32) {
+        printBytes("Saved Pubkey: ", info->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->user.long_name, info->user.short_name, nodeId,
+    LOG_DEBUG("Update changed=%d user %s/%s, id=0x%08x, channel=%d", changed, info->long_name, info->short_name, nodeId,
              info->channel);
-    info->has_user = true;

    if (changed) {
        updateGUIforNode = info;
@@ -1958,7 +2376,8 @@ 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.

-        info->via_mqtt = mp.via_mqtt; // Store if we received this packet via MQTT
+        nodeInfoLiteSetBit(info, NODEINFO_BITFIELD_VIA_MQTT_MASK,
+                           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);
@@ -1973,8 +2392,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 && lite->is_favorite != is_favorite) {
-        lite->is_favorite = is_favorite;
+    if (lite && nodeInfoLiteIsFavorite(lite) != is_favorite) {
+        nodeInfoLiteSetBit(lite, NODEINFO_BITFIELD_IS_FAVORITE_MASK, is_favorite);
        sortMeshDB();
        saveNodeDatabaseToDisk();
    }
@@ -1988,10 +2407,10 @@ bool NodeDB::isFavorite(uint32_t nodeId)
    if (nodeId == NODENUM_BROADCAST)
        return false;

-    meshtastic_NodeInfoLite *lite = getMeshNode(nodeId);
+    const meshtastic_NodeInfoLite *lite = getMeshNode(nodeId);

    if (lite) {
-        return lite->is_favorite;
+        return nodeInfoLiteIsFavorite(lite);
    }
    return false;
 }
@@ -2016,14 +2435,14 @@ bool NodeDB::isFromOrToFavoritedNode(const meshtastic_MeshPacket &p)
        lite = &meshNodes->at(i);

        if (lite->num == p.from) {
-            if (lite->is_favorite)
+            if (nodeInfoLiteIsFavorite(lite))
                return true;

            seenFrom = true;
        }

        if (lite->num == p.to) {
-            if (lite->is_favorite)
+            if (nodeInfoLiteIsFavorite(lite))
                return true;

            seenTo = true;
@@ -2059,10 +2478,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 (meshNodes->at(i).is_favorite && !meshNodes->at(i - 1).is_favorite) {
+                } else if (nodeInfoLiteIsFavorite(&meshNodes->at(i)) && !nodeInfoLiteIsFavorite(&meshNodes->at(i - 1))) {
                    std::swap(meshNodes->at(i), meshNodes->at(i - 1));
                    changed = true;
-                } else if (!meshNodes->at(i).is_favorite && meshNodes->at(i - 1).is_favorite) {
+                } else if (!nodeInfoLiteIsFavorite(&meshNodes->at(i)) && nodeInfoLiteIsFavorite(&meshNodes->at(i - 1))) {
                    // noop
                } else if (meshNodes->at(i).last_heard > meshNodes->at(i - 1).last_heard) {
                    std::swap(meshNodes->at(i), meshNodes->at(i - 1));
@@ -2122,17 +2541,18 @@ 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 (!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;
+                if (!isFavoriteNode && !isIgnored && !isVerified && cand->last_heard < oldest) {
+                    oldest = cand->last_heard;
                    oldestIndex = i;
                }
                // The oldest "boring" node
-                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;
+                if (!isFavoriteNode && !isIgnored && cand->public_key.size == 0 && cand->last_heard < oldestBoring) {
+                    oldestBoring = cand->last_heard;
                    oldestBoringIndex = i;
                }
            }
@@ -2142,6 +2562,7 @@ 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);
@@ -2165,18 +2586,23 @@ meshtastic_NodeInfoLite *NodeDB::getOrCreateMeshNode(NodeNum n)
 /// valid lat/lon
 bool NodeDB::hasValidPosition(const meshtastic_NodeInfoLite *n)
 {
-    return n->has_position && (n->position.latitude_i != 0 || n->position.longitude_i != 0);
+    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);
 }

 /// If we have a node / user and they report is_licensed = true
 /// we consider them licensed
 UserLicenseStatus NodeDB::getLicenseStatus(uint32_t nodeNum)
 {
-    meshtastic_NodeInfoLite *info = getMeshNode(nodeNum);
-    if (!info || !info->has_user) {
+    const meshtastic_NodeInfoLite *info = getMeshNode(nodeNum);
+    if (!nodeInfoLiteHasUser(info))
        return UserLicenseStatus::NotKnown;
-    }
-    return info->user.is_licensed ? UserLicenseStatus::Licensed : UserLicenseStatus::NotLicensed;
+    return nodeInfoLiteIsLicensed(info) ? UserLicenseStatus::Licensed : UserLicenseStatus::NotLicensed;
 }

 #if !defined(MESHTASTIC_EXCLUDE_PKI)
@@ -6,10 +6,12 @@
 #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
@@ -82,7 +84,9 @@ 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 24
+#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_MIN_VER 24

 extern meshtastic_DeviceState devicestate;
@@ -166,6 +170,21 @@ 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;

@@ -277,6 +296,43 @@ 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()
@@ -285,7 +341,11 @@ class NodeDB
        emptyNodeDatabase.version = DEVICESTATE_CUR_VER;
        size_t nodeDatabaseSize;
        pb_get_encoded_size(&nodeDatabaseSize, meshtastic_NodeDatabase_fields, &emptyNodeDatabase);
-        return nodeDatabaseSize + (MAX_NUM_NODES * meshtastic_NodeInfoLite_size);
+        // 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);
    }

    // returns true if the maximum number of nodes is reached or we are running low on memory
@@ -329,6 +389,7 @@ 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
@@ -363,6 +424,11 @@ 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;
@@ -397,10 +463,74 @@ 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 (1 << NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_SHIFT)
+#define NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_MASK (1u << NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_SHIFT)
 #define NODEINFO_BITFIELD_IS_MUTED_SHIFT 1
-#define NODEINFO_BITFIELD_IS_MUTED_MASK (1 << NODEINFO_BITFIELD_IS_MUTED_SHIFT)
+#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 Module_Config_size                                                                                                       \
    (ModuleConfig_CannedMessageConfig_size + ModuleConfig_ExternalNotificationConfig_size + ModuleConfig_MQTTConfig_size +       \
@@ -0,0 +1,129 @@
+// 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;
+}
@@ -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), recentPackets(NULL) // Initialize members
+PacketHistory::PacketHistory(uint32_t size) : recentPacketsCapacity(0) // 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), recentPa

    // Allocate memory for the recent packets array
    recentPacketsCapacity = size;
-    recentPackets = new PacketRecord[recentPacketsCapacity];
+    recentPackets.reset(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,33 +43,20 @@ PacketHistory::PacketHistory(uint32_t size) : recentPacketsCapacity(0), recentPa
    }

    // Initialize the recent packets array to zero
-    memset(recentPackets, 0, sizeof(PacketRecord) * recentPacketsCapacity);
+    memset(recentPackets.get(), 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 = new uint16_t[hashCapacity];
+    hashIndex.reset(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, 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;
+    memset(hashIndex.get(), 0xFF, sizeof(uint16_t) * hashCapacity); // Fill with HASH_EMPTY (0xFFFF)
 #endif
 }

@@ -285,7 +272,7 @@ void PacketHistory::hashRebuild()
 {
    if (!hashIndex)
        return;
-    memset(hashIndex, 0xFF, sizeof(uint16_t) * hashCapacity);
+    memset(hashIndex.get(), 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);
@@ -332,7 +319,8 @@ PacketHistory::PacketRecord *PacketHistory::find(NodeNum sender, PacketId id)
 #endif

    // Linear scan (sole path when hash excluded, fallback when hash allocation failed)
-    for (PacketRecord *it = recentPackets; it < (recentPackets + recentPacketsCapacity); ++it) {
+    PacketRecord *base = recentPackets.get();
+    for (PacketRecord *it = base; it < (base + recentPacketsCapacity); ++it) {
        if (it->id == id && it->sender == sender) {
            return it;
        }
@@ -346,39 +334,38 @@ 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 = recentPackets; it < (recentPackets + recentPacketsCapacity); ++it) {
+    for (it = base; it < (base + 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 - recentPackets, recentPacketsCapacity);
+            LOG_DEBUG("Packet History - insert: Free slot@ %d/%d", tu - base, recentPacketsCapacity);
 #endif
            // We have that, Exit the loop
-            it = (recentPackets + recentPacketsCapacity);
+            it = (base + 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 - recentPackets, recentPacketsCapacity,
-                      OldtrxTimeMsec);
+            LOG_DEBUG("Packet History - insert: Matched slot@ %d/%d age=%d", tu - base, recentPacketsCapacity, OldtrxTimeMsec);
 #endif
            // We have that, Exit the loop
-            it = (recentPackets + recentPacketsCapacity);
+            it = (base + 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 - recentPackets, recentPacketsCapacity);
+                    it->sender, it->id, it - base, 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 - recentPackets, recentPacketsCapacity,
-                          OldtrxTimeMsec);
+                LOG_DEBUG("Packet History - insert: Older slot@ %d/%d age=%d", tu - base, recentPacketsCapacity, OldtrxTimeMsec);
 #endif
            }
            // keep looking for oldest till entire array is checked
@@ -393,13 +380,11 @@ 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 - recentPackets, recentPacketsCapacity);
+        LOG_DEBUG("Packet History - insert: slot@ %d/%d is NEW", tu - base, recentPacketsCapacity);
    } else if (tu->id == r.id && tu->sender == r.sender) {
-        LOG_DEBUG("Packet History - insert: slot@ %d/%d MATCHED, age=%d", tu - recentPackets, recentPacketsCapacity,
-                  OldtrxTimeMsec);
+        LOG_DEBUG("Packet History - insert: slot@ %d/%d MATCHED, age=%d", tu - base, recentPacketsCapacity, OldtrxTimeMsec);
    } else {
-        LOG_DEBUG("Packet History - insert: slot@ %d/%d REUSE OLDEST, age=%d", tu - recentPackets, recentPacketsCapacity,
-                  OldtrxTimeMsec);
+        LOG_DEBUG("Packet History - insert: slot@ %d/%d REUSE OLDEST, age=%d", tu - base, recentPacketsCapacity, OldtrxTimeMsec);
    }
 #endif

@@ -432,9 +417,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 - recentPackets, 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 - base,
+              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) {
@@ -454,16 +439,16 @@ void PacketHistory::insert(const PacketRecord &r)
    *tu = r; // store the packet

    if (!isMatchingSlot) {
-        hashInsert(r.sender, r.id, (uint16_t)(tu - recentPackets));
+        hashInsert(r.sender, r.id, (uint16_t)(tu - base));
    }
 #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 - recentPackets, 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 - base,
+              recentPacketsCapacity, tu->sender, tu->id, tu->next_hop, tu->relayed_by[0], tu->relayed_by[1], tu->relayed_by[2],
+              tu->rxTimeMsec);
 #endif
 }

@@ -1,6 +1,7 @@
 #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
@@ -26,7 +27,7 @@ class PacketHistory

    uint32_t recentPacketsCapacity =
        0; // Can be set in constructor, no need to recompile. Used to allocate memory for mx_recentPackets.
-    PacketRecord *recentPackets = NULL; // Simple and fixed in size. Debloat.
+    std::unique_ptr<PacketRecord[]> recentPackets; // 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.
@@ -34,7 +35,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;
-    uint16_t *hashIndex = NULL;
+    std::unique_ptr<uint16_t[]> hashIndex;
    uint32_t hashCapacity = 0; // Always a power of 2
    uint32_t hashMask = 0;     // hashCapacity - 1, for fast modular indexing

@@ -64,11 +65,8 @@ 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
@@ -100,5 +98,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 != NULL && recentPacketsCapacity != 0; }
+    bool initOk(void) { return recentPackets != nullptr && recentPacketsCapacity != 0; }
 };
@@ -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) {
+    if (config_nonce == SPECIAL_NONCE_ONLY_NODES || config_nonce == SPECIAL_NONCE_GRADIENT_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,6 +81,15 @@ 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();
 }
@@ -120,6 +129,15 @@ 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();
@@ -302,7 +320,7 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
                nodeInfoForPhone.num = 0;
            }
        }
-        if (config_nonce == SPECIAL_NONCE_ONLY_NODES) {
+        if (config_nonce == SPECIAL_NONCE_ONLY_NODES || config_nonce == SPECIAL_NONCE_GRADIENT_ONLY_NODES) {
            // If client only wants node info, jump directly to sending nodes
            state = STATE_SEND_OTHER_NODEINFOS;
            onNowHasData(0);
@@ -522,11 +540,6 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
            // LOG_INFO("nodeinfo: num=0x%x, lastseen=%u, id=%s, name=%s", nodeInfoForPhone.num, nodeInfoForPhone.last_heard,
            // nodeInfoForPhone.user.id, nodeInfoForPhone.user.long_name);

-            // Occasional progress logging. (readIndex==2 will be true for the first non-us node)
-            if (readIndex == 2 || readIndex % 20 == 0) {
-                LOG_DEBUG("nodeinfo: %d/%d", readIndex, nodeDB->getNumMeshNodes());
-            }
-
            fromRadioScratch.which_payload_variant = meshtastic_FromRadio_node_info_tag;
            fromRadioScratch.node_info = infoToSend;
            prefetchNodeInfos();
@@ -534,8 +547,124 @@ 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;
@@ -543,9 +672,9 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)

    case STATE_SEND_FILEMANIFEST: {
        LOG_DEBUG("FromRadio=STATE_SEND_FILEMANIFEST");
-        // last element
-        if (config_state == filesManifest.size() ||
-            config_nonce == SPECIAL_NONCE_ONLY_NODES) { // also handles an empty filesManifest
+        // ONLY_NODES variants skip the manifest.
+        if (config_state == filesManifest.size() || config_nonce == SPECIAL_NONCE_ONLY_NODES ||
+            config_nonce == SPECIAL_NONCE_GRADIENT_ONLY_NODES) {
            config_state = 0;
            filesManifest.clear();
            // Skip to complete packet
@@ -657,15 +786,19 @@ void PhoneAPI::releaseQueueStatusPhonePacket()
 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);
+        wasEmpty = nodeInfoQueue.empty();
        while (nodeInfoQueue.size() < kNodePrefetchDepth) {
            auto nextNode = nodeDB->readNextMeshNode(readIndex);
            if (!nextNode)
                break;

-            auto info = TypeConversions::ConvertToNodeInfo(nextNode);
+            auto info =
+                gradient ? TypeConversions::ConvertToNodeInfoThin(nextNode) : 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;
@@ -673,14 +806,269 @@ void PhoneAPI::prefetchNodeInfos()
            info.via_mqtt = isUs ? false : info.via_mqtt;
            info.is_favorite = info.is_favorite || isUs;
            nodeInfoQueue.push_back(info);
+            // Log progress here (at fetch time) so readIndex is accurate and each value logs only once.
+            if (readIndex == 2 || readIndex % 20 == 0) {
+                LOG_DEBUG("nodeinfo: %d/%d", readIndex, nodeDB->getNumMeshNodes());
+            }
            added = true;
        }
    }

-    if (added)
+    if (added && wasEmpty)
        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) {
@@ -727,6 +1115,31 @@ 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();
@@ -4,12 +4,16 @@
 #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

@@ -22,6 +26,9 @@

 #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
@@ -45,7 +52,13 @@ 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
-        STATE_SEND_FILEMANIFEST,    // Send file manifest
+        // 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_COMPLETE_ID,
        STATE_SEND_PACKETS // send packets or debug strings
    };
@@ -88,6 +101,20 @@ 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

@@ -137,6 +164,10 @@ 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
@@ -185,6 +216,18 @@ 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();

@@ -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) ? node->user.short_name : "???";
+        const char *sender = (node && nodeInfoLiteHasUser(node) && node->short_name[0]) ? node->short_name : "???";
        return sender;
    }

@@ -121,4 +121,4 @@ template <class T> class ProtobufModule : protected SinglePortModule
            return alterReceivedProtobuf(mp, decoded);
        }
    }
-};
+};
@@ -252,7 +252,7 @@ bool RF95Interface::reconfigure()

    startReceive(); // restart receiving

-    return RADIOLIB_ERR_NONE;
+    return true;
 }

 /**
@@ -5,6 +5,7 @@
 #include "LR1110Interface.h"
 #include "LR1120Interface.h"
 #include "LR1121Interface.h"
+#include "LR2021Interface.h"
 #include "MeshRadio.h"
 #include "MeshService.h"
 #include "NodeDB.h"
@@ -478,6 +479,20 @@ 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));
@@ -119,7 +119,7 @@ bool RadioLibInterface::canSendImmediately()
        return true;
 }

-bool RadioLibInterface::receiveDetected(uint16_t irq, ulong syncWordHeaderValidFlag, ulong preambleDetectedFlag)
+bool RadioLibInterface::receiveDetected(uint16_t irq, unsigned long syncWordHeaderValidFlag, unsigned long preambleDetectedFlag)
 {
    bool detected = (irq & (syncWordHeaderValidFlag | preambleDetectedFlag));
    // Handle false detections
@@ -220,7 +220,7 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified
  protected:
    uint32_t activeReceiveStart = 0;

-    bool receiveDetected(uint16_t irq, ulong syncWordHeaderValidFlag, ulong preambleDetectedFlag);
+    bool receiveDetected(uint16_t irq, unsigned long syncWordHeaderValidFlag, unsigned long preambleDetectedFlag);

    /** Do any hardware setup needed on entry into send configuration for the radio.
     * Subclasses can customize, but must also call this base method */
@@ -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)->user.public_key.size == 0)) {
+                           (nodeDB->getMeshNode(p->from) == nullptr || nodeDB->getMeshNode(p->from)->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));
@@ -120,17 +120,17 @@ bool Router::shouldDecrementHopLimit(const meshtastic_MeshPacket *p)
        if (!node)
            continue;

-        // Check 1: is_favorite (cheapest - single bool)
-        if (!node->is_favorite)
+        // Check 1: is_favorite (cheapest - single bit test)
+        if (!nodeInfoLiteIsFavorite(node))
            continue;

-        // Check 2: has_user (cheap - single bool)
-        if (!node->has_user)
+        // Check 2: has_user (cheap - single bit test)
+        if (!nodeInfoLiteHasUser(node))
            continue;

        // Check 3: role check (moderate cost - multiple comparisons)
-        if (!IS_ONE_OF(node->user.role, meshtastic_Config_DeviceConfig_Role_ROUTER,
-                       meshtastic_Config_DeviceConfig_Role_ROUTER_LATE, meshtastic_Config_DeviceConfig_Role_CLIENT_BASE)) {
+        if (!IS_ONE_OF(node->role, meshtastic_Config_DeviceConfig_Role_ROUTER, meshtastic_Config_DeviceConfig_Role_ROUTER_LATE,
+                       meshtastic_Config_DeviceConfig_Role_CLIENT_BASE)) {
            continue;
        }

@@ -433,7 +433,7 @@ DecodeState perhapsDecode(meshtastic_MeshPacket *p)
    concurrency::LockGuard g(cryptLock);

    if (config.device.rebroadcast_mode == meshtastic_Config_DeviceConfig_RebroadcastMode_KNOWN_ONLY &&
-        (nodeDB->getMeshNode(p->from) == NULL || !nodeDB->getMeshNode(p->from)->has_user)) {
+        !nodeInfoLiteHasUser(nodeDB->getMeshNode(p->from))) {
        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)->user.public_key.size > 0 && nodeDB->getMeshNode(p->to)->user.public_key.size > 0 &&
-        rawSize > MESHTASTIC_PKC_OVERHEAD) {
+        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) {
        LOG_DEBUG("Attempt PKI decryption");

-        if (crypto->decryptCurve25519(p->from, nodeDB->getMeshNode(p->from)->user.public_key, p->id, rawSize, p->encrypted.bytes,
+        if (crypto->decryptCurve25519(p->from, nodeDB->getMeshNode(p->from)->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)->user.public_key.bytes, 32);
+                memcpy(&p->public_key.bytes, nodeDB->getMeshNode(p->from)->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->user.public_key.size != 32) {
+            if (node == nullptr || node->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->user.public_key.bytes, 32) != 0) {
+                memcmp(p->public_key.bytes, node->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->user.public_key.bytes);
+                         *node->public_key.bytes);
                return meshtastic_Routing_Error_PKI_FAILED;
            }
-            crypto->encryptCurve25519(p->to, getFrom(p), node->user.public_key, p->id, numbytes, bytes, p->encrypted.bytes);
+            crypto->encryptCurve25519(p->to, getFrom(p), node->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 (node != NULL && node->is_ignored) {
+    if (nodeInfoLiteIsIgnored(node)) {
        LOG_DEBUG("Ignore msg, 0x%x is ignored", p->from);
        packetPool.release(p);
        return;
@@ -262,7 +262,7 @@ template <typename T> bool SX126xInterface<T>::reconfigure()

    startReceive(); // restart receiving

-    return RADIOLIB_ERR_NONE;
+    return true;
 }

 template <typename T> void SX126xInterface<T>::disableInterrupt()
@@ -153,7 +153,7 @@ template <typename T> bool SX128xInterface<T>::reconfigure()

    startReceive(); // restart receiving

-    return RADIOLIB_ERR_NONE;
+    return true;
 }

 template <typename T> void SX128xInterface<T>::disableInterrupt()
@@ -3,7 +3,9 @@
 #include "mesh/generated/meshtastic/mesh.pb.h"
 #include "meshUtils.h"

-meshtastic_NodeInfo TypeConversions::ConvertToNodeInfo(const meshtastic_NodeInfoLite *lite)
+meshtastic_NodeInfo TypeConversions::ConvertToNodeInfo(const meshtastic_NodeInfoLite *lite,
+                                                       const meshtastic_PositionLite *position,
+                                                       const meshtastic_DeviceMetrics *deviceMetrics)
 {
    meshtastic_NodeInfo info = meshtastic_NodeInfo_init_default;

@@ -11,42 +13,56 @@ meshtastic_NodeInfo TypeConversions::ConvertToNodeInfo(const meshtastic_NodeInfo
    info.snr = lite->snr;
    info.last_heard = lite->last_heard;
    info.channel = lite->channel;
-    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;
+    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);

    if (lite->has_hops_away) {
        info.has_hops_away = true;
        info.hops_away = lite->hops_away;
    }

-    if (lite->has_position) {
+    if (position) {
        info.has_position = true;
-        if (lite->position.latitude_i != 0)
+        if (position->latitude_i != 0)
            info.position.has_latitude_i = true;
-        info.position.latitude_i = lite->position.latitude_i;
-        if (lite->position.longitude_i != 0)
+        info.position.latitude_i = position->latitude_i;
+        if (position->longitude_i != 0)
            info.position.has_longitude_i = true;
-        info.position.longitude_i = lite->position.longitude_i;
-        if (lite->position.altitude != 0)
+        info.position.longitude_i = position->longitude_i;
+        if (position->altitude != 0)
            info.position.has_altitude = true;
-        info.position.altitude = lite->position.altitude;
-        info.position.location_source = lite->position.location_source;
-        info.position.time = lite->position.time;
+        info.position.altitude = position->altitude;
+        info.position.location_source = position->location_source;
+        info.position.time = position->time;
    }
-    if (lite->has_user) {
+    if (nodeInfoLiteHasUser(lite)) {
        info.has_user = true;
-        info.user = ConvertToUser(lite->num, lite->user);
+        info.user = ConvertToUser(lite);
    }
-    if (lite->has_device_metrics) {
+    if (deviceMetrics) {
        info.has_device_metrics = true;
-        info.device_metrics = lite->device_metrics;
+        info.device_metrics = *deviceMetrics;
    }
    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;
@@ -77,46 +93,50 @@ meshtastic_Position TypeConversions::ConvertToPosition(meshtastic_PositionLite l
    return position;
 }

-meshtastic_UserLite TypeConversions::ConvertToUserLite(meshtastic_User user)
+void TypeConversions::CopyUserToNodeInfoLite(meshtastic_NodeInfoLite *lite, const meshtastic_User &user)
 {
-    meshtastic_UserLite lite = meshtastic_UserLite_init_default;
+    if (!lite)
+        return;

-    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;
+    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);
 }

-meshtastic_User TypeConversions::ConvertToUser(uint32_t nodeNum, meshtastic_UserLite lite)
+meshtastic_User TypeConversions::ConvertToUser(const meshtastic_NodeInfoLite *lite)
 {
    meshtastic_User user = meshtastic_User_init_default;
+    if (!lite)
+        return user;

-    snprintf(user.id, sizeof(user.id), "!%08x", nodeNum);
-    strncpy(user.long_name, lite.long_name, sizeof(user.long_name));
+    snprintf(user.id, sizeof(user.id), "!%08x", lite->num);
+    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 = 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;
+    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));

    return user;
-}
+}
@@ -7,9 +7,16 @@
 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 meshtastic_UserLite ConvertToUserLite(meshtastic_User user);
-    static meshtastic_User ConvertToUser(uint32_t nodeNum, meshtastic_UserLite lite);
+
+    static void CopyUserToNodeInfoLite(meshtastic_NodeInfoLite *lite, const meshtastic_User &user);
+    static meshtastic_User ConvertToUser(const meshtastic_NodeInfoLite *lite);
 };
@@ -55,7 +55,7 @@ extern const pb_msgdesc_t meshtastic_ChannelSet_msg;

 /* Maximum encoded size of messages (where known) */
 #define MESHTASTIC_MESHTASTIC_APPONLY_PB_H_MAX_SIZE meshtastic_ChannelSet_size
-#define meshtastic_ChannelSet_size               682
+#define meshtastic_ChannelSet_size               685

 #ifdef __cplusplus
 } /* extern "C" */
@@ -618,6 +618,8 @@ typedef struct _meshtastic_Config_LoRaConfig {
    bool config_ok_to_mqtt;
    /* Set where LORA FEM is enabled, disabled, or not present */
    meshtastic_Config_LoRaConfig_FEM_LNA_Mode fem_lna_mode;
+    /* Don't use radiolib to initialize the radio, instead listen for a serialHal connection */
+    bool serial_hal_only;
 } meshtastic_Config_LoRaConfig;

 typedef struct _meshtastic_Config_BluetoothConfig {
@@ -779,7 +781,7 @@ extern "C" {
 #define meshtastic_Config_NetworkConfig_init_default {0, "", "", "", 0, _meshtastic_Config_NetworkConfig_AddressMode_MIN, false, meshtastic_Config_NetworkConfig_IpV4Config_init_default, "", 0, 0}
 #define meshtastic_Config_NetworkConfig_IpV4Config_init_default {0, 0, 0, 0}
 #define meshtastic_Config_DisplayConfig_init_default {0, _meshtastic_Config_DisplayConfig_DeprecatedGpsCoordinateFormat_MIN, 0, 0, 0, _meshtastic_Config_DisplayConfig_DisplayUnits_MIN, _meshtastic_Config_DisplayConfig_OledType_MIN, _meshtastic_Config_DisplayConfig_DisplayMode_MIN, 0, 0, _meshtastic_Config_DisplayConfig_CompassOrientation_MIN, 0, 0, 0}
-#define meshtastic_Config_LoRaConfig_init_default {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0, _meshtastic_Config_LoRaConfig_FEM_LNA_Mode_MIN}
+#define meshtastic_Config_LoRaConfig_init_default {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0, _meshtastic_Config_LoRaConfig_FEM_LNA_Mode_MIN, 0}
 #define meshtastic_Config_BluetoothConfig_init_default {0, _meshtastic_Config_BluetoothConfig_PairingMode_MIN, 0}
 #define meshtastic_Config_SecurityConfig_init_default {{0, {0}}, {0, {0}}, 0, {{0, {0}}, {0, {0}}, {0, {0}}}, 0, 0, 0, 0}
 #define meshtastic_Config_SessionkeyConfig_init_default {0}
@@ -790,7 +792,7 @@ extern "C" {
 #define meshtastic_Config_NetworkConfig_init_zero {0, "", "", "", 0, _meshtastic_Config_NetworkConfig_AddressMode_MIN, false, meshtastic_Config_NetworkConfig_IpV4Config_init_zero, "", 0, 0}
 #define meshtastic_Config_NetworkConfig_IpV4Config_init_zero {0, 0, 0, 0}
 #define meshtastic_Config_DisplayConfig_init_zero {0, _meshtastic_Config_DisplayConfig_DeprecatedGpsCoordinateFormat_MIN, 0, 0, 0, _meshtastic_Config_DisplayConfig_DisplayUnits_MIN, _meshtastic_Config_DisplayConfig_OledType_MIN, _meshtastic_Config_DisplayConfig_DisplayMode_MIN, 0, 0, _meshtastic_Config_DisplayConfig_CompassOrientation_MIN, 0, 0, 0}
-#define meshtastic_Config_LoRaConfig_init_zero   {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0, _meshtastic_Config_LoRaConfig_FEM_LNA_Mode_MIN}
+#define meshtastic_Config_LoRaConfig_init_zero   {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0, _meshtastic_Config_LoRaConfig_FEM_LNA_Mode_MIN, 0}
 #define meshtastic_Config_BluetoothConfig_init_zero {0, _meshtastic_Config_BluetoothConfig_PairingMode_MIN, 0}
 #define meshtastic_Config_SecurityConfig_init_zero {{0, {0}}, {0, {0}}, 0, {{0, {0}}, {0, {0}}, {0, {0}}}, 0, 0, 0, 0}
 #define meshtastic_Config_SessionkeyConfig_init_zero {0}
@@ -877,6 +879,7 @@ extern "C" {
 #define meshtastic_Config_LoRaConfig_ignore_mqtt_tag 104
 #define meshtastic_Config_LoRaConfig_config_ok_to_mqtt_tag 105
 #define meshtastic_Config_LoRaConfig_fem_lna_mode_tag 106
+#define meshtastic_Config_LoRaConfig_serial_hal_only_tag 107
 #define meshtastic_Config_BluetoothConfig_enabled_tag 1
 #define meshtastic_Config_BluetoothConfig_mode_tag 2
 #define meshtastic_Config_BluetoothConfig_fixed_pin_tag 3
@@ -1029,7 +1032,8 @@ X(a, STATIC,   SINGULAR, BOOL,     pa_fan_disabled,  15) \
 X(a, STATIC,   REPEATED, UINT32,   ignore_incoming, 103) \
 X(a, STATIC,   SINGULAR, BOOL,     ignore_mqtt,     104) \
 X(a, STATIC,   SINGULAR, BOOL,     config_ok_to_mqtt, 105) \
-X(a, STATIC,   SINGULAR, UENUM,    fem_lna_mode,    106)
+X(a, STATIC,   SINGULAR, UENUM,    fem_lna_mode,    106) \
+X(a, STATIC,   SINGULAR, BOOL,     serial_hal_only, 107)
 #define meshtastic_Config_LoRaConfig_CALLBACK NULL
 #define meshtastic_Config_LoRaConfig_DEFAULT NULL

@@ -1086,7 +1090,7 @@ extern const pb_msgdesc_t meshtastic_Config_SessionkeyConfig_msg;
 #define meshtastic_Config_BluetoothConfig_size   10
 #define meshtastic_Config_DeviceConfig_size      100
 #define meshtastic_Config_DisplayConfig_size     36
-#define meshtastic_Config_LoRaConfig_size        88
+#define meshtastic_Config_LoRaConfig_size        91
 #define meshtastic_Config_NetworkConfig_IpV4Config_size 20
 #define meshtastic_Config_NetworkConfig_size     204
 #define meshtastic_Config_PositionConfig_size    62
@@ -18,6 +18,18 @@ PB_BIND(meshtastic_NodeInfoLite, meshtastic_NodeInfoLite, AUTO)
 PB_BIND(meshtastic_DeviceState, meshtastic_DeviceState, 2)


+PB_BIND(meshtastic_NodePositionEntry, meshtastic_NodePositionEntry, AUTO)
+
+
+PB_BIND(meshtastic_NodeTelemetryEntry, meshtastic_NodeTelemetryEntry, AUTO)
+
+
+PB_BIND(meshtastic_NodeEnvironmentEntry, meshtastic_NodeEnvironmentEntry, AUTO)
+
+
+PB_BIND(meshtastic_NodeStatusEntry, meshtastic_NodeStatusEntry, AUTO)
+
+
 PB_BIND(meshtastic_NodeDatabase, meshtastic_NodeDatabase, AUTO)


@@ -63,43 +63,35 @@ typedef struct _meshtastic_UserLite {
    bool is_unmessagable;
 } meshtastic_UserLite;

+typedef PB_BYTES_ARRAY_T(32) meshtastic_NodeInfoLite_public_key_t;
 typedef struct _meshtastic_NodeInfoLite {
    /* The node number */
    uint32_t num;
-    /* The user info for this node */
-    bool has_user;
-    meshtastic_UserLite user;
-    /* This position data. Note: before 1.2.14 we would also store the last time we've heard from this node in position.time, that is no longer true.
- Position.time now indicates the last time we received a POSITION from that node. */
-    bool has_position;
-    meshtastic_PositionLite position;
    /* Returns the Signal-to-noise ratio (SNR) of the last received message,
 as measured by the receiver. Return SNR of the last received message in dB */
    float snr;
    /* Set to indicate the last time we received a packet from this node */
    uint32_t last_heard;
-    /* The latest device metrics for the node. */
-    bool has_device_metrics;
-    meshtastic_DeviceMetrics device_metrics;
    /* local channel index we heard that node on. Only populated if its not the default channel. */
    uint8_t channel;
-    /* True if we witnessed the node over MQTT instead of LoRA transport */
-    bool via_mqtt;
    /* Number of hops away from us this node is (0 if direct neighbor) */
    bool has_hops_away;
    uint8_t hops_away;
-    /* True if node is in our favorites list
- Persists between NodeDB internal clean ups */
-    bool is_favorite;
-    /* True if node is in our ignored list
- Persists between NodeDB internal clean ups */
-    bool is_ignored;
    /* Last byte of the node number of the node that should be used as the next hop to reach this node. */
    uint8_t next_hop;
-    /* Bitfield for storing booleans.
- LSB 0 is_key_manually_verified
- LSB 1 is_muted */
+    /* Bitfield for storing booleans. See NODEINFO_BITFIELD_* in src/mesh/NodeDB.h. */
    uint32_t bitfield;
+    /* A full name for this user, i.e. "Kevin Hester". */
+    char long_name[25];
+    /* A VERY short name, ideally two characters or an emoji.
+ Suitable for a tiny OLED screen. */
+    char short_name[5];
+    /* Hardware model the user's device is running. */
+    meshtastic_HardwareModel hw_model;
+    /* The user's role in the mesh. */
+    meshtastic_Config_DeviceConfig_Role role;
+    /* The public key of the user's device, for PKI-based encrypted DMs. */
+    meshtastic_NodeInfoLite_public_key_t public_key;
 } meshtastic_NodeInfoLite;

 /* This message is never sent over the wire, but it is used for serializing DB
@@ -143,6 +135,30 @@ typedef struct _meshtastic_DeviceState {
    meshtastic_NodeRemoteHardwarePin node_remote_hardware_pins[12];
 } meshtastic_DeviceState;

+typedef struct _meshtastic_NodePositionEntry {
+    uint32_t num;
+    bool has_position;
+    meshtastic_PositionLite position;
+} meshtastic_NodePositionEntry;
+
+typedef struct _meshtastic_NodeTelemetryEntry {
+    uint32_t num;
+    bool has_device_metrics;
+    meshtastic_DeviceMetrics device_metrics;
+} meshtastic_NodeTelemetryEntry;
+
+typedef struct _meshtastic_NodeEnvironmentEntry {
+    uint32_t num;
+    bool has_environment_metrics;
+    meshtastic_EnvironmentMetrics environment_metrics;
+} meshtastic_NodeEnvironmentEntry;
+
+typedef struct _meshtastic_NodeStatusEntry {
+    uint32_t num;
+    bool has_status;
+    meshtastic_StatusMessage status;
+} meshtastic_NodeStatusEntry;
+
 typedef struct _meshtastic_NodeDatabase {
    /* A version integer used to invalidate old save files when we make
 incompatible changes This integer is set at build time and is private to
@@ -150,6 +166,12 @@ typedef struct _meshtastic_NodeDatabase {
    uint32_t version;
    /* New lite version of NodeDB to decrease memory footprint */
    std::vector<meshtastic_NodeInfoLite> nodes;
+    /* Per-NodeNum satellite arrays. Constrained platforms (e.g. STM32WL) omit
+ these via MESHTASTIC_EXCLUDE_*DB build flags. */
+    std::vector<meshtastic_NodePositionEntry> positions;
+    std::vector<meshtastic_NodeTelemetryEntry> telemetry;
+    std::vector<meshtastic_NodeStatusEntry> status;
+    std::vector<meshtastic_NodeEnvironmentEntry> environment;
 } meshtastic_NodeDatabase;

 /* The on-disk saved channels */
@@ -191,16 +213,24 @@ extern "C" {
 /* Initializer values for message structs */
 #define meshtastic_PositionLite_init_default     {0, 0, 0, 0, _meshtastic_Position_LocSource_MIN}
 #define meshtastic_UserLite_init_default         {{0}, "", "", _meshtastic_HardwareModel_MIN, 0, _meshtastic_Config_DeviceConfig_Role_MIN, {0, {0}}, false, 0}
-#define meshtastic_NodeInfoLite_init_default     {0, false, meshtastic_UserLite_init_default, false, meshtastic_PositionLite_init_default, 0, 0, false, meshtastic_DeviceMetrics_init_default, 0, 0, false, 0, 0, 0, 0, 0}
+#define meshtastic_NodeInfoLite_init_default     {0, 0, 0, 0, false, 0, 0, 0, "", "", _meshtastic_HardwareModel_MIN, _meshtastic_Config_DeviceConfig_Role_MIN, {0, {0}}}
 #define meshtastic_DeviceState_init_default      {false, meshtastic_MyNodeInfo_init_default, false, meshtastic_User_init_default, 0, {meshtastic_MeshPacket_init_default}, false, meshtastic_MeshPacket_init_default, 0, 0, 0, false, meshtastic_MeshPacket_init_default, 0, {meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default}}
-#define meshtastic_NodeDatabase_init_default     {0, {0}}
+#define meshtastic_NodePositionEntry_init_default {0, false, meshtastic_PositionLite_init_default}
+#define meshtastic_NodeTelemetryEntry_init_default {0, false, meshtastic_DeviceMetrics_init_default}
+#define meshtastic_NodeEnvironmentEntry_init_default {0, false, meshtastic_EnvironmentMetrics_init_default}
+#define meshtastic_NodeStatusEntry_init_default  {0, false, meshtastic_StatusMessage_init_default}
+#define meshtastic_NodeDatabase_init_default     {0, {0}, {0}, {0}, {0}, {0}}
 #define meshtastic_ChannelFile_init_default      {0, {meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default}, 0}
 #define meshtastic_BackupPreferences_init_default {0, 0, false, meshtastic_LocalConfig_init_default, false, meshtastic_LocalModuleConfig_init_default, false, meshtastic_ChannelFile_init_default, false, meshtastic_User_init_default}
 #define meshtastic_PositionLite_init_zero        {0, 0, 0, 0, _meshtastic_Position_LocSource_MIN}
 #define meshtastic_UserLite_init_zero            {{0}, "", "", _meshtastic_HardwareModel_MIN, 0, _meshtastic_Config_DeviceConfig_Role_MIN, {0, {0}}, false, 0}
-#define meshtastic_NodeInfoLite_init_zero        {0, false, meshtastic_UserLite_init_zero, false, meshtastic_PositionLite_init_zero, 0, 0, false, meshtastic_DeviceMetrics_init_zero, 0, 0, false, 0, 0, 0, 0, 0}
+#define meshtastic_NodeInfoLite_init_zero        {0, 0, 0, 0, false, 0, 0, 0, "", "", _meshtastic_HardwareModel_MIN, _meshtastic_Config_DeviceConfig_Role_MIN, {0, {0}}}
 #define meshtastic_DeviceState_init_zero         {false, meshtastic_MyNodeInfo_init_zero, false, meshtastic_User_init_zero, 0, {meshtastic_MeshPacket_init_zero}, false, meshtastic_MeshPacket_init_zero, 0, 0, 0, false, meshtastic_MeshPacket_init_zero, 0, {meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero}}
-#define meshtastic_NodeDatabase_init_zero        {0, {0}}
+#define meshtastic_NodePositionEntry_init_zero   {0, false, meshtastic_PositionLite_init_zero}
+#define meshtastic_NodeTelemetryEntry_init_zero  {0, false, meshtastic_DeviceMetrics_init_zero}
+#define meshtastic_NodeEnvironmentEntry_init_zero {0, false, meshtastic_EnvironmentMetrics_init_zero}
+#define meshtastic_NodeStatusEntry_init_zero     {0, false, meshtastic_StatusMessage_init_zero}
+#define meshtastic_NodeDatabase_init_zero        {0, {0}, {0}, {0}, {0}, {0}}
 #define meshtastic_ChannelFile_init_zero         {0, {meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero, meshtastic_Channel_init_zero}, 0}
 #define meshtastic_BackupPreferences_init_zero   {0, 0, false, meshtastic_LocalConfig_init_zero, false, meshtastic_LocalModuleConfig_init_zero, false, meshtastic_ChannelFile_init_zero, false, meshtastic_User_init_zero}

@@ -219,18 +249,17 @@ extern "C" {
 #define meshtastic_UserLite_public_key_tag       7
 #define meshtastic_UserLite_is_unmessagable_tag  9
 #define meshtastic_NodeInfoLite_num_tag          1
-#define meshtastic_NodeInfoLite_user_tag         2
-#define meshtastic_NodeInfoLite_position_tag     3
 #define meshtastic_NodeInfoLite_snr_tag          4
 #define meshtastic_NodeInfoLite_last_heard_tag   5
-#define meshtastic_NodeInfoLite_device_metrics_tag 6
 #define meshtastic_NodeInfoLite_channel_tag      7
-#define meshtastic_NodeInfoLite_via_mqtt_tag     8
 #define meshtastic_NodeInfoLite_hops_away_tag    9
-#define meshtastic_NodeInfoLite_is_favorite_tag  10
-#define meshtastic_NodeInfoLite_is_ignored_tag   11
 #define meshtastic_NodeInfoLite_next_hop_tag     12
 #define meshtastic_NodeInfoLite_bitfield_tag     13
+#define meshtastic_NodeInfoLite_long_name_tag    14
+#define meshtastic_NodeInfoLite_short_name_tag   15
+#define meshtastic_NodeInfoLite_hw_model_tag     16
+#define meshtastic_NodeInfoLite_role_tag         17
+#define meshtastic_NodeInfoLite_public_key_tag   18
 #define meshtastic_DeviceState_my_node_tag       2
 #define meshtastic_DeviceState_owner_tag         3
 #define meshtastic_DeviceState_receive_queue_tag 5
@@ -240,8 +269,20 @@ extern "C" {
 #define meshtastic_DeviceState_did_gps_reset_tag 11
 #define meshtastic_DeviceState_rx_waypoint_tag   12
 #define meshtastic_DeviceState_node_remote_hardware_pins_tag 13
+#define meshtastic_NodePositionEntry_num_tag     1
+#define meshtastic_NodePositionEntry_position_tag 2
+#define meshtastic_NodeTelemetryEntry_num_tag    1
+#define meshtastic_NodeTelemetryEntry_device_metrics_tag 2
+#define meshtastic_NodeEnvironmentEntry_num_tag  1
+#define meshtastic_NodeEnvironmentEntry_environment_metrics_tag 2
+#define meshtastic_NodeStatusEntry_num_tag       1
+#define meshtastic_NodeStatusEntry_status_tag    2
 #define meshtastic_NodeDatabase_version_tag      1
 #define meshtastic_NodeDatabase_nodes_tag        2
+#define meshtastic_NodeDatabase_positions_tag    3
+#define meshtastic_NodeDatabase_telemetry_tag    4
+#define meshtastic_NodeDatabase_status_tag       5
+#define meshtastic_NodeDatabase_environment_tag  6
 #define meshtastic_ChannelFile_channels_tag      1
 #define meshtastic_ChannelFile_version_tag       2
 #define meshtastic_BackupPreferences_version_tag 1
@@ -275,23 +316,19 @@ X(a, STATIC,   OPTIONAL, BOOL,     is_unmessagable,   9)

 #define meshtastic_NodeInfoLite_FIELDLIST(X, a) \
 X(a, STATIC,   SINGULAR, UINT32,   num,               1) \
-X(a, STATIC,   OPTIONAL, MESSAGE,  user,              2) \
-X(a, STATIC,   OPTIONAL, MESSAGE,  position,          3) \
 X(a, STATIC,   SINGULAR, FLOAT,    snr,               4) \
 X(a, STATIC,   SINGULAR, FIXED32,  last_heard,        5) \
-X(a, STATIC,   OPTIONAL, MESSAGE,  device_metrics,    6) \
 X(a, STATIC,   SINGULAR, UINT32,   channel,           7) \
-X(a, STATIC,   SINGULAR, BOOL,     via_mqtt,          8) \
 X(a, STATIC,   OPTIONAL, UINT32,   hops_away,         9) \
-X(a, STATIC,   SINGULAR, BOOL,     is_favorite,      10) \
-X(a, STATIC,   SINGULAR, BOOL,     is_ignored,       11) \
 X(a, STATIC,   SINGULAR, UINT32,   next_hop,         12) \
-X(a, STATIC,   SINGULAR, UINT32,   bitfield,         13)
+X(a, STATIC,   SINGULAR, UINT32,   bitfield,         13) \
+X(a, STATIC,   SINGULAR, STRING,   long_name,        14) \
+X(a, STATIC,   SINGULAR, STRING,   short_name,       15) \
+X(a, STATIC,   SINGULAR, UENUM,    hw_model,         16) \
+X(a, STATIC,   SINGULAR, UENUM,    role,             17) \
+X(a, STATIC,   SINGULAR, BYTES,    public_key,       18)
 #define meshtastic_NodeInfoLite_CALLBACK NULL
 #define meshtastic_NodeInfoLite_DEFAULT NULL
-#define meshtastic_NodeInfoLite_user_MSGTYPE meshtastic_UserLite
-#define meshtastic_NodeInfoLite_position_MSGTYPE meshtastic_PositionLite
-#define meshtastic_NodeInfoLite_device_metrics_MSGTYPE meshtastic_DeviceMetrics

 #define meshtastic_DeviceState_FIELDLIST(X, a) \
 X(a, STATIC,   OPTIONAL, MESSAGE,  my_node,           2) \
@@ -312,13 +349,49 @@ X(a, STATIC,   REPEATED, MESSAGE,  node_remote_hardware_pins,  13)
 #define meshtastic_DeviceState_rx_waypoint_MSGTYPE meshtastic_MeshPacket
 #define meshtastic_DeviceState_node_remote_hardware_pins_MSGTYPE meshtastic_NodeRemoteHardwarePin

+#define meshtastic_NodePositionEntry_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   num,               1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  position,          2)
+#define meshtastic_NodePositionEntry_CALLBACK NULL
+#define meshtastic_NodePositionEntry_DEFAULT NULL
+#define meshtastic_NodePositionEntry_position_MSGTYPE meshtastic_PositionLite
+
+#define meshtastic_NodeTelemetryEntry_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   num,               1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  device_metrics,    2)
+#define meshtastic_NodeTelemetryEntry_CALLBACK NULL
+#define meshtastic_NodeTelemetryEntry_DEFAULT NULL
+#define meshtastic_NodeTelemetryEntry_device_metrics_MSGTYPE meshtastic_DeviceMetrics
+
+#define meshtastic_NodeEnvironmentEntry_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   num,               1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  environment_metrics,   2)
+#define meshtastic_NodeEnvironmentEntry_CALLBACK NULL
+#define meshtastic_NodeEnvironmentEntry_DEFAULT NULL
+#define meshtastic_NodeEnvironmentEntry_environment_metrics_MSGTYPE meshtastic_EnvironmentMetrics
+
+#define meshtastic_NodeStatusEntry_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   num,               1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  status,            2)
+#define meshtastic_NodeStatusEntry_CALLBACK NULL
+#define meshtastic_NodeStatusEntry_DEFAULT NULL
+#define meshtastic_NodeStatusEntry_status_MSGTYPE meshtastic_StatusMessage
+
 #define meshtastic_NodeDatabase_FIELDLIST(X, a) \
 X(a, STATIC,   SINGULAR, UINT32,   version,           1) \
-X(a, CALLBACK, REPEATED, MESSAGE,  nodes,             2)
+X(a, CALLBACK, REPEATED, MESSAGE,  nodes,             2) \
+X(a, CALLBACK, REPEATED, MESSAGE,  positions,         3) \
+X(a, CALLBACK, REPEATED, MESSAGE,  telemetry,         4) \
+X(a, CALLBACK, REPEATED, MESSAGE,  status,            5) \
+X(a, CALLBACK, REPEATED, MESSAGE,  environment,       6)
 extern bool meshtastic_NodeDatabase_callback(pb_istream_t *istream, pb_ostream_t *ostream, const pb_field_t *field);
 #define meshtastic_NodeDatabase_CALLBACK meshtastic_NodeDatabase_callback
 #define meshtastic_NodeDatabase_DEFAULT NULL
 #define meshtastic_NodeDatabase_nodes_MSGTYPE meshtastic_NodeInfoLite
+#define meshtastic_NodeDatabase_positions_MSGTYPE meshtastic_NodePositionEntry
+#define meshtastic_NodeDatabase_telemetry_MSGTYPE meshtastic_NodeTelemetryEntry
+#define meshtastic_NodeDatabase_status_MSGTYPE meshtastic_NodeStatusEntry
+#define meshtastic_NodeDatabase_environment_MSGTYPE meshtastic_NodeEnvironmentEntry

 #define meshtastic_ChannelFile_FIELDLIST(X, a) \
 X(a, STATIC,   REPEATED, MESSAGE,  channels,          1) \
@@ -345,6 +418,10 @@ extern const pb_msgdesc_t meshtastic_PositionLite_msg;
 extern const pb_msgdesc_t meshtastic_UserLite_msg;
 extern const pb_msgdesc_t meshtastic_NodeInfoLite_msg;
 extern const pb_msgdesc_t meshtastic_DeviceState_msg;
+extern const pb_msgdesc_t meshtastic_NodePositionEntry_msg;
+extern const pb_msgdesc_t meshtastic_NodeTelemetryEntry_msg;
+extern const pb_msgdesc_t meshtastic_NodeEnvironmentEntry_msg;
+extern const pb_msgdesc_t meshtastic_NodeStatusEntry_msg;
 extern const pb_msgdesc_t meshtastic_NodeDatabase_msg;
 extern const pb_msgdesc_t meshtastic_ChannelFile_msg;
 extern const pb_msgdesc_t meshtastic_BackupPreferences_msg;
@@ -354,6 +431,10 @@ extern const pb_msgdesc_t meshtastic_BackupPreferences_msg;
 #define meshtastic_UserLite_fields &meshtastic_UserLite_msg
 #define meshtastic_NodeInfoLite_fields &meshtastic_NodeInfoLite_msg
 #define meshtastic_DeviceState_fields &meshtastic_DeviceState_msg
+#define meshtastic_NodePositionEntry_fields &meshtastic_NodePositionEntry_msg
+#define meshtastic_NodeTelemetryEntry_fields &meshtastic_NodeTelemetryEntry_msg
+#define meshtastic_NodeEnvironmentEntry_fields &meshtastic_NodeEnvironmentEntry_msg
+#define meshtastic_NodeStatusEntry_fields &meshtastic_NodeStatusEntry_msg
 #define meshtastic_NodeDatabase_fields &meshtastic_NodeDatabase_msg
 #define meshtastic_ChannelFile_fields &meshtastic_ChannelFile_msg
 #define meshtastic_BackupPreferences_fields &meshtastic_BackupPreferences_msg
@@ -361,10 +442,14 @@ extern const pb_msgdesc_t meshtastic_BackupPreferences_msg;
 /* Maximum encoded size of messages (where known) */
 /* meshtastic_NodeDatabase_size depends on runtime parameters */
 #define MESHTASTIC_MESHTASTIC_DEVICEONLY_PB_H_MAX_SIZE meshtastic_BackupPreferences_size
-#define meshtastic_BackupPreferences_size        2429
+#define meshtastic_BackupPreferences_size        2432
 #define meshtastic_ChannelFile_size              718
 #define meshtastic_DeviceState_size              1737
-#define meshtastic_NodeInfoLite_size             196
+#define meshtastic_NodeEnvironmentEntry_size     170
+#define meshtastic_NodeInfoLite_size             105
+#define meshtastic_NodePositionEntry_size        36
+#define meshtastic_NodeStatusEntry_size          89
+#define meshtastic_NodeTelemetryEntry_size       35
 #define meshtastic_PositionLite_size             28
 #define meshtastic_UserLite_size                 98

@@ -0,0 +1,15 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9.1 */
+
+#include "meshtastic/deviceonly_legacy.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(meshtastic_NodeInfoLite_Legacy, meshtastic_NodeInfoLite_Legacy, AUTO)
+
+
+PB_BIND(meshtastic_NodeDatabase_Legacy, meshtastic_NodeDatabase_Legacy, AUTO)
+
+
+
@@ -0,0 +1,124 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9.1 */
+
+#ifndef PB_MESHTASTIC_MESHTASTIC_DEVICEONLY_LEGACY_PB_H_INCLUDED
+#define PB_MESHTASTIC_MESHTASTIC_DEVICEONLY_LEGACY_PB_H_INCLUDED
+#include <pb.h>
+#include <vector>
+#include "meshtastic/deviceonly.pb.h"
+#include "meshtastic/telemetry.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+/* Legacy NodeInfoLite descriptor used only to decode pre-split
+ /prefs/nodes.proto saves during the v24 -> v25 migration boot.
+ This preserves the original NodeInfoLite-compatible field numbers needed
+ to parse old wire bytes cleanly, including user (2), position (3),
+ device_metrics (6), and the legacy-only compatibility fields via_mqtt (8),
+ is_favorite (10), and is_ignored (11). Steady-state code does not use
+ this struct; it is dropped after migration completes. This file should be
+ removed once DEVICESTATE_MIN_VER advances past 24. */
+typedef struct _meshtastic_NodeInfoLite_Legacy {
+    uint32_t num;
+    bool has_user;
+    meshtastic_UserLite user;
+    bool has_position;
+    meshtastic_PositionLite position;
+    float snr;
+    uint32_t last_heard;
+    bool has_device_metrics;
+    meshtastic_DeviceMetrics device_metrics;
+    uint8_t channel;
+    bool via_mqtt;
+    bool has_hops_away;
+    uint8_t hops_away;
+    bool is_favorite;
+    bool is_ignored;
+    uint8_t next_hop;
+    uint32_t bitfield;
+} meshtastic_NodeInfoLite_Legacy;
+
+/* Legacy NodeDatabase shape: one repeated array of fat NodeInfoLite_Legacy
+ with no satellite position/telemetry arrays. */
+typedef struct _meshtastic_NodeDatabase_Legacy {
+    uint32_t version;
+    std::vector<meshtastic_NodeInfoLite_Legacy> nodes;
+} meshtastic_NodeDatabase_Legacy;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define meshtastic_NodeInfoLite_Legacy_init_default {0, false, meshtastic_UserLite_init_default, false, meshtastic_PositionLite_init_default, 0, 0, false, meshtastic_DeviceMetrics_init_default, 0, 0, false, 0, 0, 0, 0, 0}
+#define meshtastic_NodeDatabase_Legacy_init_default {0, {0}}
+#define meshtastic_NodeInfoLite_Legacy_init_zero {0, false, meshtastic_UserLite_init_zero, false, meshtastic_PositionLite_init_zero, 0, 0, false, meshtastic_DeviceMetrics_init_zero, 0, 0, false, 0, 0, 0, 0, 0}
+#define meshtastic_NodeDatabase_Legacy_init_zero {0, {0}}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define meshtastic_NodeInfoLite_Legacy_num_tag   1
+#define meshtastic_NodeInfoLite_Legacy_user_tag  2
+#define meshtastic_NodeInfoLite_Legacy_position_tag 3
+#define meshtastic_NodeInfoLite_Legacy_snr_tag   4
+#define meshtastic_NodeInfoLite_Legacy_last_heard_tag 5
+#define meshtastic_NodeInfoLite_Legacy_device_metrics_tag 6
+#define meshtastic_NodeInfoLite_Legacy_channel_tag 7
+#define meshtastic_NodeInfoLite_Legacy_via_mqtt_tag 8
+#define meshtastic_NodeInfoLite_Legacy_hops_away_tag 9
+#define meshtastic_NodeInfoLite_Legacy_is_favorite_tag 10
+#define meshtastic_NodeInfoLite_Legacy_is_ignored_tag 11
+#define meshtastic_NodeInfoLite_Legacy_next_hop_tag 12
+#define meshtastic_NodeInfoLite_Legacy_bitfield_tag 13
+#define meshtastic_NodeDatabase_Legacy_version_tag 1
+#define meshtastic_NodeDatabase_Legacy_nodes_tag 2
+
+/* Struct field encoding specification for nanopb */
+#define meshtastic_NodeInfoLite_Legacy_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   num,               1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  user,              2) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  position,          3) \
+X(a, STATIC,   SINGULAR, FLOAT,    snr,               4) \
+X(a, STATIC,   SINGULAR, FIXED32,  last_heard,        5) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  device_metrics,    6) \
+X(a, STATIC,   SINGULAR, UINT32,   channel,           7) \
+X(a, STATIC,   SINGULAR, BOOL,     via_mqtt,          8) \
+X(a, STATIC,   OPTIONAL, UINT32,   hops_away,         9) \
+X(a, STATIC,   SINGULAR, BOOL,     is_favorite,      10) \
+X(a, STATIC,   SINGULAR, BOOL,     is_ignored,       11) \
+X(a, STATIC,   SINGULAR, UINT32,   next_hop,         12) \
+X(a, STATIC,   SINGULAR, UINT32,   bitfield,         13)
+#define meshtastic_NodeInfoLite_Legacy_CALLBACK NULL
+#define meshtastic_NodeInfoLite_Legacy_DEFAULT NULL
+#define meshtastic_NodeInfoLite_Legacy_user_MSGTYPE meshtastic_UserLite
+#define meshtastic_NodeInfoLite_Legacy_position_MSGTYPE meshtastic_PositionLite
+#define meshtastic_NodeInfoLite_Legacy_device_metrics_MSGTYPE meshtastic_DeviceMetrics
+
+#define meshtastic_NodeDatabase_Legacy_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   version,           1) \
+X(a, CALLBACK, REPEATED, MESSAGE,  nodes,             2)
+extern bool meshtastic_NodeDatabase_Legacy_callback(pb_istream_t *istream, pb_ostream_t *ostream, const pb_field_t *field);
+#define meshtastic_NodeDatabase_Legacy_CALLBACK meshtastic_NodeDatabase_Legacy_callback
+#define meshtastic_NodeDatabase_Legacy_DEFAULT NULL
+#define meshtastic_NodeDatabase_Legacy_nodes_MSGTYPE meshtastic_NodeInfoLite_Legacy
+
+extern const pb_msgdesc_t meshtastic_NodeInfoLite_Legacy_msg;
+extern const pb_msgdesc_t meshtastic_NodeDatabase_Legacy_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define meshtastic_NodeInfoLite_Legacy_fields &meshtastic_NodeInfoLite_Legacy_msg
+#define meshtastic_NodeDatabase_Legacy_fields &meshtastic_NodeDatabase_Legacy_msg
+
+/* Maximum encoded size of messages (where known) */
+/* meshtastic_NodeDatabase_Legacy_size depends on runtime parameters */
+#define MESHTASTIC_MESHTASTIC_DEVICEONLY_LEGACY_PB_H_MAX_SIZE meshtastic_NodeInfoLite_Legacy_size
+#define meshtastic_NodeInfoLite_Legacy_size      196
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif
@@ -205,7 +205,7 @@ extern const pb_msgdesc_t meshtastic_LocalModuleConfig_msg;

 /* Maximum encoded size of messages (where known) */
 #define MESHTASTIC_MESHTASTIC_LOCALONLY_PB_H_MAX_SIZE meshtastic_LocalModuleConfig_size
-#define meshtastic_LocalConfig_size              754
+#define meshtastic_LocalConfig_size              757
 #define meshtastic_LocalModuleConfig_size        820

 #ifdef __cplusplus
@@ -0,0 +1,19 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9.1 */
+
+#include "meshtastic/serial_hal.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(meshtastic_SerialHalCommand, meshtastic_SerialHalCommand, 2)
+
+
+PB_BIND(meshtastic_SerialHalResponse, meshtastic_SerialHalResponse, 2)
+
+
+
+
+
+
+
@@ -0,0 +1,135 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9.1 */
+
+#ifndef PB_MESHTASTIC_MESHTASTIC_SERIAL_HAL_PB_H_INCLUDED
+#define PB_MESHTASTIC_MESHTASTIC_SERIAL_HAL_PB_H_INCLUDED
+#include <pb.h>
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Enum definitions */
+typedef enum _meshtastic_SerialHalCommand_Type {
+    meshtastic_SerialHalCommand_Type_UNSET = 0,
+    meshtastic_SerialHalCommand_Type_PIN_MODE = 1,
+    meshtastic_SerialHalCommand_Type_DIGITAL_WRITE = 2,
+    meshtastic_SerialHalCommand_Type_DIGITAL_READ = 3,
+    meshtastic_SerialHalCommand_Type_ATTACH_INTERRUPT = 4,
+    meshtastic_SerialHalCommand_Type_DETACH_INTERRUPT = 5,
+    meshtastic_SerialHalCommand_Type_SPI_TRANSFER = 6,
+    meshtastic_SerialHalCommand_Type_NOOP = 7
+} meshtastic_SerialHalCommand_Type;
+
+typedef enum _meshtastic_SerialHalResponse_Result {
+    meshtastic_SerialHalResponse_Result_OK = 0,
+    meshtastic_SerialHalResponse_Result_ERROR = 1,
+    meshtastic_SerialHalResponse_Result_BAD_REQUEST = 2,
+    meshtastic_SerialHalResponse_Result_UNSUPPORTED = 3
+} meshtastic_SerialHalResponse_Result;
+
+/* Struct definitions */
+typedef PB_BYTES_ARRAY_T(512) meshtastic_SerialHalCommand_data_t;
+typedef struct _meshtastic_SerialHalCommand {
+    /* Host-assigned request id. Replies echo this id back in
+ SerialHalResponse.transaction_id. */
+    uint32_t transaction_id;
+    meshtastic_SerialHalCommand_Type type;
+    uint32_t pin;
+    uint32_t value;
+    uint32_t mode;
+    meshtastic_SerialHalCommand_data_t data;
+} meshtastic_SerialHalCommand;
+
+typedef PB_BYTES_ARRAY_T(512) meshtastic_SerialHalResponse_data_t;
+typedef struct _meshtastic_SerialHalResponse {
+    /* Matches the originating SerialHalCommand.transaction_id for normal
+ request/response traffic.
+
+ A value of 0 indicates an unsolicited interrupt notification generated by
+ the device. In that case, the host should interpret value as the GPIO pin
+ that triggered. */
+    uint32_t transaction_id;
+    meshtastic_SerialHalResponse_Result result;
+    /* Used by DIGITAL_READ replies and interrupt notifications. For interrupt
+ notifications (transaction_id == 0), this carries the pin number. */
+    uint32_t value;
+    meshtastic_SerialHalResponse_data_t data;
+    char error[80];
+} meshtastic_SerialHalResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Helper constants for enums */
+#define _meshtastic_SerialHalCommand_Type_MIN meshtastic_SerialHalCommand_Type_UNSET
+#define _meshtastic_SerialHalCommand_Type_MAX meshtastic_SerialHalCommand_Type_NOOP
+#define _meshtastic_SerialHalCommand_Type_ARRAYSIZE ((meshtastic_SerialHalCommand_Type)(meshtastic_SerialHalCommand_Type_NOOP+1))
+
+#define _meshtastic_SerialHalResponse_Result_MIN meshtastic_SerialHalResponse_Result_OK
+#define _meshtastic_SerialHalResponse_Result_MAX meshtastic_SerialHalResponse_Result_UNSUPPORTED
+#define _meshtastic_SerialHalResponse_Result_ARRAYSIZE ((meshtastic_SerialHalResponse_Result)(meshtastic_SerialHalResponse_Result_UNSUPPORTED+1))
+
+#define meshtastic_SerialHalCommand_type_ENUMTYPE meshtastic_SerialHalCommand_Type
+
+#define meshtastic_SerialHalResponse_result_ENUMTYPE meshtastic_SerialHalResponse_Result
+
+
+/* Initializer values for message structs */
+#define meshtastic_SerialHalCommand_init_default {0, _meshtastic_SerialHalCommand_Type_MIN, 0, 0, 0, {0, {0}}}
+#define meshtastic_SerialHalResponse_init_default {0, _meshtastic_SerialHalResponse_Result_MIN, 0, {0, {0}}, ""}
+#define meshtastic_SerialHalCommand_init_zero    {0, _meshtastic_SerialHalCommand_Type_MIN, 0, 0, 0, {0, {0}}}
+#define meshtastic_SerialHalResponse_init_zero   {0, _meshtastic_SerialHalResponse_Result_MIN, 0, {0, {0}}, ""}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define meshtastic_SerialHalCommand_transaction_id_tag 1
+#define meshtastic_SerialHalCommand_type_tag     2
+#define meshtastic_SerialHalCommand_pin_tag      3
+#define meshtastic_SerialHalCommand_value_tag    4
+#define meshtastic_SerialHalCommand_mode_tag     5
+#define meshtastic_SerialHalCommand_data_tag     6
+#define meshtastic_SerialHalResponse_transaction_id_tag 1
+#define meshtastic_SerialHalResponse_result_tag  2
+#define meshtastic_SerialHalResponse_value_tag   3
+#define meshtastic_SerialHalResponse_data_tag    4
+#define meshtastic_SerialHalResponse_error_tag   5
+
+/* Struct field encoding specification for nanopb */
+#define meshtastic_SerialHalCommand_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   transaction_id,    1) \
+X(a, STATIC,   SINGULAR, UENUM,    type,              2) \
+X(a, STATIC,   SINGULAR, UINT32,   pin,               3) \
+X(a, STATIC,   SINGULAR, UINT32,   value,             4) \
+X(a, STATIC,   SINGULAR, UINT32,   mode,              5) \
+X(a, STATIC,   SINGULAR, BYTES,    data,              6)
+#define meshtastic_SerialHalCommand_CALLBACK NULL
+#define meshtastic_SerialHalCommand_DEFAULT NULL
+
+#define meshtastic_SerialHalResponse_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   transaction_id,    1) \
+X(a, STATIC,   SINGULAR, UENUM,    result,            2) \
+X(a, STATIC,   SINGULAR, UINT32,   value,             3) \
+X(a, STATIC,   SINGULAR, BYTES,    data,              4) \
+X(a, STATIC,   SINGULAR, STRING,   error,             5)
+#define meshtastic_SerialHalResponse_CALLBACK NULL
+#define meshtastic_SerialHalResponse_DEFAULT NULL
+
+extern const pb_msgdesc_t meshtastic_SerialHalCommand_msg;
+extern const pb_msgdesc_t meshtastic_SerialHalResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define meshtastic_SerialHalCommand_fields &meshtastic_SerialHalCommand_msg
+#define meshtastic_SerialHalResponse_fields &meshtastic_SerialHalResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+#define MESHTASTIC_MESHTASTIC_SERIAL_HAL_PB_H_MAX_SIZE meshtastic_SerialHalResponse_size
+#define meshtastic_SerialHalCommand_size         541
+#define meshtastic_SerialHalResponse_size        610
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif
@@ -729,7 +729,7 @@ void handleNodes(HTTPRequest *req, HTTPResponse *res)
    uint32_t readIndex = 0;
    const meshtastic_NodeInfoLite *tempNodeInfo = nodeDB->readNextMeshNode(readIndex);
    while (tempNodeInfo != NULL) {
-        if (tempNodeInfo->has_user) {
+        if (nodeInfoLiteHasUser(tempNodeInfo)) {
            JSONObject node;

            char id[16];
@@ -737,26 +737,26 @@ void handleNodes(HTTPRequest *req, HTTPResponse *res)

            node["id"] = new JSONValue(id);
            node["snr"] = new JSONValue(tempNodeInfo->snr);
-            node["via_mqtt"] = new JSONValue(BoolToString(tempNodeInfo->via_mqtt));
+            node["via_mqtt"] = new JSONValue(BoolToString(nodeInfoLiteViaMqtt(tempNodeInfo)));
            node["last_heard"] = new JSONValue((int)tempNodeInfo->last_heard);
            node["position"] = new JSONValue();

            if (nodeDB->hasValidPosition(tempNodeInfo)) {
-                JSONObject position;
-                position["latitude"] = new JSONValue((float)tempNodeInfo->position.latitude_i * 1e-7);
-                position["longitude"] = new JSONValue((float)tempNodeInfo->position.longitude_i * 1e-7);
-                position["altitude"] = new JSONValue((int)tempNodeInfo->position.altitude);
-                node["position"] = new JSONValue(position);
+                meshtastic_PositionLite posLite;
+                if (nodeDB->copyNodePosition(tempNodeInfo->num, posLite)) {
+                    JSONObject position;
+                    position["latitude"] = new JSONValue((float)posLite.latitude_i * 1e-7);
+                    position["longitude"] = new JSONValue((float)posLite.longitude_i * 1e-7);
+                    position["altitude"] = new JSONValue((int)posLite.altitude);
+                    node["position"] = new JSONValue(position);
+                }
            }

-            node["long_name"] = new JSONValue(tempNodeInfo->user.long_name);
-            node["short_name"] = new JSONValue(tempNodeInfo->user.short_name);
-            char macStr[18];
-            snprintf(macStr, sizeof(macStr), "%02X:%02X:%02X:%02X:%02X:%02X", tempNodeInfo->user.macaddr[0],
-                     tempNodeInfo->user.macaddr[1], tempNodeInfo->user.macaddr[2], tempNodeInfo->user.macaddr[3],
-                     tempNodeInfo->user.macaddr[4], tempNodeInfo->user.macaddr[5]);
-            node["mac_address"] = new JSONValue(macStr);
-            node["hw_model"] = new JSONValue(tempNodeInfo->user.hw_model);
+            node["long_name"] = new JSONValue(tempNodeInfo->long_name);
+            node["short_name"] = new JSONValue(tempNodeInfo->short_name);
+            // mac_address dropped from NodeInfoLite as part of the slim refactor; emit zeros.
+            node["mac_address"] = new JSONValue("00:00:00:00:00:00");
+            node["hw_model"] = new JSONValue(tempNodeInfo->hw_model);

            nodesArray.push_back(new JSONValue(node));
        }
@@ -930,4 +930,4 @@ void handleScanNetworks(HTTPRequest *req, HTTPResponse *res)
    res->print(jsonString.c_str());
    delete value;
 }
-#endif
+#endif
@@ -37,9 +37,43 @@
 #define MAX_RX_NOTIFICATION_TOPHONE 2
 #endif

-/// Verify baseline assumption of node size. If it increases, we need to reevaluate
-/// the impact of its memory footprint, notably on MAX_NUM_NODES.
-static_assert(sizeof(meshtastic_NodeInfoLite) <= 200, "NodeInfoLite size increased. Reconsider impact on MAX_NUM_NODES.");
+/// Tighten this when the slim header shrinks; loosen only with deliberate
+/// awareness of MAX_NUM_NODES impact per platform.
+static_assert(sizeof(meshtastic_NodeInfoLite) <= 130, "NodeInfoLite size increased. Reconsider impact on MAX_NUM_NODES.");
+
+// Compile satellite NodeDBs out on STM32WL (and the status DB also follows
+// MESHTASTIC_EXCLUDE_STATUS).
+#ifndef MESHTASTIC_EXCLUDE_POSITIONDB
+#if defined(ARCH_STM32WL)
+#define MESHTASTIC_EXCLUDE_POSITIONDB 1
+#else
+#define MESHTASTIC_EXCLUDE_POSITIONDB 0
+#endif
+#endif
+
+#ifndef MESHTASTIC_EXCLUDE_TELEMETRYDB
+#if defined(ARCH_STM32WL)
+#define MESHTASTIC_EXCLUDE_TELEMETRYDB 1
+#else
+#define MESHTASTIC_EXCLUDE_TELEMETRYDB 0
+#endif
+#endif
+
+#ifndef MESHTASTIC_EXCLUDE_ENVIRONMENTDB
+#if defined(ARCH_STM32WL)
+#define MESHTASTIC_EXCLUDE_ENVIRONMENTDB 1
+#else
+#define MESHTASTIC_EXCLUDE_ENVIRONMENTDB 0
+#endif
+#endif
+
+#ifndef MESHTASTIC_EXCLUDE_STATUSDB
+#if defined(ARCH_STM32WL) || defined(MESHTASTIC_EXCLUDE_STATUS)
+#define MESHTASTIC_EXCLUDE_STATUSDB 1
+#else
+#define MESHTASTIC_EXCLUDE_STATUSDB 0
+#endif
+#endif

 /// max number of nodes allowed in the nodeDB
 #ifndef MAX_NUM_NODES
--- a/Show More
+++ b/Show More