Refactor test messages for clarity and consistency in regex tests

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

.github/ISSUE_TEMPLATE/Bug Report.yml

@@ -75,11 +75,11 @@ body:
   - type: checkboxes
     id: mui
     attributes:
-      label: Is this bug report about any UI (https://meshtastic.org/docs/configuration/device-uis/) component firmware?
+      label: Is this bug report about any UI component firmware like InkHUD or Meshtatic UI (MUI)?
       options:
-        - label: Meshtastic UI aka MUI
-        - label: InkHUD
-        - label: BaseUI
+        - label: Meshtastic UI aka MUI colorTFT
+        - label: InkHUD ePaper
+        - label: OLED slide UI on any display
 
   - type: input
     id: version

.github/copilot-instructions.md

@@ -13,7 +13,6 @@ 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
 
@@ -71,70 +70,6 @@ PKI (Public Key Infrastructure) messages have special handling:
 - Accepted on a special "PKI" channel
 - Allow encrypted DMs between nodes that discovered each other on downlink-enabled channels
 
-## Encryption & Key Management
-
-Meshtastic packets on the air are typically encrypted one of two ways: the **per-channel symmetric** layer (AES-CTR with a shared PSK) for broadcasts and channel traffic, and the **per-peer PKI** layer (X25519 ECDH → AES-256-CCM) for direct messages and remote admin. A channel with a 0-byte PSK (or Ham mode, which wipes PSKs) transmits cleartext — see the size table below. Both are implemented in `src/mesh/CryptoEngine.cpp`; the send/receive dispatch lives in `src/mesh/Router.cpp`; admin authorization lives in `src/modules/AdminModule.cpp`.
-
-### High-level model
-
-- **Channels** are symmetric rooms: anyone with the PSK can read any message on the channel. Channel 0 is the "primary" channel and ships with the short-form default PSK on factory devices, forming the public mesh most users join. (The LoRa modem preset `LONG_FAST` lives on `config.lora.modem_preset` and is an independent field — don't conflate "channel 0 default PSK" with the modem preset name.)
-- **DMs** addressed to a single node require PKI so that other holders of the channel PSK can't read them. Outside Ham mode, Meshtastic does not fall back to channel-symmetric encryption when the destination public key is unknown.
-- **Remote admin** is a DM carrying an `AdminMessage`. The receiver only acts on it if the sender's public key is on its allowlist (`config.security.admin_key[0..2]`).
-- **Ham mode** (`owner.is_licensed=true`, where `owner` is the local `meshtastic_User` record) disables PKI entirely and sends cleartext — FCC Part 97 prohibits encryption on amateur bands.
-- **No ratchet, no session.** Every packet is encrypted from scratch — a stateless design that matches the high-loss, store-and-forward nature of LoRa.
-
-### Symmetric channel encryption (AES-CTR)
-
-`CryptoEngine::encryptPacket` / `decrypt` / `encryptAESCtr` in `src/mesh/CryptoEngine.cpp`.
-
-- **Cipher**: AES-CTR, AES-128 or AES-256 depending on key length. Same routine in both directions (CTR is a stream cipher, so encrypt == decrypt).
-- **Key**: `ChannelSettings.psk` bytes. Size semantics:
-  - **0 bytes** → no encryption, cleartext on the air
-  - **1 byte** → short-form index into the well-known `defaultpsk[]` in `src/mesh/Channels.h`. Index 0 = cleartext; 1 = defaultpsk unchanged; 2..255 = defaultpsk with its last byte incremented by (index − 1). This is what the CLI's `--ch-set psk default` produces.
-  - **16 bytes** → raw AES-128 key
-  - **32 bytes** → raw AES-256 key
-  - **2..15 bytes** → zero-padded to 16 and used as AES-128 (with a warn log); **17..31 bytes** → zero-padded to 32 and used as AES-256 (with a warn log). Defensive fallback for malformed PSK input, not something to rely on.
-- **Nonce (128 bit)**: `packet_id` (u64 LE) ‖ `from_node` (u32 LE) ‖ `block_counter` (u32, starts at 0). Built in `CryptoEngine::initNonce`.
-- **No AEAD**: channel packets carry no MAC, so the channel-hash byte is not an integrity or authenticity check. `Channels::getHash` is a 1-byte XOR-derived hint over the channel name bytes and PSK bytes that helps receivers pick a candidate channel/PSK for decryption. Because it is only a small hint and collisions are easy to find, it should be described purely as a PSK-selection aid, not as a security filter an attacker cannot bypass.
-- **Channel 0 is special in one way only**: it's the channel the Router attempts PKI decryption on before falling through to AES-CTR. Non-zero channels always go straight to AES-CTR.
-
-### PKI encryption for DMs (X25519 ECDH + AES-256-CCM)
-
-`CryptoEngine::encryptCurve25519` / `decryptCurve25519` in `src/mesh/CryptoEngine.cpp`.
-
-- **Keypair**: Curve25519 (aka X25519), 32-byte public + 32-byte private. Stored in `config.security.public_key` / `private_key`; the public half is mirrored into `owner.public_key` so it rides along in NodeInfo broadcasts and propagates through the mesh like any other identity field.
-- **Key generation** (`generateKeyPair`): stirs `HardwareRNG::fill()` (64 B from platform TRNG when available), the 16-byte `myNodeInfo.device_id`, and a call to `random()` into the rweather/Crypto library's software RNG, then `Curve25519::dh1`. `regeneratePublicKey` recomputes the public half from a known private (used when restoring from backup).
-- **Keygen entry points**: at boot, `NodeDB` calls `generateKeyPair` (or `regeneratePublicKey` when a stored private key is present and passes a low-entropy check) **directly** when `!owner.is_licensed` and `config.lora.region != UNSET`. `ensurePkiKeys` wraps the same logic for runtime/admin flows — it's the path `AdminModule::handleSetConfig` runs when first assigning a valid region or when security config is written; **do not assume it's the universal boot-time gate**, because the NodeDB path bypasses it.
-- **Handshake**: `Curve25519::dh2(local_private, remote_public) → 32-byte shared secret → SHA-256 → 32-byte AES-256 key`. Recomputed per packet. The SHA-256 step is effectively a KDF over the raw ECDH output.
-- **Cipher**: AES-256-CCM via `aes_ccm_ae` / `aes_ccm_ad` (`src/mesh/aes-ccm.cpp`). MAC length (the `M` parameter) is **8 bytes**. No AAD — the MAC covers ciphertext only.
-- **Nonce (13 bytes / 104 bit)**: `aes_ccm_ae`/`aes_ccm_ad` use a 13-byte CCM nonce (`L = 2` is hardcoded in `src/mesh/aes-ccm.cpp`), not a 16-byte nonce. For PKI packets, `CryptoEngine::initNonce(fromNode, packetNum, extraNonce)` starts from the usual packet-derived nonce material, then overwrites nonce bytes `4..7` with a fresh 32-bit `extraNonce = random()`. The effective nonce bytes are therefore: bytes `0..3` = `packet_id`, bytes `4..7` = transmitted `extraNonce`, bytes `8..11` = `from_node`, byte `12` = `0x00`. The receiver reconstructs the same 13-byte nonce from the packet metadata plus the appended `extraNonce`.
-- **Wire overhead**: 12 bytes appended to the ciphertext = 8-byte MAC ‖ 4-byte extraNonce. Defined as `MESHTASTIC_PKC_OVERHEAD = 12` in `src/mesh/RadioInterface.h`. Only the 4-byte `extraNonce` is sent; the rest of the 13-byte CCM nonce is reconstructed from packet fields as described above. The Router's send path checks this overhead against `MAX_LORA_PAYLOAD_LEN` before committing to PKI.
-- **Send selection** (`Router::send`): the sender enters the PKI path when **all** hold — we're the originator AND not Ham mode AND not Portduino simradio AND not on the `serial`/`gpio` channels (unless the packet is already marked `pki_encrypted`) AND `config.security.private_key.size == 32` AND destination is a single node (not broadcast) AND the portnum isn't infrastructure. `TRACEROUTE_APP`, `NODEINFO_APP`, `ROUTING_APP`, and `POSITION_APP` are routed through channel encryption even when DMed (these need to be readable by relaying peers). Once on the PKI path, if the destination's public key isn't in our NodeDB the send **fails** with `PKI_SEND_FAIL_PUBLIC_KEY` — it does not silently fall back to channel encryption. If the client explicitly set `pki_encrypted=true` and any condition blocks PKI, the send fails with `PKI_FAILED`.
-- **Receive selection** (`Router::perhapsDecode`): try PKI decrypt first when `channel == 0` AND `isToUs(p)` AND not broadcast AND both peers have public keys in NodeDB AND `rawSize > MESHTASTIC_PKC_OVERHEAD`. On success the packet gets `pki_encrypted=true` stamped and the sender's public key copied into `p->public_key` for downstream authorization.
-
-### Remote admin authorization
-
-Implemented in `src/modules/AdminModule.cpp` → `handleReceivedProtobuf`. The authorization check runs in this order:
-
-1. **Response messages** — if `messageIsResponse(r)` is true (the payload is a response to one of our earlier admin requests), it's accepted without any further check. The in-file comment flags this as a known-untightened gap: a stricter implementation would remember which `public_key` we last queried and reject responses that don't match.
-2. **Local admin** — `mp.from == 0` (phone app over BLE, serial CLI, internal module); never travels over the air. **Rejected** if `config.security.is_managed` is true, because managed devices expect admin to arrive over the air through an authorized remote path.
-3. **Legacy admin channel (deprecated)** — the packet arrived on a channel named literally `"admin"`. Gated by `config.security.admin_channel_enabled`; returns `NOT_AUTHORIZED` if the flag is false. Kept for backward compatibility; new deployments should use PKI admin.
-4. **PKI admin (preferred for remote)** — `mp.pki_encrypted == true` AND `mp.public_key` matches one of `config.security.admin_key[0..2]` (up to three authorized 32-byte Curve25519 public keys, typically copied from the admin node's own `user.public_key`).
-5. **Fallthrough** → `NOT_AUTHORIZED`.
-
-On top of authorization, any remote admin message that **mutates** state (not a request, not a response) also has to pass a session-key check (`checkPassKey`): the client must first pull a fresh 8-byte `session_passkey` via `get_admin_session_key_request`, then echo that passkey back in the mutating message. The device rotates the passkey after 150 s and rejects values older than 300 s — a narrow anti-replay window on top of the PKI layer.
-
-`config.security.is_managed = true` disables **local** admin writes (`mp.from == 0` is rejected). It does not by itself force every admin action through PKI — the legacy `"admin"` channel still authorizes remote admin when `config.security.admin_channel_enabled == true`. The AdminModule refuses to persist `is_managed=true` unless at least one `admin_key` is populated — a deliberate guard against operators locking themselves out.
-
-### Key-rotation hazards (actions that invalidate peers)
-
-- **`factory_reset_device`** (the "full" variant, calls `NodeDB::factoryReset(eraseBleBonds=true)`) → **wipes** the X25519 private key; a fresh keypair is generated on the next region-set. Every existing peer holds the old public key, so DMs to this node silently fail PKI decrypt until every peer re-exchanges NodeInfo.
-- **`factory_reset_config`** (the "partial" variant, calls `NodeDB::factoryReset()` with `eraseBleBonds=false`) → **preserves** the X25519 private key in `installDefaultConfig(preserveKey=true)`; the public key is zeroed and gets rebuilt from the preserved private key on the next boot via the NodeDB path's `regeneratePublicKey` call. Identity is preserved and the mesh does not need to re-exchange keys.
-- **`region=UNSET → valid region`** → `ensurePkiKeys` runs inside the same `handleSetConfig` path; missing keys get generated at that moment.
-- **Ham mode transitions** — entering Ham mode (`user.is_licensed=true`) runs `Channels::ensureLicensedOperation`, which **wipes every channel PSK** (all traffic becomes cleartext) and disables the legacy admin channel. The X25519 private key is preserved on the device but not used because `Router::send` skips PKI when `owner.is_licensed` is true. Leaving Ham mode re-enables PKI with the preserved keypair but does not restore the wiped channel PSKs — the operator has to re-set them.
-- **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.
-
 ## Project Structure
 
 ```
@@ -145,7 +80,7 @@ firmware/
 │   │   ├── NodeDB.*       # Node database management
 │   │   ├── Router.*       # Packet routing
 │   │   ├── Channels.*     # Channel management
-│   │   ├── CryptoEngine.* # AES-CTR (channels) + X25519 ECDH→AES-256-CCM (PKI for DMs/admin)
+│   │   ├── CryptoEngine.* # AES-CCM encryption
 │   │   ├── *Interface.*   # Radio interface implementations
 │   │   ├── api/           # WiFi/Ethernet server APIs (ServerAPI, PacketAPI)
 │   │   ├── http/          # HTTP server (WebServer, ContentHandler)
@@ -361,23 +296,6 @@ Key defines in variant.h:
 
 ## Build System
 
-## Agent Tooling Baseline
-
-Mirror counterpart: `AGENTS.md` under **Agent Tooling Baseline**.
-
-To reduce avoidable agent mistakes, assume these tools are available (or install them before significant repo work):
-
-- **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` (fallback for non-Linux hosts; macOS can also build natively via `pio run -e native-macos`)
-
-Fallback expectations for agents:
-
-- If `rg` is unavailable, use `find` + `grep` instead of failing.
-- For native tests on hosts without Linux deps, prefer `./bin/test-native-docker.sh`.
-- The simulator helper script is `./bin/test-simulator.sh`.
-
 Uses **PlatformIO** with custom scripts:
 
 - `bin/platformio-pre.py` - Pre-build script
@@ -389,7 +307,6 @@ 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
@@ -531,8 +448,6 @@ Run with: `pio test -e native`
 
 Simulation testing: `bin/test-simulator.sh`
 
-Quick entry point for new test modules: `test/README.md` (native unit-test authoring guide, skeleton, pitfalls, and setup checklist).
-
 ### Hardware-in-the-loop tests (`mcp-server/tests/`)
 
 Separate pytest suite that exercises real USB-connected Meshtastic devices. See the **MCP Server & Hardware Test Harness** section below for invocation, tier layout, and agent usage rules.
@@ -575,8 +490,6 @@ 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.

.github/prompts/new-module.prompt.md

@@ -118,7 +118,7 @@ CallbackObserver<MyModule, const meshtastic::Status *> statusObserver =
 
 Add test suite in `test/test_mymodule/`:
 
-```text
+```
 test/
 └── test_mymodule/
     └── test_main.cpp

.github/prompts/new-variant.prompt.md

@@ -6,7 +6,7 @@ Guide for adding a new Meshtastic hardware variant to the firmware.
 
 Create under `variants/<arch>/<name>/`:
 
-```text
+```
 variants/
 ├── esp32/          # ESP32
 ├── esp32s3/        # ESP32-S3

.github/workflows/build_macos_bin.yml

@@ -1,51 +0,0 @@
-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
-
-      - 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

.github/workflows/docker_build.yml

@@ -73,9 +73,7 @@ jobs:
       - name: Sanitize platform string
         id: sanitize_platform
         # Replace slashes with underscores
-        env:
-          plat: ${{ inputs.platform }}
-        run: echo "cleaned_platform=${plat}" | sed 's/\//_/g' >> $GITHUB_OUTPUT
+        run: echo "cleaned_platform=${{ inputs.platform }}" | sed 's/\//_/g' >> $GITHUB_OUTPUT
 
       - name: Docker login
         if: ${{ inputs.push }}

.github/workflows/docker_manifest.yml

@@ -43,15 +43,6 @@ 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:
@@ -79,27 +70,16 @@ 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
@@ -182,7 +162,6 @@ 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
@@ -203,4 +182,3 @@ 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 }}

.github/workflows/main_matrix.yml

@@ -116,20 +116,6 @@ 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
@@ -300,7 +286,6 @@ jobs:
       - gather-artifacts
       - build-debian-src
       - package-pio-deps-native-tft
-      # - MacOS
     steps:
       - name: Checkout
         uses: actions/checkout@v6

.trunk/trunk.yaml

@@ -4,22 +4,22 @@ cli:
 plugins:
   sources:
     - id: trunk
-      ref: v1.8.0
+      ref: v1.7.6
       uri: https://github.com/trunk-io/plugins
 lint:
   enabled:
-    - checkov@3.2.525
-    - renovate@43.150.0
-    - prettier@3.8.3
-    - trufflehog@3.95.2
+    - checkov@3.2.517
+    - renovate@43.110.9
+    - prettier@3.8.1
+    - trufflehog@3.94.3
     - yamllint@1.38.0
     - bandit@1.9.4
-    - trivy@0.70.0
+    - trivy@0.69.3
     - taplo@0.10.0
-    - ruff@0.15.12
+    - ruff@0.15.9
     - isort@8.0.1
     - markdownlint@0.48.0
-    - oxipng@10.1.1
+    - oxipng@10.1.0
     - svgo@4.0.1
     - actionlint@1.7.12
     - flake8@7.3.0
@@ -36,7 +36,7 @@ lint:
         - bin/**
 runtimes:
   enabled:
-    - python@3.14.4
+    - python@3.10.8
     - go@1.21.0
     - node@22.16.0
 actions:

AGENTS.md

@@ -10,18 +10,17 @@ 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`)                                        |
-| 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]`                                                                |
+| 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]`                                      |
 
 ## MCP server (device + test automation)
 
@@ -49,15 +48,6 @@ Three test-and-diagnose workflows exist as slash commands:
 
 Bodies live in `.claude/commands/` and `.github/prompts/` respectively. `.claude/commands/README.md` is the index.
 
-## Encryption at a glance
-
-Two layers, both in `src/mesh/CryptoEngine.cpp`:
-
-- **Channel (symmetric)** — **AES-CTR** with a channel-wide PSK (AES-128 or AES-256). Nonce = packet_id ‖ from_node ‖ block_counter. No AEAD; integrity is soft (channel-hash filter). The well-known default PSK lives in `src/mesh/Channels.h`; a 1-byte PSK is a short-form index into it.
-- **Per-peer PKI** — **X25519 ECDH** (Curve25519, 32-byte keys) → SHA-256 → **AES-256-CCM** with an 8-byte MAC. Fresh 32-bit `extraNonce` per packet, sent in the clear alongside the MAC. 12-byte wire overhead (`MESHTASTIC_PKC_OVERHEAD`). Used for DMs. Also used for remote admin (`src/modules/AdminModule.cpp`), where AdminMessage authorization is gated by `config.security.admin_key[0..2]`. Disabled entirely in Ham mode (`user.is_licensed=true`).
-
-Key rotation to never trigger casually: only the **full** factory reset (`factory_reset_device`, `eraseBleBonds=true`) wipes `security.private_key` and regenerates the keypair — every peer holds the old public key, so DMs silently fail PKI decrypt until NodeInfo re-exchanges. The **partial** config reset (`factory_reset_config`) preserves the private key and doesn't invalidate peer relationships. Explicitly blanking `security.private_key` via admin also triggers regen. See the **Encryption & Key Management** section of `.github/copilot-instructions.md` for the full spec (nonce layout, send/receive selection logic including infrastructure-portnum exceptions, admin-key + session-passkey authorization, `is_managed` scope, key-rotation hazards).
-
 ## House rules
 
 - **No destructive device operations without operator approval.** `factory_reset`, `erase_and_flash`, `reboot`, `shutdown`, history-rewriting git ops — describe the action and stop. Operator authorizes.
@@ -122,21 +112,19 @@ 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_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`.                                                                                                                               |
+| 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`.                                                                   |

Dockerfile

@@ -3,17 +3,15 @@
 # trunk-ignore-all(hadolint/DL3008): Do not pin apt package versions
 # trunk-ignore-all(hadolint/DL3013): Do not pin pip package versions
 
-FROM debian:trixie AS builder
+FROM python:3.14-slim-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 \

alpine.Dockerfile

@@ -3,19 +3,12 @@
 # trunk-ignore-all(hadolint/DL3018): Do not pin apk package versions
 # trunk-ignore-all(hadolint/DL3013): Do not pin pip package versions
 
-# Ensure the Alpine version is updated in both stages of the container!
-FROM alpine:3.23 AS builder
+FROM python:3.14-alpine3.22 AS builder
 ARG PIO_ENV=native
-
-# 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 \
@@ -67,4 +60,4 @@ EXPOSE 4403
 
 CMD [ "sh",  "-cx", "meshtasticd --fsdir=/var/lib/meshtasticd" ]
 
-HEALTHCHECK NONE
+HEALTHCHECK NONE

bin/build-native.sh

@@ -31,6 +31,5 @@ basename=meshtasticd-$1-$VERSION
 pio pkg install --environment "$PIO_ENV" || platformioFailed
 pio run --environment "$PIO_ENV" || platformioFailed
 
-os_name=$(uname -s | tr '[:upper:]' '[:lower:]')
-cp "$BUILDDIR/meshtasticd" "$OUTDIR/meshtasticd_${os_name}_$(uname -m)"
+cp "$BUILDDIR/meshtasticd" "$OUTDIR/meshtasticd_linux_$(uname -m)"
 cp bin/native-install.* $OUTDIR/

bin/config.d/lora-luckfox-pico-max-ws-raspberry-pi-pico-hat.yaml

@@ -1,31 +0,0 @@
-# For use with Armbian luckfox-pico-max
-# Waveshare LoRa HAT for Raspberry Pi Pico
-# https://www.waveshare.com/wiki/Pico-LoRa-SX1262
-
-Meta:
-  name: luckfox-pico-max-ws-raspberry-pi-pico-hat
-  support: community
-  compatible:
-    - luckfox-pico-max # Armbian
-
-Lora:
-  Module: sx1262
-  DIO2_AS_RF_SWITCH: true
-  DIO3_TCXO_VOLTAGE: true
-  spidev: spidev0.0
-  Busy: # GPIO1_C7 / GP2
-    pin: 55
-    gpiochip: 1
-    line: 23
-  CS: # GPIO1_C6 / GP3
-    pin: 54
-    gpiochip: 1
-    line: 22
-  Reset: # GPIO1_D1 / GP15
-    pin: 57
-    gpiochip: 1
-    line: 25
-  IRQ: # GPIO2_A2 / GP20
-    pin: 66
-    gpiochip: 2
-    line: 2

bin/show-unmerged-prs.sh

@@ -1,118 +0,0 @@
-#!/bin/bash
-
-# Script to show commits in develop that are not in master
-# with their associated PR info and commit hashes
-# 
-# Usage:
-#   ./show-unmerged-prs.sh            # Show all unmerged commits
-#   ./show-unmerged-prs.sh --bugfix   # Show only bugfix-labeled PRs
-
-set -e
-
-REPO="firmware"
-OWNER="meshtastic"
-BASE_BRANCH="master"
-HEAD_BRANCH="develop"
-LIMIT=100
-FILTER_LABEL=""
-
-# Parse arguments
-for arg in "$@"; do
-    case $arg in
-        --bugfix)
-            FILTER_LABEL="bugfix"
-            shift
-            ;;
-        --feature)
-            FILTER_LABEL="feature"
-            shift
-            ;;
-        --help)
-            echo "Usage: $0 [OPTIONS]"
-            echo "Options:"
-            echo "  --bugfix     Show only PRs labeled with 'bugfix'"
-            echo "  --feature    Show only PRs labeled with 'feature'"
-            echo "  --help       Show this help message"
-            exit 0
-            ;;
-    esac
-done
-
-if [ -n "$FILTER_LABEL" ]; then
-    echo "Fetching commits in $HEAD_BRANCH that are not in $BASE_BRANCH (filtered by label: $FILTER_LABEL)..."
-else
-    echo "Fetching commits in $HEAD_BRANCH that are not in $BASE_BRANCH..."
-fi
-echo ""
-
-# Check if gh CLI is available
-if ! command -v gh &> /dev/null; then
-    echo "ERROR: GitHub CLI (gh) not found. Please install it first."
-    echo "Visit: https://cli.github.com/"
-    exit 1
-fi
-
-# Get commits in develop that are not in master
-# For each commit, try to find associated PR
-git fetch origin develop master 2>/dev/null || true
-
-# Use git to get the list of commits
-commits=$(git log --pretty=format:"%H|%s" origin/master..origin/develop | head -n $LIMIT)
-
-count=0
-displayed=0
-echo "Commits in $HEAD_BRANCH not in $BASE_BRANCH:"
-echo "=============================================="
-echo ""
-
-while IFS='|' read -r hash subject; do
-    ((count++))
-    
-    # Try to find the PR for this commit
-    # Extract PR number, title, description, and labels
-    pr_response=$(gh api -X GET "/repos/$OWNER/$REPO/commits/$hash/pulls" \
-        -H "Accept: application/vnd.github.v3+json" 2>/dev/null | \
-        jq -r '.[0] | "\(.number)|\(.title)|\(.body // "No description")|\(.labels | map(.name) | join(","))"' 2>/dev/null || echo "||||")
-    
-    if [ -z "$pr_response" ] || [ "$pr_response" = "||||" ]; then
-        # If no PR found, skip if filter is active, otherwise show the commit
-        if [ -z "$FILTER_LABEL" ]; then
-            ((displayed++))
-            echo "[$displayed] Commit: $hash"
-            echo "    Subject: $subject"
-            echo "    PR: Not found in GitHub"
-            echo ""
-        fi
-    else
-        IFS='|' read -r pr_num pr_title pr_desc pr_labels <<< "$pr_response"
-        
-        # Check if filter matches
-        if [ -n "$FILTER_LABEL" ]; then
-            # Only show if the label is in the labels list
-            if ! echo "$pr_labels" | grep -q "$FILTER_LABEL"; then
-                continue
-            fi
-        fi
-        
-        ((displayed++))
-        echo "[$displayed] PR #$pr_num - $pr_title"
-        echo "    Commit: $hash"
-        if [ -n "$pr_desc" ] && [ "$pr_desc" != "No description" ]; then
-            # Truncate description to 200 chars
-            desc_short="${pr_desc:0:200}"
-            [ ${#pr_desc} -gt 200 ] && desc_short+="..."
-            echo "    Description: $desc_short"
-        fi
-        if [ -n "$pr_labels" ] && [ "$pr_labels" != "" ]; then
-            echo "    Labels: $pr_labels"
-        fi
-        echo ""
-    fi
-done <<< "$commits"
-
-echo ""
-if [ -n "$FILTER_LABEL" ]; then
-    echo "Done. Showing $displayed PRs with label '$FILTER_LABEL' from $displayed commits checked."
-else
-    echo "Done. Showing $displayed commits from $HEAD_BRANCH not in $BASE_BRANCH."
-fi

boards/heltec_v4_r8.json

@@ -1,43 +0,0 @@
-{
-  "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"
-}

debian/ci_pack_sdeb.sh

@@ -1,5 +1,4 @@
 #!/usr/bin/bash
-set -e
 export DEBEMAIL="jbennett@incomsystems.biz"
 export PLATFORMIO_LIBDEPS_DIR=pio/libdeps
 export PLATFORMIO_PACKAGES_DIR=pio/packages

mcp-server/README.md

@@ -166,73 +166,15 @@ 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)                                              |
-| `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.
+| 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) |
 
 ## Hardware Test Suite
 

mcp-server/src/meshtastic_mcp/connection.py

@@ -1,4 +1,4 @@
-"""Context manager for meshtastic interface connections (serial + TCP).
+"""Context manager for meshtastic.SerialInterface connections.
 
 Every info/admin tool goes through `connect(port)` so we have a single place
 that:
@@ -6,16 +6,8 @@ that:
   - fails fast if a serial_session is already holding the port,
   - guarantees `.close()` is called, even on exception.
 
-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.
+The `SerialInterface` blocks on construction waiting for the node database;
+that's fine for v1 since every tool is a short-lived request.
 """
 
 from __future__ import annotations
@@ -25,107 +17,20 @@ 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.
-
-    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()`.
-    """
+    """Pick a port: explicit > sole likely_meshtastic candidate > error."""
     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, 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."
+            "No Meshtastic devices detected. Plug one in 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)
@@ -138,62 +43,17 @@ def resolve_port(port: str | None) -> str:
 
 @contextmanager
 def connect(port: str | None = None, timeout_s: float = 8.0) -> Iterator:
-    """Open a meshtastic interface (serial or TCP) and always close it.
+    """Open a `meshtastic.SerialInterface` and always close it.
 
-    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.
+    Raises `ConnectionError` immediately if another serial session holds the
+    port (a `pio device monitor` in `serial_sessions/`, for instance).
     """
-    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(
@@ -210,12 +70,7 @@ def connect(port: str | None = None, timeout_s: float = 8.0) -> Iterator:
 
     iface = None
     try:
-        iface = SerialInterface(
-            devPath=resolved,
-            connectNow=True,
-            noProto=False,
-            timeout=timeout,
-        )
+        iface = SerialInterface(devPath=resolved, connectNow=True, noProto=False)
         yield iface
     finally:
         if iface is not None:

mcp-server/src/meshtastic_mcp/devices.py

@@ -1,18 +1,13 @@
-"""USB/serial + TCP device discovery.
+"""USB/serial 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
@@ -24,45 +19,6 @@ 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.
 
@@ -114,22 +70,6 @@ def list_devices(include_unknown: bool = False) -> list[dict[str, Any]]:
             }
         )
 
-    # 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"],
-        )
-    )
-
+    # Stable ordering: likely_meshtastic first, then by port path
+    results.sort(key=lambda r: (not r["likely_meshtastic"], r["port"]))
     return results

mcp-server/src/meshtastic_mcp/flash.py

@@ -17,7 +17,7 @@ from typing import Any
 
 import serial
 
-from . import boards, config, connection, devices, pio, userprefs
+from . import boards, config, devices, pio, userprefs
 
 # Meshtastic variants use both `esp32s3` and `esp32-s3` style names across
 # variants/*/platformio.ini (no consistency enforced). Accept both spellings.
@@ -46,18 +46,6 @@ 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():
@@ -153,8 +141,6 @@ 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],
@@ -214,7 +200,6 @@ 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:
@@ -272,7 +257,6 @@ 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:
@@ -407,7 +391,6 @@ 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}
 

mcp-server/src/meshtastic_mcp/hw_tools.py

@@ -16,7 +16,7 @@ import subprocess
 from pathlib import Path
 from typing import Any, Sequence
 
-from . import config, connection, pio
+from . import config, pio
 
 _TIMEOUT_SHORT = 30
 _TIMEOUT_LONG = 600
@@ -102,7 +102,6 @@ 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)
@@ -117,7 +116,6 @@ 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.
@@ -136,7 +134,6 @@ 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 {
@@ -159,7 +156,6 @@ 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}")
@@ -217,7 +213,6 @@ 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:

mcp-server/src/meshtastic_mcp/serial_session.py

@@ -71,10 +71,6 @@ 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

mcp-server/tests/unit/test_connection_tcp.py

@@ -1,383 +0,0 @@
-"""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

platformio.ini

@@ -29,7 +29,6 @@ build_flags = -Wno-missing-field-initializers
 	-DUSE_THREAD_NAMES
 	-DTINYGPS_OPTION_NO_CUSTOM_FIELDS
 	-DPB_ENABLE_MALLOC=1
-	-DPB_VALIDATE_UTF8=1
 	-DRADIOLIB_EXCLUDE_CC1101=1
 	-DRADIOLIB_EXCLUDE_NRF24=1
 	-DRADIOLIB_EXCLUDE_RF69=1
@@ -59,6 +58,7 @@ build_flags = -Wno-missing-field-initializers
 	-DMESHTASTIC_EXCLUDE_POWERMON=1
 	-DMESHTASTIC_EXCLUDE_STATUS=1
 	-D MAX_THREADS=40 ; As we've split modules, we have more threads to manage
+	-DLED_BUILTIN=-1
 	#-DBUILD_EPOCH=$UNIX_TIME ; set in platformio-custom.py now
 	#-D OLED_PL=1
 	#-D DEBUG_HEAP=1 ; uncomment to add free heap space / memory leak debugging logs
@@ -68,7 +68,7 @@ monitor_speed = 115200
 monitor_filters = direct
 lib_deps =
 	# renovate: datasource=git-refs depName=meshtastic-esp8266-oled-ssd1306 packageName=https://github.com/meshtastic/esp8266-oled-ssd1306 gitBranch=master
-	https://github.com/meshtastic/esp8266-oled-ssd1306/archive/6bfd1f135e1ebe37afd6050bb4b9964cea3fcfda.zip
+	https://github.com/meshtastic/esp8266-oled-ssd1306/archive/21e484f409cde18d44012caef84c244eb5ca28f3.zip
 	# renovate: datasource=git-refs depName=meshtastic-OneButton packageName=https://github.com/meshtastic/OneButton gitBranch=master
 	https://github.com/meshtastic/OneButton/archive/fa352d668c53f290cfa480a5f79ad422cd828c70.zip
 	# renovate: datasource=git-refs depName=meshtastic-arduino-fsm packageName=https://github.com/meshtastic/arduino-fsm gitBranch=master
@@ -126,7 +126,7 @@ lib_deps =
 [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/4bf593a82100b911ff816dddf7158ffdee2114cd.zip
+	https://github.com/meshtastic/device-ui/archive/56e1da4e7d30abcd746a2092a30e422f8cf5fc2b.zip
 
 ; Common libs for environmental measurements in telemetry module
 [environmental_base]

src/Power.cpp

@@ -717,17 +717,37 @@ bool Power::setup()
         found = true;
 #endif
     }
-    attachPowerInterrupts();
+#ifdef EXT_PWR_DETECT
+    attachInterrupt(
+        EXT_PWR_DETECT,
+        []() {
+            power->setIntervalFromNow(0);
+            runASAP = true;
+        },
+        CHANGE);
+#endif
+#ifdef BATTERY_CHARGING_INV
+    attachInterrupt(
+        BATTERY_CHARGING_INV,
+        []() {
+            power->setIntervalFromNow(0);
+            runASAP = true;
+        },
+        CHANGE);
+#endif
+#ifdef EXT_CHRG_DETECT
+    attachInterrupt(
+        EXT_CHRG_DETECT,
+        []() {
+            power->setIntervalFromNow(0);
+            runASAP = true;
+            BaseType_t higherWake = 0;
+        },
+        CHANGE);
+#endif
     enabled = found;
     low_voltage_counter = 0;
 
-#ifdef ARCH_ESP32
-    // Register callbacks for before and after lightsleep
-    // Used to detach and reattach interrupts
-    lsObserver.observe(&notifyLightSleep);
-    lsEndObserver.observe(&notifyLightSleepEnd);
-#endif
-
     return found;
 }
 
@@ -755,10 +775,8 @@ void Power::reboot()
     rp2040.reboot();
 #elif defined(ARCH_PORTDUINO)
     deInitApiServer();
-#ifdef __linux__
     if (aLinuxInputImpl)
         aLinuxInputImpl->deInit();
-#endif
     SPI.end();
     Wire.end();
     Serial1.end();
@@ -1008,97 +1026,6 @@ int32_t Power::runOnce()
     return (statusHandler && statusHandler->isInitialized()) ? (1000 * 20) : RUN_SAME;
 }
 
-#ifdef ARCH_ESP32
-
-// Detach our class' interrupts before lightsleep
-// Allows sleep.cpp to configure its own interrupts, which wake the device on user-button press
-int Power::beforeLightSleep(void *unused)
-{
-    LOG_WARN("Detaching power interrupts for sleep");
-    detachPowerInterrupts();
-    return 0; // Indicates success
-}
-
-// Reconfigure our interrupts
-// Our class' interrupts were disconnected during sleep, to allow the user button to wake the device from sleep
-int Power::afterLightSleep(esp_sleep_wakeup_cause_t cause)
-{
-    attachPowerInterrupts();
-    return 0; // Indicates success
-}
-
-#endif
-
-/*
- * Attach (or re-attach) hardware interrupts for power management
- * Public method. Used outside class when waking from MCU sleep
- */
-void Power::attachPowerInterrupts()
-{
-#ifdef EXT_PWR_DETECT
-    attachInterrupt(
-        EXT_PWR_DETECT,
-        []() {
-            power->setIntervalFromNow(0);
-            runASAP = true;
-        },
-        CHANGE);
-#endif
-#ifdef BATTERY_CHARGING_INV
-    attachInterrupt(
-        BATTERY_CHARGING_INV,
-        []() {
-            power->setIntervalFromNow(0);
-            runASAP = true;
-        },
-        CHANGE);
-#endif
-#ifdef EXT_CHRG_DETECT
-    attachInterrupt(
-        EXT_CHRG_DETECT,
-        []() {
-            power->setIntervalFromNow(0);
-            runASAP = true;
-            BaseType_t higherWake = 0;
-        },
-        CHANGE);
-#endif
-#ifdef PMU_IRQ
-    if (PMU) {
-        attachInterrupt(
-            PMU_IRQ,
-            [] {
-                pmu_irq = true;
-                power->setIntervalFromNow(0);
-                runASAP = true;
-            },
-            FALLING);
-    }
-#endif
-}
-
-/*
- * Detach the "normal" button interrupts.
- * Public method. Used before attaching a "wake-on-button" interrupt for MCU sleep
- */
-void Power::detachPowerInterrupts()
-{
-#ifdef EXT_PWR_DETECT
-    detachInterrupt(EXT_PWR_DETECT);
-#endif
-#ifdef BATTERY_CHARGING_INV
-    detachInterrupt(BATTERY_CHARGING_INV);
-#endif
-#ifdef EXT_CHRG_DETECT
-    detachInterrupt(EXT_CHRG_DETECT);
-#endif
-#ifdef PMU_IRQ
-    if (PMU) {
-        detachInterrupt(PMU_IRQ);
-    }
-#endif
-}
-
 /**
  * Init the power manager chip
  *
@@ -1376,6 +1303,8 @@ bool Power::axpChipInit()
     }
 
     pinMode(PMU_IRQ, INPUT);
+    attachInterrupt(
+        PMU_IRQ, [] { pmu_irq = true; }, FALLING);
 
     // we do not look for AXPXXX_CHARGING_FINISHED_IRQ & AXPXXX_CHARGING_IRQ
     // because it occurs repeatedly while there is no battery also it could cause

src/RedirectablePrint.h

@@ -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>
 

src/configuration.h

@@ -157,9 +157,6 @@ 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.

src/detect/ScanI2C.h

@@ -34,7 +34,6 @@ class ScanI2C
         SHT31,
         SHT4X,
         SHTC3,
-        SHTXX,
         LPS22HB,
         QMC6310U,
         QMC6310N,

src/gps/GPSUpdateScheduling.cpp

@@ -70,25 +70,20 @@ 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
-    uint32_t elapsed = elapsedSearchMs();
-
-    // Anything over 15 minutes is too long, regardless of the broadcast interval.
-    // TODO: Make a smarter algorithm that backs off the search dwell time when not getting a lock.
-    if (elapsed > maxSearchClampMs)
-        return true;
-
     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
-    if (elapsed > maxSearchMs)
+    else if (elapsedSearchMs() > maxSearchMs)
         return true;
 
     // Otherwise, not too long yet!
-    return false;
+    else
+        return false;
 }
 
 // Updates the predicted time-to-get-lock, by exponentially smoothing the latest observation

src/graphics/TFTDisplay.cpp

@@ -428,7 +428,7 @@ static LGFX *tft = nullptr;
 
 #elif defined(ST7789_CS)
 #include <LovyanGFX.hpp> // Graphics and font library for ST7735 driver chip
-#if defined(HELTEC_V4_TFT) || defined(HELTEC_V4_R8_TFT)
+#ifdef HELTEC_V4_TFT
 #include "chsc6x.h"
 #include "lgfx/v1/Touch.hpp"
 namespace lgfx
@@ -450,11 +450,7 @@ 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;
@@ -491,7 +487,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) || defined(HELTEC_V4_R8_TFT)
+#elif defined(HELTEC_V4_TFT)
     lgfx::TOUCH_CHSC6X _touch_instance;
 #else
     lgfx::Touch_GT911 _touch_instance;
@@ -510,11 +506,7 @@ 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
-#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.spi_3wire = false;
             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)
@@ -564,11 +556,8 @@ 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

src/graphics/niche/Drivers/EInk/ED047TC1.cpp

@@ -1,122 +0,0 @@
-/*
-
-    NicheGraphics parallel E-Ink driver for the LilyGo T5-S3-ePaper-Pro (ED047TC1).
-
-    InkHUD buffer format : 1bpp, horizontal bytes, MSB = leftmost pixel, 1 = white
-    FastEPD buffer format: 1bpp, horizontal bytes, MSB = leftmost pixel, 1 = white
-
-    Both formats share the same pixel layout and polarity (1 = white, 0 = black).
-    The InkHUD safe-area buffer (944×523) is copied into the centre of the physical
-    960×540 FastEPD buffer so content clears the panel's inactive edge border.
-    See ED047TC1.h for the H_OFFSET_BYTES / V_OFFSET_TOP / V_OFFSET_BOTTOM constants.
-
-*/
-
-// Ruler diagnostic — uncomment to draw calibration lines at each physical edge.
-// #define EINK_EDGE_LINES
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-#ifdef T5_S3_EPAPER_PRO
-
-#include "./ED047TC1.h"
-
-#include "FastEPD.h"
-#include "configuration.h"
-
-using namespace NicheGraphics::Drivers;
-
-void ED047TC1::begin(SPIClass *spi, uint8_t pin_dc, uint8_t pin_cs, uint8_t pin_busy, uint8_t pin_rst)
-{
-    // Parallel display — SPI parameters are not used
-    (void)spi;
-    (void)pin_dc;
-    (void)pin_cs;
-    (void)pin_busy;
-    (void)pin_rst;
-
-    epaper = new FASTEPD;
-
-#if defined(T5_S3_EPAPER_PRO_V1)
-    epaper->initPanel(BB_PANEL_LILYGO_T5PRO, 28000000);
-#elif defined(T5_S3_EPAPER_PRO_V2)
-    epaper->initPanel(BB_PANEL_LILYGO_T5PRO_V2, 28000000);
-    // Initialize all PCA9535 port-0 pins as outputs / HIGH
-    for (int i = 0; i < 8; i++) {
-        epaper->ioPinMode(i, OUTPUT);
-        epaper->ioWrite(i, HIGH);
-    }
-#else
-#error "ED047TC1 driver: unsupported variant — define T5_S3_EPAPER_PRO_V1 or T5_S3_EPAPER_PRO_V2"
-#endif
-
-    epaper->setMode(BB_MODE_1BPP);
-    epaper->clearWhite();
-    epaper->fullUpdate(true); // Blocking initial clear
-}
-
-void ED047TC1::update(uint8_t *imageData, UpdateTypes type)
-{
-    if (!epaper)
-        return;
-
-    // InkHUD renders into a DISPLAY_WIDTH × DISPLAY_HEIGHT safe-area buffer.
-    // We need to place that into the centre of the physical 960×540 FastEPD buffer,
-    // leaving blank margins at every edge to avoid the panel's inactive border.
-    const uint32_t srcRowBytes = (DISPLAY_WIDTH + 7) / 8; // bytes per row in InkHUD buffer (118)
-    const uint32_t dstRowBytes = (960 + 7) / 8;           // bytes per row in physical buffer (120)
-    const uint32_t dstTotalRows = 540;
-
-    uint8_t *cur = epaper->currentBuffer();
-
-    // Fill physical buffer with white (0xFF = white in FastEPD 1bpp)
-    memset(cur, 0xFF, dstRowBytes * dstTotalRows);
-
-    // Copy each InkHUD row into the physical buffer with horizontal + vertical offsets
-    for (uint32_t row = 0; row < DISPLAY_HEIGHT; row++) {
-        const uint8_t *srcRow = imageData + row * srcRowBytes;
-        uint8_t *dstRow = cur + (row + V_OFFSET_TOP) * dstRowBytes + H_OFFSET_BYTES;
-        memcpy(dstRow, srcRow, srcRowBytes);
-    }
-
-#ifdef EINK_EDGE_LINES
-    // Draw a 1px black box at the exact boundary of the safe area within the
-    // physical buffer. If the margins are correct, all 4 lines should be
-    // fully visible and right at the edge of the usable display area.
-
-    auto setPixelBlack = [&](uint32_t col, uint32_t row) { cur[row * dstRowBytes + col / 8] &= ~(0x80 >> (col % 8)); };
-
-    const uint32_t safeX = H_OFFSET_BYTES * 8;
-    const uint32_t safeY = V_OFFSET_TOP;
-    const uint32_t safeW = DISPLAY_WIDTH;
-    const uint32_t safeH = DISPLAY_HEIGHT;
-
-    // Top edge: horizontal line at safeY
-    for (uint32_t col = safeX; col < safeX + safeW; col++)
-        setPixelBlack(col, safeY);
-
-    // Bottom edge: horizontal line at safeY + safeH - 1
-    for (uint32_t col = safeX; col < safeX + safeW; col++)
-        setPixelBlack(col, safeY + safeH - 1);
-
-    // Left edge: vertical line at safeX
-    for (uint32_t row = safeY; row < safeY + safeH; row++)
-        setPixelBlack(safeX, row);
-
-    // Right edge: vertical line at safeX + safeW - 1
-    for (uint32_t row = safeY; row < safeY + safeH; row++)
-        setPixelBlack(safeX + safeW - 1, row);
-#endif
-
-    if (type == FULL) {
-        epaper->fullUpdate(CLEAR_SLOW, false);
-        epaper->backupPlane(); // Sync pPrevious so next partialUpdate has a correct baseline
-    } else {
-        // FAST: true partial update — compares pCurrent vs pPrevious and only applies
-        // the update waveform to rows that actually changed. Unchanged rows get a neutral
-        // signal (no visible effect). partialUpdate() updates pPrevious internally.
-        epaper->partialUpdate(false, 0, dstTotalRows - 1);
-    }
-}
-
-#endif // T5_S3_EPAPER_PRO
-#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

src/graphics/niche/Drivers/EInk/ED047TC1.h

@@ -1,90 +0,0 @@
-/*
-
-    E-Ink display driver adapter
-        - ED047TC1 (via FastEPD library)
-        - Manufacturer: E Ink / used in LilyGo T5-E-Paper-S3-Pro
-        - Size: 4.7 inch
-        - Physical resolution: 960px x 540px
-        - Interface: 8-bit parallel (NOT SPI)
-
-    Unlike the other NicheGraphics EInk drivers, this one drives a parallel e-paper
-    panel via the FastEPD library. SPI parameters passed to begin() are ignored.
-
-    The ED047TC1 panel has an inactive pixel border on all four edges (~4–8 physical
-    pixels). DISPLAY_WIDTH / DISPLAY_HEIGHT expose a reduced "safe area" to InkHUD so
-    that content is never drawn into this dead zone. The update() method copies the
-    InkHUD frame buffer into the centre of the larger physical 960×540 buffer, using
-    H_OFFSET_BYTES (horizontal, whole bytes = 8 pixels per byte),
-    V_OFFSET_TOP and V_OFFSET_BOTTOM (vertical, pixel rows) to position it.
-
-    Changing these constants shifts content inward from each physical edge:
-        H_OFFSET_BYTES = 1  →  8px left margin, 8px right margin   (960 – 8 – 8   = 944)
-        V_OFFSET_TOP   = 9  →  9px top margin  (asymmetric: top ≠ bottom)
-        V_OFFSET_BOTTOM = 8 →  8px bottom margin                    (540 – 9 – 8   = 523)
-
-*/
-
-#pragma once
-
-#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
-
-#include "configuration.h"
-
-#include "./EInk.h"
-
-// Forward declare to avoid pulling FastEPD into all translation units
-class FASTEPD;
-
-namespace NicheGraphics::Drivers
-{
-
-class ED047TC1 : public EInk
-{
-    // Safe-area dimensions exposed to InkHUD (physical panel is 960×540).
-    //
-    // The ED047TC1 has an inactive pixel border on all physical edges.
-    // The physical buffer coordinates do NOT directly match the visual orientation
-    // due to FastEPD's portrait scan direction and InkHUD's rotation=3 (270° CW):
-    //
-    //   Physical buffer          Visual on device (rotation=3)
-    //   ─────────────────        ──────────────────────────────
-    //   Physical LEFT  cols  →   Visual TOP    edge
-    //   Physical RIGHT cols  →   Visual BOTTOM edge
-    //   Physical TOP   rows  →   Visual RIGHT  edge
-    //   Physical BOTTOM rows →   Visual LEFT   edge
-    //
-    // Offset constants shift the InkHUD safe-area away from each physical dead zone:
-    //   H_OFFSET_BYTES : whole bytes from physical left  (8px per byte, affects visual TOP)
-    //   Physical right margin = 960 − H_OFFSET_BYTES×8 − DISPLAY_WIDTH  (affects visual BOTTOM)
-    //   V_OFFSET_TOP   : pixel rows from physical top    (affects visual RIGHT)
-    //   V_OFFSET_BOTTOM: pixel rows from physical bottom (affects visual LEFT)
-    //
-    // Calibrated by flashing a 1px border box and adjusting until all 4 sides are visible.
-
-    static constexpr uint16_t DISPLAY_WIDTH = 944;  // 960 − H_OFFSET_BYTES×8 − right_margin (8+8 = 16px)
-    static constexpr uint16_t DISPLAY_HEIGHT = 523; // 540 − V_OFFSET_TOP − V_OFFSET_BOTTOM (9+8 = 17px)
-
-    static constexpr uint8_t H_OFFSET_BYTES = 1;  // visual TOP  : 8px physical left margin
-                                                  // visual BOTTOM: 960−8−944=8px physical right margin
-    static constexpr uint8_t V_OFFSET_TOP = 9;    // visual RIGHT : CONFIRMED OK
-    static constexpr uint8_t V_OFFSET_BOTTOM = 8; // visual LEFT  : 8px physical bottom margin
-
-    static constexpr UpdateTypes supported = static_cast<UpdateTypes>(FULL | FAST);
-
-  public:
-    ED047TC1() : EInk(DISPLAY_WIDTH, DISPLAY_HEIGHT, supported) {}
-
-    // EInk interface — SPI params are not used for this parallel display
-    void begin(SPIClass *spi, uint8_t pin_dc, uint8_t pin_cs, uint8_t pin_busy, uint8_t pin_rst = 0xFF) override;
-    void update(uint8_t *imageData, UpdateTypes type) override;
-
-  protected:
-    bool isUpdateDone() override { return true; } // FastEPD updates are blocking
-
-  private:
-    FASTEPD *epaper = nullptr;
-};
-
-} // namespace NicheGraphics::Drivers
-
-#endif // MESHTASTIC_INCLUDE_NICHE_GRAPHICS

src/graphics/niche/InkHUD/AppletFont.h

@@ -88,12 +88,8 @@ class AppletFont
 
 // Greek
 #include "graphics/niche/Fonts/FreeSans12pt_Win1253.h"
-#include "graphics/niche/Fonts/FreeSans18pt_Win1253.h"
-#include "graphics/niche/Fonts/FreeSans24pt_Win1253.h"
 #include "graphics/niche/Fonts/FreeSans6pt_Win1253.h"
 #include "graphics/niche/Fonts/FreeSans9pt_Win1253.h"
-#define FREESANS_24PT_WIN1253 InkHUD::AppletFont(FreeSans24pt_Win1253, InkHUD::AppletFont::WINDOWS_1253, -5, 3)
-#define FREESANS_18PT_WIN1253 InkHUD::AppletFont(FreeSans18pt_Win1253, InkHUD::AppletFont::WINDOWS_1253, -4, 2)
 #define FREESANS_12PT_WIN1253 InkHUD::AppletFont(FreeSans12pt_Win1253, InkHUD::AppletFont::WINDOWS_1253, -3, 1)
 #define FREESANS_9PT_WIN1253 InkHUD::AppletFont(FreeSans9pt_Win1253, InkHUD::AppletFont::WINDOWS_1253, -2, -1)
 #define FREESANS_6PT_WIN1253 InkHUD::AppletFont(FreeSans6pt_Win1253, InkHUD::AppletFont::WINDOWS_1253, -1, -2)

src/input/ButtonThread.cpp

@@ -143,10 +143,6 @@ int32_t ButtonThread::runOnce()
         leadUpSequenceActive = false;
         resetLeadUpSequence();
     }
-#ifdef INPUT_DEBUG
-    if (buttonCurrentlyPressed)
-        LOG_WARN("Button held for %u ms", millis() - buttonPressStartTime);
-#endif
 
     // Progressive lead-up sound system
     if (!_suppressLeadUp && buttonCurrentlyPressed && (millis() - buttonPressStartTime) >= BUTTON_LEADUP_MS) {
@@ -315,8 +311,7 @@ int32_t ButtonThread::runOnce()
 void ButtonThread::attachButtonInterrupts()
 {
     // Interrupt for user button, during normal use. Improves responsiveness.
-    if (_intRoutine != nullptr)
-        attachInterrupt(_pinNum, _intRoutine, CHANGE);
+    attachInterrupt(_pinNum, _intRoutine, CHANGE);
 }
 
 /*
@@ -325,8 +320,7 @@ void ButtonThread::attachButtonInterrupts()
  */
 void ButtonThread::detachButtonInterrupts()
 {
-    if (_intRoutine != nullptr)
-        detachInterrupt(_pinNum);
+    detachInterrupt(_pinNum);
 }
 
 #ifdef ARCH_ESP32

src/input/InputBroker.cpp

@@ -390,11 +390,8 @@ 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

src/input/LinuxInput.h

@@ -1,8 +1,5 @@
 #pragma once
-// 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__)
+#if ARCH_PORTDUINO
 #include "InputBroker.h"
 #include "concurrency/OSThread.h"
 #include <assert.h>

src/input/LinuxInputImpl.h

@@ -1,5 +1,4 @@
-// Linux evdev impl. Same Linux-only gating as LinuxInput.h.
-#if defined(ARCH_PORTDUINO) && defined(__linux__)
+#ifdef ARCH_PORTDUINO
 #pragma once
 #include "LinuxInput.h"
 #include "main.h"

src/input/TouchScreenImpl1.cpp

@@ -29,8 +29,7 @@ void TouchScreenImpl1::init()
     return;
 #else
     TouchScreenBase::init(true);
-    if (inputBroker)
-        inputBroker->registerSource(this);
+    inputBroker->registerSource(this);
 #endif
 }
 

src/main.cpp

@@ -340,9 +340,138 @@ void setup()
 
 #ifdef BLE_LED
     pinMode(BLE_LED, OUTPUT);
+#ifdef BLE_LED_INVERTED
+    digitalWrite(BLE_LED, HIGH);
+#else
+    digitalWrite(BLE_LED, LOW);
+#endif
+#endif
+
+#if defined(T_DECK)
+    // GPIO10 manages all peripheral power supplies
+    // Turn on peripheral power immediately after MUC starts.
+    // If some boards are turned on late, ESP32 will reset due to low voltage.
+    // ESP32-C3(Keyboard) , MAX98357A(Audio Power Amplifier) ,
+    // TF Card , Display backlight(AW9364DNR) , AN48841B(Trackball) , ES7210(Decoder)
+    pinMode(KB_POWERON, OUTPUT);
+    digitalWrite(KB_POWERON, HIGH);
+    // T-Deck has all three SPI peripherals (TFT, SD, LoRa) attached to the same SPI bus
+    // We need to initialize all CS pins in advance otherwise there will be SPI communication issues
+    // e.g. when detecting the SD card
+    pinMode(LORA_CS, OUTPUT);
+    digitalWrite(LORA_CS, HIGH);
+    pinMode(SDCARD_CS, OUTPUT);
+    digitalWrite(SDCARD_CS, HIGH);
+    pinMode(TFT_CS, OUTPUT);
+    digitalWrite(TFT_CS, HIGH);
+    delay(100);
+#elif defined(T_DECK_PRO)
+    pinMode(LORA_EN, OUTPUT);
+    digitalWrite(LORA_EN, HIGH);
+    pinMode(LORA_CS, OUTPUT);
+    digitalWrite(LORA_CS, HIGH);
+    pinMode(SDCARD_CS, OUTPUT);
+    digitalWrite(SDCARD_CS, HIGH);
+    pinMode(PIN_EINK_CS, OUTPUT);
+    digitalWrite(PIN_EINK_CS, HIGH);
+#if PIN_EINK_RES >= 0
+    pinMode(PIN_EINK_RES, OUTPUT);
+    digitalWrite(PIN_EINK_RES, HIGH);
+#endif
+    pinMode(CST328_PIN_RST, OUTPUT);
+    digitalWrite(CST328_PIN_RST, HIGH);
+#elif defined(T_LORA_PAGER)
+    pinMode(LORA_CS, OUTPUT);
+    digitalWrite(LORA_CS, HIGH);
+    pinMode(SDCARD_CS, OUTPUT);
+    digitalWrite(SDCARD_CS, HIGH);
+    pinMode(TFT_CS, OUTPUT);
+    digitalWrite(TFT_CS, HIGH);
+    pinMode(KB_INT, INPUT_PULLUP);
+    // io expander
+    io.begin(Wire, XL9555_SLAVE_ADDRESS0, SDA, SCL);
+    io.pinMode(EXPANDS_DRV_EN, OUTPUT);
+    io.digitalWrite(EXPANDS_DRV_EN, HIGH);
+    io.pinMode(EXPANDS_AMP_EN, OUTPUT);
+    io.digitalWrite(EXPANDS_AMP_EN, LOW);
+    io.pinMode(EXPANDS_LORA_EN, OUTPUT);
+    io.digitalWrite(EXPANDS_LORA_EN, HIGH);
+    io.pinMode(EXPANDS_GPS_EN, OUTPUT);
+    io.digitalWrite(EXPANDS_GPS_EN, HIGH);
+    io.pinMode(EXPANDS_KB_EN, OUTPUT);
+    io.digitalWrite(EXPANDS_KB_EN, HIGH);
+    io.pinMode(EXPANDS_SD_EN, OUTPUT);
+    io.digitalWrite(EXPANDS_SD_EN, HIGH);
+    io.pinMode(EXPANDS_GPIO_EN, OUTPUT);
+    io.digitalWrite(EXPANDS_GPIO_EN, HIGH);
+    io.pinMode(EXPANDS_SD_PULLEN, INPUT);
+#elif defined(HACKADAY_COMMUNICATOR)
+    pinMode(KB_INT, INPUT);
     digitalWrite(BLE_LED, LED_STATE_OFF);
 #endif
 
+#if defined(T_DECK)
+    // GPIO10 manages all peripheral power supplies
+    // Turn on peripheral power immediately after MUC starts.
+    // If some boards are turned on late, ESP32 will reset due to low voltage.
+    // ESP32-C3(Keyboard) , MAX98357A(Audio Power Amplifier) ,
+    // TF Card , Display backlight(AW9364DNR) , AN48841B(Trackball) , ES7210(Decoder)
+    pinMode(KB_POWERON, OUTPUT);
+    digitalWrite(KB_POWERON, HIGH);
+    // T-Deck has all three SPI peripherals (TFT, SD, LoRa) attached to the same SPI bus
+    // We need to initialize all CS pins in advance otherwise there will be SPI communication issues
+    // e.g. when detecting the SD card
+    pinMode(LORA_CS, OUTPUT);
+    digitalWrite(LORA_CS, HIGH);
+    pinMode(SDCARD_CS, OUTPUT);
+    digitalWrite(SDCARD_CS, HIGH);
+    pinMode(TFT_CS, OUTPUT);
+    digitalWrite(TFT_CS, HIGH);
+    delay(100);
+#elif defined(T_DECK_PRO)
+    pinMode(LORA_EN, OUTPUT);
+    digitalWrite(LORA_EN, HIGH);
+    pinMode(LORA_CS, OUTPUT);
+    digitalWrite(LORA_CS, HIGH);
+    pinMode(SDCARD_CS, OUTPUT);
+    digitalWrite(SDCARD_CS, HIGH);
+    pinMode(PIN_EINK_CS, OUTPUT);
+    digitalWrite(PIN_EINK_CS, HIGH);
+#if PIN_EINK_RES >= 0
+    pinMode(PIN_EINK_RES, OUTPUT);
+    digitalWrite(PIN_EINK_RES, HIGH);
+#endif
+    pinMode(CST328_PIN_RST, OUTPUT);
+    digitalWrite(CST328_PIN_RST, HIGH);
+#elif defined(T_LORA_PAGER)
+    pinMode(LORA_CS, OUTPUT);
+    digitalWrite(LORA_CS, HIGH);
+    pinMode(SDCARD_CS, OUTPUT);
+    digitalWrite(SDCARD_CS, HIGH);
+    pinMode(TFT_CS, OUTPUT);
+    digitalWrite(TFT_CS, HIGH);
+    pinMode(KB_INT, INPUT_PULLUP);
+    // io expander
+    io.begin(Wire, XL9555_SLAVE_ADDRESS0, SDA, SCL);
+    io.pinMode(EXPANDS_DRV_EN, OUTPUT);
+    io.digitalWrite(EXPANDS_DRV_EN, HIGH);
+    io.pinMode(EXPANDS_AMP_EN, OUTPUT);
+    io.digitalWrite(EXPANDS_AMP_EN, LOW);
+    io.pinMode(EXPANDS_LORA_EN, OUTPUT);
+    io.digitalWrite(EXPANDS_LORA_EN, HIGH);
+    io.pinMode(EXPANDS_GPS_EN, OUTPUT);
+    io.digitalWrite(EXPANDS_GPS_EN, HIGH);
+    io.pinMode(EXPANDS_KB_EN, OUTPUT);
+    io.digitalWrite(EXPANDS_KB_EN, HIGH);
+    io.pinMode(EXPANDS_SD_EN, OUTPUT);
+    io.digitalWrite(EXPANDS_SD_EN, HIGH);
+    io.pinMode(EXPANDS_GPIO_EN, OUTPUT);
+    io.digitalWrite(EXPANDS_GPIO_EN, HIGH);
+    io.pinMode(EXPANDS_SD_PULLEN, INPUT);
+#elif defined(HACKADAY_COMMUNICATOR)
+    pinMode(KB_INT, INPUT);
+#endif
+
     concurrency::hasBeenSetup = true;
 #if HAS_SCREEN
     meshtastic_Config_DisplayConfig_OledType screen_model =

src/mesh/CryptoEngine.cpp

@@ -4,7 +4,6 @@
 #include <memory>
 
 #if !(MESHTASTIC_EXCLUDE_PKI)
-#include "HardwareRNG.h"
 #include "NodeDB.h"
 #include "aes-ccm.h"
 #include "meshUtils.h"
@@ -27,15 +26,6 @@ void CryptoEngine::generateKeyPair(uint8_t *pubKey, uint8_t *privKey)
 {
     // Mix in any randomness we can, to make key generation stronger.
     CryptRNG.begin(optstr(APP_VERSION));
-
-    uint8_t hardwareEntropy[64] = {0};
-    if (HardwareRNG::fill(hardwareEntropy, sizeof(hardwareEntropy), true)) {
-        CryptRNG.stir(hardwareEntropy, sizeof(hardwareEntropy));
-    } else {
-        LOG_WARN("Hardware entropy unavailable, falling back to software RNG");
-    }
-    memset(hardwareEntropy, 0, sizeof(hardwareEntropy));
-
     if (myNodeInfo.device_id.size == 16) {
         CryptRNG.stir(myNodeInfo.device_id.bytes, myNodeInfo.device_id.size);
     }

src/mesh/Default.cpp

@@ -2,21 +2,18 @@
 
 #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)
 {
-    return secondsToMsClamped(configuredInterval > 0 ? configuredInterval : defaultInterval);
+    if (configuredInterval > 0)
+        return configuredInterval * 1000;
+    return defaultInterval * 1000;
 }
 
 uint32_t Default::getConfiguredOrDefaultMs(uint32_t configuredInterval)
 {
-    return secondsToMsClamped(configuredInterval > 0 ? configuredInterval : default_broadcast_interval_secs);
+    if (configuredInterval > 0)
+        return configuredInterval * 1000;
+    return default_broadcast_interval_secs * 1000;
 }
 
 uint32_t Default::getConfiguredOrDefault(uint32_t configured, uint32_t defaultValue)
@@ -50,14 +47,7 @@ uint32_t Default::getConfiguredOrDefaultMsScaled(uint32_t configured, uint32_t d
                   meshtastic_Config_DeviceConfig_Role_TAK_TRACKER))
         return getConfiguredOrDefaultMs(configured, defaultValue);
 
-    // 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;
+    return getConfiguredOrDefaultMs(configured, defaultValue) * congestionScalingCoefficient(numOnlineNodes);
 }
 
 uint32_t Default::getConfiguredOrMinimumValue(uint32_t configured, uint32_t minValue)
@@ -76,4 +66,4 @@ uint8_t Default::getConfiguredOrDefaultHopLimit(uint8_t configured)
 #else
     return (configured >= HOP_MAX) ? HOP_MAX : config.lora.hop_limit;
 #endif
-}
+}

src/mesh/HardwareRNG.cpp

@@ -1,173 +0,0 @@
-#include "HardwareRNG.h"
-
-#include <algorithm>
-#include <cstring>
-#include <random>
-
-#include "configuration.h"
-
-#if HAS_RADIO
-#include "RadioLibInterface.h"
-#endif
-
-#if defined(ARCH_NRF52)
-#include <Adafruit_nRFCrypto.h>
-extern Adafruit_nRFCrypto nRFCrypto;
-#elif defined(ARCH_ESP32)
-#include <esp_system.h>
-#elif defined(ARCH_RP2040)
-#include <Arduino.h>
-#elif defined(ARCH_PORTDUINO)
-#include <random>
-#include <unistd.h>
-#ifdef __linux__
-#include <sys/random.h> // getrandom()
-#else
-#include <stdlib.h> // arc4random_buf() on Darwin/BSD
-#endif
-#endif
-
-namespace HardwareRNG
-{
-
-namespace
-{
-void fillWithRandomDevice(uint8_t *buffer, size_t length)
-{
-    std::random_device rd;
-    size_t offset = 0;
-    while (offset < length) {
-        uint32_t value = rd();
-        size_t toCopy = std::min(length - offset, sizeof(value));
-        memcpy(buffer + offset, &value, toCopy);
-        offset += toCopy;
-    }
-}
-
-#if HAS_RADIO
-bool mixWithLoRaEntropy(uint8_t *buffer, size_t length)
-{
-    // Only attempt to pull entropy from the modem if it is initialized and exposes the helper.
-    // When the radio stack is disabled or has not yet been configured, we simply skip this step
-    // and return false so callers know no extra mixing occurred.
-    RadioLibInterface *radio = RadioLibInterface::instance;
-    if (!radio) {
-        // This path can run during portduinoSetup() before the console is initialized,
-        // both for unit-test binaries and the simulator's meshtasticd; LOG_* dereferences `console`.
-        if (console) {
-            LOG_ERROR("No radio instance available to provide entropy");
-        }
-        return false;
-    }
-
-    constexpr size_t chunkSize = 16;
-    uint8_t scratch[chunkSize];
-    size_t offset = 0;
-    bool mixed = false;
-
-    while (offset < length) {
-        size_t toCopy = std::min(length - offset, chunkSize);
-
-        // randomBytes() returns false if the modem does not support it or is not ready
-        // (for instance, when the radio is powered down). We break immediately to avoid
-        // blocking or returning partially-filled entropy and simply report failure.
-        if (!radio->randomBytes(scratch, toCopy)) {
-            break;
-        }
-
-        for (size_t i = 0; i < toCopy; ++i) {
-            buffer[offset + i] ^= scratch[i];
-        }
-
-        mixed = true;
-        offset += toCopy;
-    }
-
-    // Avoid leaving the modem-sourced bytes sitting on the stack longer than needed.
-    if (mixed) {
-        memset(scratch, 0, sizeof(scratch));
-    }
-
-    return mixed;
-}
-#endif
-} // namespace
-
-bool fill(uint8_t *buffer, size_t length, bool useRadioEntropy)
-{
-    if (!buffer || length == 0) {
-        return false;
-    }
-
-    bool filled = false;
-
-#if defined(ARCH_NRF52)
-    // The Nordic SDK RNG provides cryptographic-quality randomness backed by hardware.
-    nRFCrypto.begin();
-    auto result = nRFCrypto.Random.generate(buffer, length);
-    nRFCrypto.end();
-    filled = result;
-#elif defined(ARCH_ESP32)
-    // ESP32 exposes a true RNG via esp_fill_random().
-    esp_fill_random(buffer, length);
-    filled = true;
-#elif defined(ARCH_RP2040)
-    // RP2040 has a hardware random number generator accessible through the Arduino core.
-    size_t offset = 0;
-    while (offset < length) {
-        uint32_t value = rp2040.hwrand32();
-        size_t toCopy = std::min(length - offset, sizeof(value));
-        memcpy(buffer + offset, &value, toCopy);
-        offset += toCopy;
-    }
-    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);
-        filled = true;
-    }
-#endif
-
-    if (!filled) {
-        // As a last resort, fall back to std::random_device. This should only be reached
-        // if a platform-specific source was unavailable.
-        fillWithRandomDevice(buffer, length);
-        filled = true;
-    }
-
-#if HAS_RADIO
-    if (useRadioEntropy) {
-        // Best-effort: if the radio is active and can provide modem entropy, XOR it over the
-        // buffer to improve overall quality. We consider the filling a success if either a
-        // good platform RNG or the modem RNG provided data, so we return true as long as at
-        // least one of those steps succeeded.
-        filled = mixWithLoRaEntropy(buffer, length) || filled;
-    }
-#endif
-
-    return filled;
-}
-
-bool seed(uint32_t &seedOut)
-{
-    uint32_t candidate = 0;
-    if (!fill(reinterpret_cast<uint8_t *>(&candidate), sizeof(candidate), true)) {
-        return false;
-    }
-    seedOut = candidate;
-    return true;
-}
-
-} // namespace HardwareRNG

src/mesh/HardwareRNG.h

@@ -1,28 +0,0 @@
-#pragma once
-
-#include <cstddef>
-#include <cstdint>
-
-namespace HardwareRNG
-{
-
-/**
- * Fill the provided buffer with random bytes sourced from the most
- * appropriate hardware-backed RNG available on the current platform.
- *
- * @param buffer Destination buffer for random bytes
- * @param length Number of bytes to write
- * @param useRadioEntropy If true, attempt to mix radio entropy into the output as well.
- * @return true if the buffer was fully populated with entropy, false on failure
- */
-bool fill(uint8_t *buffer, size_t length, bool useRadioEntropy = false);
-
-/**
- * Populate a 32-bit seed value with hardware-backed randomness where possible.
- *
- * @param seedOut Destination for the generated seed value
- * @return true if a seed was produced from a reliable entropy source
- */
-bool seed(uint32_t &seedOut);
-
-} // namespace HardwareRNG

src/mesh/MeshRadio.h

@@ -4,34 +4,6 @@
 #include "MeshTypes.h"
 #include "PointerQueue.h"
 #include "configuration.h"
-#include "detect/LoRaRadioType.h"
-
-// 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
-struct RegionProfile {
-    const meshtastic_Config_LoRaConfig_ModemPreset *presets; // sentinel-terminated; first entry is the default
-    float spacing;                                           // gaps between radio channels
-    float padding;                                           // padding at each side of the "operating channel"
-    bool audioPermitted;
-    bool licensedOnly;        // a region profile for licensed operators only
-    int8_t textThrottle;      // throttle for text - future expansion
-    int8_t positionThrottle;  // throttle for location data - future expansion
-    int8_t telemetryThrottle; // throttle for telemetry - future expansion
-    uint8_t overrideSlot;     // a per-region override slot for if we need to fix it in place
-};
-
-extern const RegionProfile PROFILE_STD;
-extern const RegionProfile PROFILE_EU868;
-extern const RegionProfile PROFILE_UNDEF;
-// extern const RegionProfile  PROFILE_LITE;
-// extern const RegionProfile  PROFILE_NARROW;
-// extern const RegionProfile  PROFILE_HAM;
 
 // Map from old region names to new region enums
 struct RegionInfo {
@@ -53,7 +25,7 @@ extern const RegionInfo *myRegion;
 extern void initRegion();
 
 // Valid LoRa spread factor range and defaults
-constexpr uint8_t LORA_SF_MIN = 5;
+constexpr uint8_t LORA_SF_MIN = 7;
 constexpr uint8_t LORA_SF_MAX = 12;
 constexpr uint8_t LORA_SF_DEFAULT = 11; // LONG_FAST default
 
@@ -65,14 +37,10 @@ constexpr uint8_t LORA_CR_DEFAULT = 5; // LONG_FAST default
 // Default bandwidth in kHz (LONG_FAST)
 constexpr float LORA_BW_DEFAULT_KHZ = 250.0f;
 
-/// Clamp spread factor to the valid LoRa range [5, 12].
+/// Clamp spread factor to the valid LoRa range [7, 12].
 /// Out-of-range values (including 0 from unset preset mode) return LORA_SF_DEFAULT.
 static inline uint8_t clampSpreadFactor(uint8_t sf)
 {
-    // We check for RF95 radios that are incompatible with Spreading Factors 5 and 6.
-    if (radioType == RF95_RADIO && (sf == 5 || sf == 6))
-        return LORA_SF_DEFAULT;
-
     if (sf < LORA_SF_MIN || sf > LORA_SF_MAX)
         return LORA_SF_DEFAULT;
     return sf;

src/mesh/NodeDB.cpp

@@ -688,7 +688,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(HELTEC_V4_R8_TFT)) &&                                           \
+     defined(ELECROW_PANEL) || defined(HELTEC_V4_TFT)) &&                                                                        \
     HAS_TFT
     // switch BT off by default; use TFT programming mode or hotkey to enable
     config.bluetooth.enabled = false;
@@ -1205,11 +1205,11 @@ void NodeDB::loadFromDisk()
     spiLock->unlock();
 #endif
 #ifdef FSCom
-#if defined(FACTORY_INSTALL) && !defined(ARCH_PORTDUINO)
+#ifdef FACTORY_INSTALL
     spiLock->lock();
     if (!FSCom.exists("/prefs/" xstr(BUILD_EPOCH))) {
         LOG_WARN("Factory Install Reset!");
-        rmDir("/prefs");
+        FSCom.format();
         FSCom.mkdir("/prefs");
         File f2 = FSCom.open("/prefs/" xstr(BUILD_EPOCH), FILE_O_WRITE);
         if (f2) {

src/mesh/PhoneAPI.cpp

@@ -512,6 +512,11 @@ 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();
@@ -642,11 +647,9 @@ void PhoneAPI::releaseQueueStatusPhonePacket()
 void PhoneAPI::prefetchNodeInfos()
 {
     bool added = false;
-    bool wasEmpty = false;
     // 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)
@@ -660,15 +663,11 @@ 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 && wasEmpty)
+    if (added)
         onNowHasData(0);
 }
 

src/mesh/PointerQueue.h

@@ -17,4 +17,14 @@ template <class T> class PointerQueue : public TypedQueue<T *>
 
         return this->dequeue(&p, maxWait) ? p : nullptr;
     }
+
+#ifdef HAS_FREE_RTOS
+    // returns a ptr or null if the queue was empty
+    T *dequeuePtrFromISR(BaseType_t *higherPriWoken)
+    {
+        T *p;
+
+        return this->dequeueFromISR(&p, higherPriWoken) ? p : nullptr;
+    }
+#endif
 };

src/mesh/RadioLibInterface.cpp

@@ -109,7 +109,7 @@ bool RadioLibInterface::canSendImmediately()
         return true;
 }
 
-bool RadioLibInterface::receiveDetected(uint16_t irq, unsigned long syncWordHeaderValidFlag, unsigned long preambleDetectedFlag)
+bool RadioLibInterface::receiveDetected(uint16_t irq, ulong syncWordHeaderValidFlag, ulong preambleDetectedFlag)
 {
     bool detected = (irq & (syncWordHeaderValidFlag | preambleDetectedFlag));
     // Handle false detections
@@ -246,24 +246,6 @@ bool RadioLibInterface::findInTxQueue(NodeNum from, PacketId id)
     return txQueue.find(from, id);
 }
 
-bool RadioLibInterface::randomBytes(uint8_t *buffer, size_t length)
-{
-    if (!buffer || length == 0 || !iface) {
-        return false;
-    }
-
-    // Older RadioLib versions only expose random(min, max), so fill the buffer byte-by-byte.
-    for (size_t i = 0; i < length; ++i) {
-        int32_t value = iface->random(0, 255);
-        if (value < 0) {
-            return false;
-        }
-        buffer[i] = static_cast<uint8_t>(value & 0xFF);
-    }
-
-    return true;
-}
-
 /** radio helper thread callback.
 We never immediately transmit after any operation (either Rx or Tx). Instead we should wait a random multiple of
 'slotTimes' (see definition in RadioInterface.h) taken from a contention window (CW) to lower the chance of collision.
@@ -605,4 +587,4 @@ bool RadioLibInterface::startSend(meshtastic_MeshPacket *txp)
 
         return res == RADIOLIB_ERR_NONE;
     }
-}
+}

src/mesh/RadioLibInterface.h

@@ -172,12 +172,6 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified
     /** Attempt to find a packet in the TxQueue. Returns true if the packet was found. */
     virtual bool findInTxQueue(NodeNum from, PacketId id) override;
 
-    /**
-     * Request randomness sourced from the LoRa modem, if supported by the active RadioLib interface.
-     * @return true if len bytes were produced, false otherwise.
-     */
-    bool randomBytes(uint8_t *buffer, size_t length);
-
   private:
     /** if we have something waiting to send, start a short (random) timer so we can come check for collision before actually
      * doing the transmit */
@@ -213,7 +207,7 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified
   protected:
     uint32_t activeReceiveStart = 0;
 
-    bool receiveDetected(uint16_t irq, unsigned long syncWordHeaderValidFlag, unsigned long preambleDetectedFlag);
+    bool receiveDetected(uint16_t irq, ulong syncWordHeaderValidFlag, ulong preambleDetectedFlag);
 
     /** Do any hardware setup needed on entry into send configuration for the radio.
      * Subclasses can customize, but must also call this base method */

src/mesh/Router.cpp

@@ -719,13 +719,9 @@ void Router::handleReceived(meshtastic_MeshPacket *p, RxSource src)
     // Also, we should set the time from the ISR and it should have msec level resolution
     p->rx_time = getValidTime(RTCQualityFromNet); // store the arrival timestamp for the phone
 
-    // Store a copy of the encrypted packet for MQTT.
-    // Local, not a class member: handleReceived re-enters itself when a module
-    // reply broadcast goes through MeshService::sendToMesh -> Router::sendLocal,
-    // and a member would be silently overwritten without release on the inner
-    // call. Each invocation now owns its own copy (issue #9632, #10101, #8729).
+    // Store a copy of encrypted packet for MQTT
     DEBUG_HEAP_BEFORE;
-    meshtastic_MeshPacket *p_encrypted = packetPool.allocCopy(*p);
+    p_encrypted = packetPool.allocCopy(*p);
     DEBUG_HEAP_AFTER("Router::handleReceived", p_encrypted);
 
     // Take those raw bytes and convert them back into a well structured protobuf we can understand
@@ -819,7 +815,8 @@ void Router::handleReceived(meshtastic_MeshPacket *p, RxSource src)
 #endif
     }
 
-    packetPool.release(p_encrypted); // Release the encrypted packet (release() handles nullptr)
+    packetPool.release(p_encrypted); // Release the encrypted packet
+    p_encrypted = nullptr;
 }
 
 void Router::perhapsHandleReceived(meshtastic_MeshPacket *p)

src/mesh/Router.h

@@ -92,6 +92,9 @@ class Router : protected concurrency::OSThread, protected PacketHistory
         before us */
     uint32_t rxDupe = 0, txRelayCanceled = 0;
 
+    // pointer to the encrypted packet
+    meshtastic_MeshPacket *p_encrypted = nullptr;
+
   protected:
     friend class RoutingModule;
 

src/mesh/SX126xInterface.cpp

@@ -448,15 +448,6 @@ template <typename T> void SX126xInterface<T>::resetAGC()
     // RX boosted gain mode
     lora.setRxBoostedGainMode(config.lora.sx126x_rx_boosted_gain);
 
-    // Re-apply the undocumented 0x8B5 RX sensitivity patch that was set in init().
-    // The CALIBRATE_ALL (0x7F) command above clears bit 0 of register 0x8B5, which
-    // silently removes the RX sensitivity improvement introduced in #9571 / #9777.
-    // Without this re-apply, every SX1262 node loses its RX boost ~60s after boot
-    // and never recovers until reboot. See empirical evidence in the PR description.
-    if (module.SPIsetRegValue(0x8B5, 0x01, 0, 0) != RADIOLIB_ERR_NONE) {
-        LOG_WARN("SX126x resetAGC: failed to re-apply 0x8B5 RX sensitivity patch");
-    }
-
     // 6. Resume receiving
     startReceive();
 }

src/mesh/TypeConversions.cpp

@@ -1,7 +1,6 @@
 #include "TypeConversions.h"
 #include "mesh/generated/meshtastic/deviceonly.pb.h"
 #include "mesh/generated/meshtastic/mesh.pb.h"
-#include "meshUtils.h"
 
 meshtastic_NodeInfo TypeConversions::ConvertToNodeInfo(const meshtastic_NodeInfoLite *lite)
 {
@@ -82,11 +81,7 @@ meshtastic_UserLite TypeConversions::ConvertToUserLite(meshtastic_User user)
     meshtastic_UserLite lite = meshtastic_UserLite_init_default;
 
     strncpy(lite.long_name, user.long_name, sizeof(lite.long_name));
-    lite.long_name[sizeof(lite.long_name) - 1] = '\0';
-    sanitizeUtf8(lite.long_name, sizeof(lite.long_name));
     strncpy(lite.short_name, user.short_name, sizeof(lite.short_name));
-    lite.short_name[sizeof(lite.short_name) - 1] = '\0';
-    sanitizeUtf8(lite.short_name, sizeof(lite.short_name));
     lite.hw_model = user.hw_model;
     lite.role = user.role;
     lite.is_licensed = user.is_licensed;
@@ -104,11 +99,7 @@ meshtastic_User TypeConversions::ConvertToUser(uint32_t nodeNum, meshtastic_User
 
     snprintf(user.id, sizeof(user.id), "!%08x", nodeNum);
     strncpy(user.long_name, lite.long_name, sizeof(user.long_name));
-    user.long_name[sizeof(user.long_name) - 1] = '\0';
-    sanitizeUtf8(user.long_name, sizeof(user.long_name));
     strncpy(user.short_name, lite.short_name, sizeof(user.short_name));
-    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;

src/mesh/generated/meshtastic/apponly.pb.h

@@ -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               685
+#define meshtastic_ChannelSet_size               682
 
 #ifdef __cplusplus
 } /* extern "C" */

src/mesh/generated/meshtastic/config.pb.h

@@ -285,18 +285,7 @@ typedef enum _meshtastic_Config_LoRaConfig_RegionCode {
     /* Nepal 865MHz */
     meshtastic_Config_LoRaConfig_RegionCode_NP_865 = 25,
     /* Brazil 902MHz */
-    meshtastic_Config_LoRaConfig_RegionCode_BR_902 = 26,
-    /* ITU Region 1 Amateur Radio 2m band (144-146 MHz) */
-    meshtastic_Config_LoRaConfig_RegionCode_ITU1_2M = 27,
-    /* ITU Region 2 / 3 Amateur Radio 2m band (144-148 MHz) */
-    meshtastic_Config_LoRaConfig_RegionCode_ITU23_2M = 28,
-    /* EU 866MHz band (Band no. 47b of 2006/771/EC and subsequent amendments) for Non-specific short-range devices (SRD) */
-    meshtastic_Config_LoRaConfig_RegionCode_EU_866 = 29,
-    /* EU 874MHz and 917MHz bands (Band no. 1 and 4 of 2022/172/EC and subsequent amendments) for Non-specific short-range devices (SRD) */
-    meshtastic_Config_LoRaConfig_RegionCode_EU_874 = 30,
-    meshtastic_Config_LoRaConfig_RegionCode_EU_917 = 31,
-    /* EU 868MHz band, with narrow presets */
-    meshtastic_Config_LoRaConfig_RegionCode_EU_N_868 = 32
+    meshtastic_Config_LoRaConfig_RegionCode_BR_902 = 26
 } meshtastic_Config_LoRaConfig_RegionCode;
 
 /* Standard predefined channel settings
@@ -326,24 +315,7 @@ typedef enum _meshtastic_Config_LoRaConfig_ModemPreset {
     meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO = 8,
     /* Long Range - Turbo
  This preset performs similarly to LongFast, but with 500Khz bandwidth. */
-    meshtastic_Config_LoRaConfig_ModemPreset_LONG_TURBO = 9,
-    /* Lite Fast
- Medium range preset optimized for EU 866MHz SRD band with 125kHz bandwidth.
- Comparable link budget to MEDIUM_FAST but compliant with Band no. 47b of 2006/771/EC. */
-    meshtastic_Config_LoRaConfig_ModemPreset_LITE_FAST = 10,
-    /* Lite Slow
- Medium-to-moderate range preset optimized for EU 866MHz SRD band with 125kHz bandwidth.
- Comparable link budget to LONG_FAST but compliant with Band no. 47b of 2006/771/EC. */
-    meshtastic_Config_LoRaConfig_ModemPreset_LITE_SLOW = 11,
-    /* Narrow Fast
- Medium-to-moderate range preset optimized for EU 868MHz band with 62.5kHz bandwidth.
- Comparable link budget to SHORT_SLOW, but with half the data rate.
- Intended to avoid interference with other devices. */
-    meshtastic_Config_LoRaConfig_ModemPreset_NARROW_FAST = 12,
-    /* Narrow Slow
- Moderate range preset optimized for EU 868MHz band with 62.5kHz bandwidth.
- Comparable link budget and data rate to LONG_FAST. */
-    meshtastic_Config_LoRaConfig_ModemPreset_NARROW_SLOW = 13
+    meshtastic_Config_LoRaConfig_ModemPreset_LONG_TURBO = 9
 } meshtastic_Config_LoRaConfig_ModemPreset;
 
 typedef enum _meshtastic_Config_LoRaConfig_FEM_LNA_Mode {
@@ -618,8 +590,6 @@ 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 {
@@ -732,12 +702,12 @@ extern "C" {
 #define _meshtastic_Config_DisplayConfig_CompassOrientation_ARRAYSIZE ((meshtastic_Config_DisplayConfig_CompassOrientation)(meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_270_INVERTED+1))
 
 #define _meshtastic_Config_LoRaConfig_RegionCode_MIN meshtastic_Config_LoRaConfig_RegionCode_UNSET
-#define _meshtastic_Config_LoRaConfig_RegionCode_MAX meshtastic_Config_LoRaConfig_RegionCode_EU_N_868
-#define _meshtastic_Config_LoRaConfig_RegionCode_ARRAYSIZE ((meshtastic_Config_LoRaConfig_RegionCode)(meshtastic_Config_LoRaConfig_RegionCode_EU_N_868+1))
+#define _meshtastic_Config_LoRaConfig_RegionCode_MAX meshtastic_Config_LoRaConfig_RegionCode_BR_902
+#define _meshtastic_Config_LoRaConfig_RegionCode_ARRAYSIZE ((meshtastic_Config_LoRaConfig_RegionCode)(meshtastic_Config_LoRaConfig_RegionCode_BR_902+1))
 
 #define _meshtastic_Config_LoRaConfig_ModemPreset_MIN meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST
-#define _meshtastic_Config_LoRaConfig_ModemPreset_MAX meshtastic_Config_LoRaConfig_ModemPreset_NARROW_SLOW
-#define _meshtastic_Config_LoRaConfig_ModemPreset_ARRAYSIZE ((meshtastic_Config_LoRaConfig_ModemPreset)(meshtastic_Config_LoRaConfig_ModemPreset_NARROW_SLOW+1))
+#define _meshtastic_Config_LoRaConfig_ModemPreset_MAX meshtastic_Config_LoRaConfig_ModemPreset_LONG_TURBO
+#define _meshtastic_Config_LoRaConfig_ModemPreset_ARRAYSIZE ((meshtastic_Config_LoRaConfig_ModemPreset)(meshtastic_Config_LoRaConfig_ModemPreset_LONG_TURBO+1))
 
 #define _meshtastic_Config_LoRaConfig_FEM_LNA_Mode_MIN meshtastic_Config_LoRaConfig_FEM_LNA_Mode_DISABLED
 #define _meshtastic_Config_LoRaConfig_FEM_LNA_Mode_MAX meshtastic_Config_LoRaConfig_FEM_LNA_Mode_NOT_PRESENT
@@ -781,7 +751,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, 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_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}
@@ -792,7 +762,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, 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_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}
@@ -879,7 +849,6 @@ 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
@@ -1032,8 +1001,7 @@ 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, BOOL,     serial_hal_only, 107)
+X(a, STATIC,   SINGULAR, UENUM,    fem_lna_mode,    106)
 #define meshtastic_Config_LoRaConfig_CALLBACK NULL
 #define meshtastic_Config_LoRaConfig_DEFAULT NULL
 
@@ -1090,7 +1058,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        91
+#define meshtastic_Config_LoRaConfig_size        88
 #define meshtastic_Config_NetworkConfig_IpV4Config_size 20
 #define meshtastic_Config_NetworkConfig_size     204
 #define meshtastic_Config_PositionConfig_size    62

src/mesh/generated/meshtastic/deviceonly.pb.h

@@ -361,7 +361,7 @@ 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        2432
+#define meshtastic_BackupPreferences_size        2429
 #define meshtastic_ChannelFile_size              718
 #define meshtastic_DeviceState_size              1737
 #define meshtastic_NodeInfoLite_size             196

src/mesh/generated/meshtastic/localonly.pb.h

@@ -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              757
+#define meshtastic_LocalConfig_size              754
 #define meshtastic_LocalModuleConfig_size        820
 
 #ifdef __cplusplus

src/mesh/generated/meshtastic/mesh.pb.h

@@ -315,8 +315,6 @@ typedef enum _meshtastic_HardwareModel {
     meshtastic_HardwareModel_THINKNODE_M7 = 129,
     meshtastic_HardwareModel_THINKNODE_M8 = 130,
     meshtastic_HardwareModel_THINKNODE_M9 = 131,
-    /* The Heltec-V4-R8 uses an ESP32S3R8 chip, plus an SX1262. */
-    meshtastic_HardwareModel_HELTEC_V4_R8 = 132,
     /* ------------------------------------------------------------------------------------------------------------------------------------------
  Reserved ID For developing private Ports. These will show up in live traffic sparsely, so we can use a high number. Keep it within 8 bits.
  ------------------------------------------------------------------------------------------------------------------------------------------ */

src/mesh/generated/meshtastic/serial_hal.pb.cpp

@@ -1,19 +0,0 @@
-/* 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)
-
-
-
-
-
-
-

src/mesh/generated/meshtastic/serial_hal.pb.h

@@ -1,135 +0,0 @@
-/* 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

src/meshUtils.cpp

@@ -117,93 +117,4 @@ size_t pb_string_length(const char *str, size_t max_len)
         }
     }
     return len;
-}
-
-bool sanitizeUtf8(char *buf, size_t bufSize)
-{
-    if (!buf || bufSize == 0)
-        return false;
-
-    // Ensure null-terminated within buffer; report if we had to enforce it
-    bool replaced = (buf[bufSize - 1] != '\0');
-    buf[bufSize - 1] = '\0';
-
-    size_t i = 0;
-    size_t len = strlen(buf);
-
-    while (i < len) {
-        uint8_t b = (uint8_t)buf[i];
-
-        // Determine expected sequence length from lead byte
-        size_t seqLen;
-        uint32_t minCodepoint;
-        if (b <= 0x7F) {
-            // ASCII — valid single byte
-            i++;
-            continue;
-        } else if ((b & 0xE0) == 0xC0) {
-            seqLen = 2;
-            minCodepoint = 0x80; // Reject overlong
-        } else if ((b & 0xF0) == 0xE0) {
-            seqLen = 3;
-            minCodepoint = 0x800;
-        } else if ((b & 0xF8) == 0xF0) {
-            seqLen = 4;
-            minCodepoint = 0x10000;
-        } else {
-            // Invalid lead byte (0x80-0xBF or 0xF8+)
-            buf[i] = '?';
-            replaced = true;
-            i++;
-            continue;
-        }
-
-        // Check that we have enough bytes remaining
-        if (i + seqLen > len) {
-            // Truncated sequence at end of string — replace remaining bytes
-            for (size_t j = i; j < len; j++) {
-                buf[j] = '?';
-            }
-            replaced = true;
-            break;
-        }
-
-        // Validate continuation bytes (must be 10xxxxxx)
-        bool valid = true;
-        for (size_t j = 1; j < seqLen; j++) {
-            if (((uint8_t)buf[i + j] & 0xC0) != 0x80) {
-                valid = false;
-                break;
-            }
-        }
-
-        if (valid) {
-            // Decode codepoint to check for overlong encodings and surrogates
-            uint32_t cp = 0;
-            if (seqLen == 2)
-                cp = b & 0x1F;
-            else if (seqLen == 3)
-                cp = b & 0x0F;
-            else
-                cp = b & 0x07;
-            for (size_t j = 1; j < seqLen; j++)
-                cp = (cp << 6) | ((uint8_t)buf[i + j] & 0x3F);
-
-            if (cp < minCodepoint || cp > 0x10FFFF || (cp >= 0xD800 && cp <= 0xDFFF)) {
-                // Overlong encoding, out of Unicode range, or surrogate half
-                valid = false;
-            }
-        }
-
-        if (valid) {
-            i += seqLen;
-        } else {
-            // Replace only the lead byte; continuation bytes will be caught on next iteration
-            buf[i] = '?';
-            replaced = true;
-            i++;
-        }
-    }
-
-    return replaced;
 }

src/meshUtils.h

@@ -38,10 +38,6 @@ const std::string vformat(const char *const zcFormat, ...);
 // Get actual string length for nanopb char array fields.
 size_t pb_string_length(const char *str, size_t max_len);
 
-// Sanitize a fixed-size char buffer in-place by replacing invalid UTF-8 sequences with '?'.
-// Ensures the result is null-terminated within bufSize. Returns true if any bytes were replaced.
-bool sanitizeUtf8(char *buf, size_t bufSize);
-
 /// Calculate 2^n without calling pow() - used for spreading factor and other calculations
 inline uint32_t pow_of_2(uint32_t n)
 {

src/modules/AdminModule.cpp

@@ -599,14 +599,10 @@ void AdminModule::handleSetOwner(const meshtastic_User &o)
     if (*o.long_name) {
         changed |= strcmp(owner.long_name, o.long_name);
         strncpy(owner.long_name, o.long_name, sizeof(owner.long_name));
-        owner.long_name[sizeof(owner.long_name) - 1] = '\0';
-        sanitizeUtf8(owner.long_name, sizeof(owner.long_name));
     }
     if (*o.short_name) {
         changed |= strcmp(owner.short_name, o.short_name);
         strncpy(owner.short_name, o.short_name, sizeof(owner.short_name));
-        owner.short_name[sizeof(owner.short_name) - 1] = '\0';
-        sanitizeUtf8(owner.short_name, sizeof(owner.short_name));
     }
     snprintf(owner.id, sizeof(owner.id), "!%08x", nodeDB->getNodeNum());
 
@@ -1404,11 +1400,7 @@ void AdminModule::handleSetHamMode(const meshtastic_HamParameters &p)
 
     // Set call sign and override lora limitations for licensed use
     strncpy(owner.long_name, p.call_sign, sizeof(owner.long_name));
-    owner.long_name[sizeof(owner.long_name) - 1] = '\0';
-    sanitizeUtf8(owner.long_name, sizeof(owner.long_name));
     strncpy(owner.short_name, p.short_name, sizeof(owner.short_name));
-    owner.short_name[sizeof(owner.short_name) - 1] = '\0';
-    sanitizeUtf8(owner.short_name, sizeof(owner.short_name));
     owner.is_licensed = true;
     config.lora.override_duty_cycle = true;
     config.lora.tx_power = p.tx_power;

src/mqtt/MQTT.cpp

@@ -32,7 +32,7 @@
 #include <assert.h>
 #include <utility>
 
-#include "IPAddress.h"
+#include <IPAddress.h>
 #if defined(ARCH_PORTDUINO)
 #include <netinet/in.h>
 #elif !defined(ntohl)

src/platform/nrf52/NRF52Bluetooth.cpp

@@ -1,7 +1,6 @@
 #include "NRF52Bluetooth.h"
 #include "BLEDfuSecure.h"
 #include "BluetoothCommon.h"
-#include "HardwareRNG.h"
 #include "PowerFSM.h"
 #include "configuration.h"
 #include "main.h"
@@ -273,13 +272,9 @@ void NRF52Bluetooth::setup()
     Bluefruit.setTxPower(NRF52_BLE_TX_POWER);
 #endif
     if (config.bluetooth.mode != meshtastic_Config_BluetoothConfig_PairingMode_NO_PIN) {
-        if (config.bluetooth.mode == meshtastic_Config_BluetoothConfig_PairingMode_FIXED_PIN) {
-            configuredPasskey = config.bluetooth.fixed_pin;
-        } else {
-            uint32_t hwrand = 0;
-            HardwareRNG::fill(reinterpret_cast<uint8_t *>(&hwrand), sizeof(hwrand));
-            configuredPasskey = hwrand % 900000u + 100000u;
-        }
+        configuredPasskey = config.bluetooth.mode == meshtastic_Config_BluetoothConfig_PairingMode_FIXED_PIN
+                                ? config.bluetooth.fixed_pin
+                                : random(100000, 999999);
         auto pinString = std::to_string(configuredPasskey);
         LOG_INFO("Bluetooth pin set to '%i'", configuredPasskey);
         Bluefruit.Security.setPIN(pinString.c_str());

src/platform/nrf52/main-nrf52.cpp

@@ -17,7 +17,6 @@
 #include <nrfx_wdt.h>
 #include <stdio.h>
 // #include <Adafruit_USBD_Device.h>
-#include "HardwareRNG.h"
 #include "NodeDB.h"
 #include "PowerMon.h"
 #include "error.h"
@@ -399,14 +398,15 @@ void nrf52Setup()
 #endif
 
     // Init random seed
-    uint32_t seed = 0;
-    if (!HardwareRNG::seed(seed)) {
-        LOG_WARN("Hardware RNG seed unavailable, using PRNG fallback");
-        // Use a hardware timer value as a fallback seed for better entropy
-        seed = micros();
-    }
-    LOG_DEBUG("Set random seed %u", seed);
-    randomSeed(seed);
+    union seedParts {
+        uint32_t seed32;
+        uint8_t seed8[4];
+    } seed;
+    nRFCrypto.begin();
+    nRFCrypto.Random.generate(seed.seed8, sizeof(seed.seed8));
+    LOG_DEBUG("Set random seed %u", seed.seed32);
+    randomSeed(seed.seed32);
+    nRFCrypto.end();
 
     // Set up nrfx watchdog. Do not enable the watchdog yet (we do that
     // the first time through the main loop), so that other threads can

src/platform/portduino/PortduinoGlue.cpp

@@ -1,5 +1,4 @@
 #include "CryptoEngine.h"
-#include "HardwareRNG.h"
 #include "PortduinoGPIO.h"
 #include "SPIChip.h"
 #include "mesh/RF95Interface.h"
@@ -9,11 +8,13 @@
 #include "PortduinoGlue.h"
 #include "SHA256.h"
 #include "api/ServerAPI.h"
+#include "linux/gpio/LinuxGPIOPin.h"
 #include "meshUtils.h"
 #include <ErriezCRC32.h>
 #include <Utility.h>
 #include <assert.h>
-#include <cctype>
+#include <bluetooth/bluetooth.h>
+#include <bluetooth/hci.h>
 #include <filesystem>
 #include <fstream>
 #include <iostream>
@@ -23,12 +24,6 @@
 #include <sys/ioctl.h>
 #include <unistd.h>
 
-#ifdef PORTDUINO_LINUX_HARDWARE
-#include "linux/gpio/LinuxGPIOPin.h"
-#include <bluetooth/bluetooth.h>
-#include <bluetooth/hci.h>
-#endif
-
 #ifdef PORTDUINO_LINUX_HARDWARE
 #include <cxxabi.h>
 #endif
@@ -134,9 +129,9 @@ void getMacAddr(uint8_t *dmac)
         }
     } else if (portduino_config.mac_address.length() > 11) {
         MAC_from_string(portduino_config.mac_address, dmac);
-        return;
+        exit;
     } else {
-#ifdef PORTDUINO_LINUX_HARDWARE
+
         struct hci_dev_info di = {0};
         di.dev_id = 0;
         bdaddr_t bdaddr;
@@ -156,11 +151,6 @@ void getMacAddr(uint8_t *dmac)
         dmac[3] = di.bdaddr.b[2];
         dmac[4] = di.bdaddr.b[1];
         dmac[5] = di.bdaddr.b[0];
-#else
-        // No BlueZ on non-Linux hosts (e.g. macOS). Leave dmac at its default;
-        // the caller can override via the --hwid CLI flag or the YAML config.
-        (void)dmac;
-#endif
     }
 }
 
@@ -243,9 +233,7 @@ void portduinoSetup()
         std::cout << "Running in simulated mode." << std::endl;
         portduino_config.MaxNodes = 200; // Default to 200 nodes
         // Set the random seed equal to TCPPort to have a different seed per instance
-        uint32_t seed = TCPPort;
-        HardwareRNG::seed(seed);
-        randomSeed(seed);
+        randomSeed(TCPPort);
         return;
     }
 
@@ -491,17 +479,10 @@ void portduinoSetup()
             exit(EXIT_FAILURE);
         }
         char serial[9] = {0};
-        // Pass the full buffer size (9 = 8 chars + null) to getSerialString,
-        // not 8. The function treats `len` as buffer size and reserves one
-        // slot for the null terminator, so passing 8 produced a 7-char serial
-        // and broke the `strlen(serial) == 8` check below — masked on Linux
-        // by the BlueZ HCI MAC fallback in getMacAddr(), but on macOS (where
-        // the BlueZ path is __linux__-guarded) it left mac_address empty and
-        // meshtasticd refused to start.
-        ch341Hal->getSerialString(serial, sizeof(serial));
+        ch341Hal->getSerialString(serial, 8);
         std::cout << "CH341 Serial " << serial << std::endl;
         char product_string[96] = {0};
-        ch341Hal->getProductString(product_string, sizeof(product_string));
+        ch341Hal->getProductString(product_string, 95);
         std::cout << "CH341 Product " << product_string << std::endl;
         if (strlen(serial) == 8 && portduino_config.mac_address.length() < 12) {
             std::cout << "Deriving MAC address from Serial and Product String" << std::endl;
@@ -531,9 +512,7 @@ void portduinoSetup()
 #endif
     printf("MAC ADDRESS: %02X:%02X:%02X:%02X:%02X:%02X\n", dmac[0], dmac[1], dmac[2], dmac[3], dmac[4], dmac[5]);
     // Rather important to set this, if not running simulated.
-    uint32_t seed = static_cast<uint32_t>(time(NULL));
-    HardwareRNG::seed(seed);
-    randomSeed(seed);
+    randomSeed(time(NULL));
 
     std::string defaultGpioChipName = gpioChipName + std::to_string(portduino_config.lora_default_gpiochip);
 
@@ -666,9 +645,7 @@ void portduinoSetup()
     if (verboseEnabled && portduino_config.logoutputlevel != level_trace) {
         portduino_config.logoutputlevel = level_debug;
     }
-    if (portduino_config.lora_spi_dev != "") {
-        portduinoSetOptions({.realHardware = true});
-    }
+
     return;
 }
 
@@ -1053,31 +1030,17 @@ static bool ends_with(std::string_view str, std::string_view suffix)
 bool MAC_from_string(std::string mac_str, uint8_t *dmac)
 {
     mac_str.erase(std::remove(mac_str.begin(), mac_str.end(), ':'), mac_str.end());
-    if (mac_str.length() != 12) {
+    if (mac_str.length() == 12) {
+        dmac[0] = std::stoi(portduino_config.mac_address.substr(0, 2), nullptr, 16);
+        dmac[1] = std::stoi(portduino_config.mac_address.substr(2, 2), nullptr, 16);
+        dmac[2] = std::stoi(portduino_config.mac_address.substr(4, 2), nullptr, 16);
+        dmac[3] = std::stoi(portduino_config.mac_address.substr(6, 2), nullptr, 16);
+        dmac[4] = std::stoi(portduino_config.mac_address.substr(8, 2), nullptr, 16);
+        dmac[5] = std::stoi(portduino_config.mac_address.substr(10, 2), nullptr, 16);
+        return true;
+    } else {
         return false;
     }
-    // Validate every character is a hex digit before parsing. std::stoi
-    // would otherwise skip leading whitespace and silently truncate at the
-    // first non-digit, which is too lenient for a MAC address.
-    for (char c : mac_str) {
-        if (!isxdigit(static_cast<unsigned char>(c))) {
-            return false;
-        }
-    }
-    // Parse into a temporary so dmac is not partially modified if a later
-    // byte fails. At least one caller in getMacAddr() ignores the bool
-    // return, so leaving stale bytes in dmac on failure would silently
-    // produce a wrong MAC.
-    uint8_t tmp[6];
-    try {
-        for (int i = 0; i < 6; i++) {
-            tmp[i] = static_cast<uint8_t>(std::stoi(mac_str.substr(i * 2, 2), nullptr, 16));
-        }
-    } catch (const std::exception &) {
-        return false;
-    }
-    memcpy(dmac, tmp, 6);
-    return true;
 }
 
 std::string exec(const char *cmd)

src/platform/portduino/USBHal.h

@@ -5,7 +5,6 @@
 #include "platform/portduino/PortduinoGlue.h"
 #include <RadioLib.h>
 #include <csignal>
-#include <cstring>
 #include <iostream>
 #include <libpinedio-usb.h>
 #include <unistd.h>
@@ -35,7 +34,7 @@ class Ch341Hal : public RadioLibHal
         : RadioLibHal(PI_INPUT, PI_OUTPUT, PI_LOW, PI_HIGH, PI_RISING, PI_FALLING)
     {
         if (serial != "") {
-            std::strncpy(pinedio.serial_number, serial.c_str(), 8);
+            strncpy(pinedio.serial_number, serial.c_str(), 8);
             pinedio_set_option(&pinedio, PINEDIO_OPTION_SEARCH_SERIAL, 1);
         }
         // LOG_INFO("USB Serial: %s", pinedio.serial_number);
@@ -60,11 +59,8 @@ class Ch341Hal : public RadioLibHal
 
     void getSerialString(char *_serial, size_t len)
     {
-        if (len == 0)
-            return;
-        size_t bytesCopied = (len - 1) < 8 ? (len - 1) : 8;
-        std::strncpy(_serial, pinedio.serial_number, bytesCopied);
-        _serial[bytesCopied] = '\0';
+        len = len > 8 ? 8 : len;
+        strncpy(_serial, pinedio.serial_number, len);
     }
 
     void getProductString(char *_product_string, size_t len)

src/platform/rp2xx0/main-rp2xx0.cpp

@@ -1,4 +1,3 @@
-#include "HardwareRNG.h"
 #include "configuration.h"
 #include "hardware/xosc.h"
 #include <hardware/clocks.h>
@@ -99,12 +98,10 @@ void getMacAddr(uint8_t *dmac)
 
 void rp2040Setup()
 {
-    /* Sets a random seed to make sure we get different random numbers on each boot. */
-    uint32_t seed = 0;
-    if (!HardwareRNG::seed(seed)) {
-        seed = rp2040.hwrand32();
-    }
-    randomSeed(seed);
+    /* Sets a random seed to make sure we get different random numbers on each boot.
+       Taken from CPU cycle counter and ROSC oscillator, so should be pretty random.
+    */
+    randomSeed(rp2040.hwrand32());
 
 #ifdef RP2040_SLOW_CLOCK
     uint f_pll_sys = frequency_count_khz(CLOCKS_FC0_SRC_VALUE_PLL_SYS_CLKSRC_PRIMARY);

src/power.h

@@ -81,7 +81,7 @@ extern RAK9154Sensor rak9154Sensor;
 extern XPowersLibInterface *PMU;
 #endif
 
-class Power : public concurrency::OSThread
+class Power : private concurrency::OSThread
 {
 
   public:
@@ -96,14 +96,6 @@ class Power : public concurrency::OSThread
     void setStatusHandler(meshtastic::PowerStatus *handler) { statusHandler = handler; }
     const uint16_t OCV[11] = {OCV_ARRAY};
 
-#ifdef ARCH_ESP32
-    int beforeLightSleep(void *unused);
-    int afterLightSleep(esp_sleep_wakeup_cause_t cause);
-#endif
-
-    void attachPowerInterrupts();
-    void detachPowerInterrupts();
-
   protected:
     meshtastic::PowerStatus *statusHandler;
 
@@ -128,14 +120,6 @@ class Power : public concurrency::OSThread
     // open circuit voltage lookup table
     uint8_t low_voltage_counter;
     uint32_t lastLogTime = 0;
-
-#ifdef ARCH_ESP32
-    // Get notified when lightsleep begins and ends
-    CallbackObserver<Power, void *> lsObserver = CallbackObserver<Power, void *>(this, &Power::beforeLightSleep);
-    CallbackObserver<Power, esp_sleep_wakeup_cause_t> lsEndObserver =
-        CallbackObserver<Power, esp_sleep_wakeup_cause_t>(this, &Power::afterLightSleep);
-#endif
-
 #ifdef DEBUG_HEAP
     uint32_t lastheap;
 #endif

src/sleep.cpp

@@ -497,12 +497,13 @@ esp_sleep_wakeup_cause_t doLightSleep(uint64_t sleepMsec) // FIXME, use a more r
     esp_sleep_wakeup_cause_t cause = esp_sleep_get_wakeup_cause();
     notifyLightSleepEnd.notifyObservers(cause); // Button interrupts are reattached here
 
+#ifdef BUTTON_PIN
     if (cause == ESP_SLEEP_WAKEUP_GPIO) {
-        LOG_INFO("Exit light sleep gpio");
-        // If we woke because of a GPIO, it's possible power needs to run to handle.
-        power->setIntervalFromNow(0);
-        runASAP = true;
-    } else {
+        LOG_INFO("Exit light sleep gpio: btn=%d",
+                 !digitalRead(config.device.button_gpio ? config.device.button_gpio : BUTTON_PIN));
+    } else
+#endif
+    {
         LOG_INFO("Exit light sleep cause: %d", cause);
     }
 

test/README.md

@@ -1,322 +0,0 @@
-# Native Unit Tests — Authoring Guide
-
-This directory contains C++ unit tests that run on the host machine via PlatformIO's native environment. Tests use the [Unity](http://www.throwtheswitch.org/unity) framework.
-
-## Running Tests
-
-```bash
-# All test suites
-pio test -e native
-
-# Single suite
-pio test -e native -f test_your_module
-
-# Verbose (shows build errors in detail)
-pio test -e native -f test_your_module -vvv
-```
-
-### Helper Scripts (Useful Shortcuts)
-
-These wrappers are handy when local host dependencies are missing or when you want repeatable commands.
-
-```bash
-# Run native tests in Docker (recommended on macOS / non-Linux hosts)
-./bin/test-native-docker.sh
-
-# Pass normal PlatformIO test args through to Dockerized test run
-./bin/test-native-docker.sh -f test_your_module
-
-# Force Docker image rebuild (after dependency changes)
-./bin/test-native-docker.sh --rebuild
-
-# Run simulator integration check (build native first)
-pio run -e native && ./bin/test-simulator.sh
-
-# Build and run meshtasticd natively
-./bin/native-run.sh
-
-# Build and run under gdbserver on localhost:2345
-./bin/native-gdbserver.sh
-
-# Build native release artifact into ./release/
-./bin/build-native.sh native
-```
-
-Notes:
-
-- The repository script name is `./bin/test-simulator.sh` (there is no `test-native-simulator.sh`).
-- `./bin/test-native-docker.sh` is the closest match to CI behavior for native tests and avoids host package setup.
-
-### System Dependencies (Ubuntu/Debian)
-
-The native build requires several system libraries. Install them all at once:
-
-```bash
-sudo apt-get install -y \
-  libbluetooth-dev libgpiod-dev libyaml-cpp-dev openssl libssl-dev \
-  libulfius-dev liborcania-dev libusb-1.0-0-dev libi2c-dev libuv1-dev
-```
-
-See `.github/actions/setup-native/action.yml` for the canonical list.
-
-## Creating a New Test Suite
-
-### 1. Directory Structure
-
-```text
-test/test_your_module/test_main.cpp
-```
-
-One file per suite. No per-test `platformio.ini` is needed — tests build under the `[env:native]` environment defined in the root `platformio.ini`.
-
-### 2. File Skeleton
-
-```cpp
-#include "MeshTypes.h"      // Include BEFORE TestUtil.h (provides NodeNum, etc.)
-#include "TestUtil.h"        // initializeTestEnvironment(), testDelay()
-#include <unity.h>
-
-#if YOUR_FEATURE_GUARD       // Same #if guard as the module under test
-
-#include "FSCommon.h"
-#include "gps/RTC.h"
-#include "mesh/NodeDB.h"
-#include "modules/YourModule.h"
-#include <cstdio>
-#include <cstring>
-#include <memory>
-
-// --- Test output helpers ---
-// Unity swallows printf/stdout. Only TEST_MESSAGE() output appears in results.
-#define MSG_BUF_LEN 200
-#define TEST_MSG_FMT(fmt, ...) do { \
-    char _buf[MSG_BUF_LEN]; \
-    snprintf(_buf, sizeof(_buf), fmt, __VA_ARGS__); \
-    TEST_MESSAGE(_buf); \
-} while(0)
-
-// --- Tests ---
-
-void test_example()
-{
-    TEST_MESSAGE("=== Example test ===");
-    TEST_ASSERT_TRUE(true);
-}
-
-// --- Unity lifecycle ---
-
-void setUp(void) { /* runs before every test */ }
-void tearDown(void) { /* runs after every test */ }
-
-void setup()
-{
-    initializeTestEnvironment();   // MUST call — sets up RTC, OSThread, console
-    UNITY_BEGIN();
-    RUN_TEST(test_example);
-    exit(UNITY_END());             // exit() required — Unity runner expects it
-}
-
-void loop() {}
-
-#else // !YOUR_FEATURE_GUARD
-
-void setUp(void) {}
-void tearDown(void) {}
-
-void setup()
-{
-    initializeTestEnvironment();
-    UNITY_BEGIN();
-    exit(UNITY_END());
-}
-
-void loop() {}
-
-#endif
-```
-
-### 3. Feature Guard
-
-Wrap the entire test body in the same `#if` guard the module uses (e.g. `#if HAS_VARIABLE_HOPS`, `#if !MESHTASTIC_EXCLUDE_GPS`). When the feature is disabled, the `#else` branch produces an empty passing suite.
-
-## Common Patterns
-
-### MockNodeDB
-
-Most module tests need to inject nodes with controlled hop distances and ages:
-
-```cpp
-class MockNodeDB : public NodeDB
-{
-  public:
-    void clearTestNodes()
-    {
-        testNodes.clear();
-        numMeshNodes = 0;
-    }
-
-    void addTestNode(NodeNum num, uint8_t hopsAway, bool hasHops,
-                     uint32_t ageSecs, bool viaMqtt = false)
-    {
-        meshtastic_NodeInfoLite node = meshtastic_NodeInfoLite_init_zero;
-        node.num = num;
-        node.has_hops_away = hasHops;
-        node.hops_away = hopsAway;
-        node.via_mqtt = viaMqtt;
-        node.last_heard = getTime() - ageSecs;
-        testNodes.push_back(node);
-        meshNodes = &testNodes;
-        numMeshNodes = testNodes.size();
-    }
-
-    std::vector<meshtastic_NodeInfoLite> testNodes;
-};
-
-static MockNodeDB *mockNodeDB = nullptr;
-```
-
-Set `nodeDB = mockNodeDB;` in `setUp()`.
-
-### Test Shim (Exposing Protected/Private Members)
-
-Subclass the module under test to make protected methods callable and private members writable:
-
-```cpp
-class YourModuleTestShim : public YourModule
-{
-  public:
-    // Expose protected methods
-    using YourModule::runOnce;
-    using YourModule::someProtectedMethod;
-
-    // Access private members via friend (see below)
-    void setPrivateField(int x) { privateField = x; }
-};
-```
-
-In the module header, grant friend access under the `UNIT_TEST` define (set automatically by PlatformIO's test framework):
-
-```cpp
-// In YourModule.h, inside the class body:
-#ifdef UNIT_TEST
-    friend class YourModuleTestShim;
-#endif
-```
-
-### Global Singleton Lifecycle
-
-Most modules use a global pointer (`extern YourModule *yourModule;`). Manage it carefully:
-
-```cpp
-void setUp(void) {
-    // ... setup ...
-}
-
-void tearDown(void) {
-    yourModule = nullptr;   // prevent dangling pointer between tests
-}
-
-void test_something() {
-    auto shim = std::unique_ptr<YourModuleTestShim>(new YourModuleTestShim());
-    yourModule = shim.get();
-    // ... test ...
-    yourModule = nullptr;
-}
-```
-
-## Pitfalls and How to Avoid Them
-
-### 1. Persisted Filesystem State Leaks Between Tests
-
-Modules that save state to `/prefs/*.bin` will have that state loaded by the next test's constructor via `loadState()`. This causes values from one test (e.g. rolling averages from a megamesh scenario) to bleed into unrelated tests.
-
-**Fix:** Delete state files at the start of `setUp()`:
-
-```cpp
-void setUp(void) {
-    // ...
-#ifdef FSCom
-    FSCom.remove("/prefs/your_module.bin");
-#endif
-}
-```
-
-### 2. File-Scope Mutable Globals Persist Across Tests
-
-Variables like `static uint8_t someDenominator = 8;` in the module `.cpp` file retain mutations from previous tests. This is distinct from member variables — it affects all instances.
-
-**Fix:** Add a `static void resetGlobal()` method to the module and call it in `setUp()`.
-
-### 3. Randomness Breaks Determinism
-
-If the module uses `rand()` for jitter or similar, test results become non-reproducible.
-
-**Fix:** Add a static enable/disable flag:
-
-```cpp
-// Module header:
-static void setJitter(bool enabled) { s_jitterEnabled = enabled; }
-
-// Test setUp:
-YourModule::setJitter(false);
-
-// Test tearDown:
-YourModule::setJitter(true);
-```
-
-### 4. Time-Dependent Logic Produces Zeros
-
-Rolling averages weighted by `elapsedMs / ONE_HOUR_MS` collapse to zero when tests complete in microseconds. Sample windows, EMA alphas, and interval-based accumulators all suffer from this.
-
-**Fix:** Expose the timestamp via friend access and simulate realistic elapsed time:
-
-```cpp
-// In test shim:
-void setWindowStartMs(uint32_t ms) { windowStartMs = ms; }
-
-// In test:
-shim.setWindowStartMs(millis() - 3600000UL);  // pretend 1 hour elapsed
-```
-
-### 5. Capacity Limits Cause Cascading Failures
-
-Fixed-size data structures (hash sets, ring buffers) overflow when tests inject more data than fits. This triggers early flushes with near-zero time fractions, compounding the time-dependent-zeros problem.
-
-**Fix:** Simulate multiple realistic time windows rather than one massive burst. Let adaptive mechanisms (if any) self-tune over several rolls.
-
-## setUp/tearDown Checklist
-
-- [ ] Create and clear MockNodeDB (if needed)
-- [ ] Zero global configs: `config`, `moduleConfig`, `myNodeInfo`
-- [ ] Set `nodeDB = mockNodeDB`
-- [ ] Delete persisted state files (`FSCom.remove(...)`)
-- [ ] Reset file-scope mutable globals
-- [ ] Disable randomness/jitter flags
-- [ ] In `tearDown`: null the global singleton pointer, restore flags
-
-## Test Organization
-
-A well-structured test suite follows this pattern:
-
-1. **Topology/scenario builders** — static helper functions that set up specific test conditions
-2. **Injection helpers** — simulate realistic traffic, time, or event patterns
-3. **Scenario tests** — each builds a scenario, runs the module, asserts on outcomes
-4. **Lifecycle tests** — state persistence, startup from blank, restart recovery
-5. **Summary test** (optional) — emits a scenario table into the log for quick CI review
-
-## Existing Test Suites
-
-| Suite                        | Module Under Test             |
-| ---------------------------- | ----------------------------- |
-| `test_crypto`                | CryptoEngine                  |
-| `test_mqtt`                  | MQTT integration              |
-| `test_radio`                 | Radio interface               |
-| `test_mesh_module`           | Module framework              |
-| `test_meshpacket_serializer` | Packet serialization          |
-| `test_transmit_history`      | Retransmission tracking       |
-| `test_atak`                  | ATAK integration              |
-| `test_default`               | Default configuration helpers |
-| `test_http_content_handler`  | HTTP handling                 |
-| `test_serial`                | Serial communication          |
-| `test_hop_scaling`           | Hop scaling algorithm         |
-| `test_traffic_management`    | Traffic management            |

test/test_default/test_main.cpp

@@ -127,60 +127,6 @@ void test_client_uses_public_channel_minimums()
     TEST_ASSERT_EQUAL_UINT32(60 * 60, position);
 }
 
-// --- Saturation/clamp tests for getConfiguredOrDefaultMs[Scaled] ---
-// These guard the INT32_MAX clamp added to avoid uint32 wrap of secs*1000 and
-// to keep results safe to cast to int32_t for OSThread runOnce returns.
-
-void test_ms_below_threshold()
-{
-    // Ordinary value passes through unchanged.
-    TEST_ASSERT_EQUAL_UINT32(60000U, Default::getConfiguredOrDefaultMs(60, 0));
-}
-
-void test_ms_at_threshold()
-{
-    // INT32_MAX / 1000 = 2,147,483 — largest secs that does not clamp.
-    TEST_ASSERT_EQUAL_UINT32(2147483000U, Default::getConfiguredOrDefaultMs(2147483U, 0));
-}
-
-void test_ms_just_above_threshold()
-{
-    // One second over the boundary must saturate, not wrap.
-    TEST_ASSERT_EQUAL_UINT32(static_cast<uint32_t>(INT32_MAX), Default::getConfiguredOrDefaultMs(2147484U, 0));
-}
-
-void test_ms_uint32_max()
-{
-    // default_sds_secs == UINT32_MAX on non-routers must not wrap.
-    TEST_ASSERT_EQUAL_UINT32(static_cast<uint32_t>(INT32_MAX), Default::getConfiguredOrDefaultMs(UINT32_MAX, 0));
-}
-
-void test_ms_default_clamps()
-{
-    // Clamp also applies when the default-arg path is taken (configured == 0).
-    TEST_ASSERT_EQUAL_UINT32(static_cast<uint32_t>(INT32_MAX), Default::getConfiguredOrDefaultMs(0, UINT32_MAX));
-}
-
-void test_ms_result_is_int32_safe()
-{
-    // Regression guard for runOnce returns: cast to int32_t must not go negative.
-    int32_t result = static_cast<int32_t>(Default::getConfiguredOrDefaultMs(UINT32_MAX, 0));
-    TEST_ASSERT_GREATER_OR_EQUAL_INT32(0, result);
-}
-
-void test_scaled_overflow_saturates()
-{
-    // long_fast (SF11/BW250) with a 24h base and heavy congestion overflows
-    // the uint32 result without the double-precision guard. Must saturate.
-    config.device.role = meshtastic_Config_DeviceConfig_Role_CLIENT;
-    config.lora.use_preset = false;
-    config.lora.spread_factor = 11;
-    config.lora.bandwidth = 250;
-
-    uint32_t res = Default::getConfiguredOrDefaultMsScaled(0, ONE_DAY, 1000);
-    TEST_ASSERT_EQUAL_UINT32(static_cast<uint32_t>(INT32_MAX), res);
-}
-
 void setup()
 {
     // Small delay to match other test mains
@@ -194,13 +140,6 @@ void setup()
     RUN_TEST(test_router_uses_router_minimums);
     RUN_TEST(test_router_late_uses_router_minimums);
     RUN_TEST(test_client_uses_public_channel_minimums);
-    RUN_TEST(test_ms_below_threshold);
-    RUN_TEST(test_ms_at_threshold);
-    RUN_TEST(test_ms_just_above_threshold);
-    RUN_TEST(test_ms_uint32_max);
-    RUN_TEST(test_ms_default_clamps);
-    RUN_TEST(test_ms_result_is_int32_safe);
-    RUN_TEST(test_scaled_overflow_saturates);
     exit(UNITY_END());
 }
 

test/test_mac_from_string/test_main.cpp

@@ -1,195 +0,0 @@
-// Unit tests for MAC_from_string in src/platform/portduino/PortduinoGlue.cpp.
-//
-// Regression coverage for when the function stripped colons from
-// its mac_str parameter but then read bytes from the global
-// portduino_config.mac_address. Symptoms: --hwid silently ignored when
-// MACAddress: was also set, and SIGABRT (stoi: no conversion) when --hwid
-// was used without MACAddress: in config.yaml.
-#include "Arduino.h"
-#include "TestUtil.h"
-#include <cstdint>
-#include <cstring>
-#include <string>
-#include <unity.h>
-
-// Forward-declare instead of including PortduinoGlue.h to avoid pulling in
-// LR11x0Interface, USBHal, mesh.pb.h, yaml-cpp, and the full portduino_config
-// struct just to test a self-contained string parser. The symbol is defined
-// in PortduinoGlue.cpp and resolved at link time.
-bool MAC_from_string(std::string mac_str, uint8_t *dmac);
-
-void setUp(void) {}
-void tearDown(void) {}
-
-// --- Happy-path parsing ---
-
-void test_colon_separated_uppercase()
-{
-    uint8_t dmac[6] = {0};
-    TEST_ASSERT_TRUE(MAC_from_string("AA:BB:CC:DD:EE:FF", dmac));
-    TEST_ASSERT_EQUAL_HEX8(0xAA, dmac[0]);
-    TEST_ASSERT_EQUAL_HEX8(0xBB, dmac[1]);
-    TEST_ASSERT_EQUAL_HEX8(0xCC, dmac[2]);
-    TEST_ASSERT_EQUAL_HEX8(0xDD, dmac[3]);
-    TEST_ASSERT_EQUAL_HEX8(0xEE, dmac[4]);
-    TEST_ASSERT_EQUAL_HEX8(0xFF, dmac[5]);
-}
-
-void test_colon_separated_lowercase()
-{
-    uint8_t dmac[6] = {0};
-    TEST_ASSERT_TRUE(MAC_from_string("02:ca:fe:ba:be:01", dmac));
-    TEST_ASSERT_EQUAL_HEX8(0x02, dmac[0]);
-    TEST_ASSERT_EQUAL_HEX8(0xCA, dmac[1]);
-    TEST_ASSERT_EQUAL_HEX8(0xFE, dmac[2]);
-    TEST_ASSERT_EQUAL_HEX8(0xBA, dmac[3]);
-    TEST_ASSERT_EQUAL_HEX8(0xBE, dmac[4]);
-    TEST_ASSERT_EQUAL_HEX8(0x01, dmac[5]);
-}
-
-void test_no_colons_packed_hex()
-{
-    // The CLI form produced by some tools — 12 hex chars, no separators.
-    uint8_t dmac[6] = {0};
-    TEST_ASSERT_TRUE(MAC_from_string("AABBCCDDEEFF", dmac));
-    TEST_ASSERT_EQUAL_HEX8(0xAA, dmac[0]);
-    TEST_ASSERT_EQUAL_HEX8(0xFF, dmac[5]);
-}
-
-void test_two_distinct_inputs_yield_distinct_outputs()
-{
-    // Direct regression for the original bug: parsing two different MAC
-    // strings in succession must produce two different byte sequences.
-    // Pre-fix, both calls would have produced identical bytes derived from
-    // the (untouched) global portduino_config.mac_address.
-    uint8_t a[6] = {0};
-    uint8_t b[6] = {0};
-    TEST_ASSERT_TRUE(MAC_from_string("AA:BB:CC:DD:EE:FF", a));
-    TEST_ASSERT_TRUE(MAC_from_string("02:CA:FE:BA:BE:01", b));
-    TEST_ASSERT_NOT_EQUAL(0, std::memcmp(a, b, 6));
-    TEST_ASSERT_EQUAL_HEX8(0xAA, a[0]);
-    TEST_ASSERT_EQUAL_HEX8(0x02, b[0]);
-}
-
-void test_does_not_read_external_state()
-{
-    // The function must derive every byte from its parameter, not from any
-    // global. Provide a unique MAC and verify all six bytes match the input
-    // exactly — leaves no room for the function to be smuggling bytes from
-    // elsewhere.
-    uint8_t dmac[6] = {0};
-    TEST_ASSERT_TRUE(MAC_from_string("12:34:56:78:9A:BC", dmac));
-    const uint8_t expected[6] = {0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC};
-    TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, dmac, 6);
-}
-
-// --- Rejected inputs ---
-// Pre-fix, the empty/short cases either crashed (stoi exception on substr("")
-// of the empty global) or silently filled dmac with stale bytes. Post-fix,
-// the length guard rejects them cleanly with `false` and dmac is unchanged.
-
-void test_empty_string_returns_false()
-{
-    uint8_t dmac[6] = {0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x11};
-    uint8_t before[6];
-    std::memcpy(before, dmac, 6);
-    TEST_ASSERT_FALSE(MAC_from_string("", dmac));
-    // dmac must be untouched on failure.
-    TEST_ASSERT_EQUAL_HEX8_ARRAY(before, dmac, 6);
-}
-
-void test_too_short_returns_false()
-{
-    uint8_t dmac[6] = {0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x11};
-    uint8_t before[6];
-    std::memcpy(before, dmac, 6);
-    TEST_ASSERT_FALSE(MAC_from_string("AA:BB:CC", dmac));
-    TEST_ASSERT_EQUAL_HEX8_ARRAY(before, dmac, 6);
-}
-
-void test_too_long_returns_false()
-{
-    uint8_t dmac[6] = {0};
-    // 14 hex chars after colon-strip > 12.
-    TEST_ASSERT_FALSE(MAC_from_string("AA:BB:CC:DD:EE:FF:00", dmac));
-}
-
-void test_only_colons_returns_false()
-{
-    uint8_t dmac[6] = {0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x11};
-    uint8_t before[6];
-    std::memcpy(before, dmac, 6);
-    TEST_ASSERT_FALSE(MAC_from_string(":::::", dmac));
-    TEST_ASSERT_EQUAL_HEX8_ARRAY(before, dmac, 6);
-}
-
-void test_extra_colons_still_parses()
-{
-    // Colon stripping happens before length check, so an unconventional
-    // grouping that totals 12 hex chars after stripping is still accepted.
-    uint8_t dmac[6] = {0};
-    TEST_ASSERT_TRUE(MAC_from_string("AABB:CCDD:EEFF", dmac));
-    TEST_ASSERT_EQUAL_HEX8(0xAA, dmac[0]);
-    TEST_ASSERT_EQUAL_HEX8(0xFF, dmac[5]);
-}
-
-void test_non_hex_input_returns_false()
-{
-    // 12 chars of non-hex would have made std::stoi throw before the
-    // try/catch wrapper was added, killing the daemon. Now must return false
-    // and leave dmac untouched.
-    uint8_t dmac[6] = {0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x11};
-    uint8_t before[6];
-    std::memcpy(before, dmac, 6);
-    TEST_ASSERT_FALSE(MAC_from_string("ZZ:ZZ:ZZ:ZZ:ZZ:ZZ", dmac));
-    TEST_ASSERT_EQUAL_HEX8_ARRAY(before, dmac, 6);
-}
-
-void test_partial_hex_failure_preserves_dmac()
-{
-    // First five bytes are valid hex; the sixth ("ZZ") is not. Without the
-    // temp-buffer staging, dmac would be partially overwritten with the five
-    // good bytes plus stale data in slot 5 — silently producing a wrong MAC
-    // since the only caller that uses this in getMacAddr() ignores the bool
-    // return value.
-    uint8_t dmac[6] = {0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x11};
-    uint8_t before[6];
-    std::memcpy(before, dmac, 6);
-    TEST_ASSERT_FALSE(MAC_from_string("AA:BB:CC:DD:EE:ZZ", dmac));
-    TEST_ASSERT_EQUAL_HEX8_ARRAY(before, dmac, 6);
-}
-
-void test_embedded_non_hex_returns_false()
-{
-    // std::stoi tolerates leading whitespace and a "0x" prefix, so a stray
-    // space inside a 2-char window like " F" would silently parse as 0xF.
-    // The per-character isxdigit() pre-check rejects these. The 14-char
-    // "0xAABBCCDDEEFF" is also rejected by the length check.
-    uint8_t dmac[6] = {0};
-    TEST_ASSERT_FALSE(MAC_from_string("AA:BB:CC:DD:EE: F", dmac));
-    TEST_ASSERT_FALSE(MAC_from_string("0xAABBCCDDEEFF", dmac));
-}
-
-// --- Unity lifecycle ---
-
-void setup()
-{
-    initializeTestEnvironment();
-    UNITY_BEGIN();
-    RUN_TEST(test_colon_separated_uppercase);
-    RUN_TEST(test_colon_separated_lowercase);
-    RUN_TEST(test_no_colons_packed_hex);
-    RUN_TEST(test_two_distinct_inputs_yield_distinct_outputs);
-    RUN_TEST(test_does_not_read_external_state);
-    RUN_TEST(test_empty_string_returns_false);
-    RUN_TEST(test_too_short_returns_false);
-    RUN_TEST(test_too_long_returns_false);
-    RUN_TEST(test_only_colons_returns_false);
-    RUN_TEST(test_extra_colons_still_parses);
-    RUN_TEST(test_non_hex_input_returns_false);
-    RUN_TEST(test_partial_hex_failure_preserves_dmac);
-    RUN_TEST(test_embedded_non_hex_returns_false);
-    exit(UNITY_END());
-}
-
-void loop() {}

test/test_transmit_history/test_main.cpp

@@ -303,10 +303,6 @@ void setup()
 {
     initializeTestEnvironment();
 
-    // Wait for portduino's millis() clock to start ticking before tests run
-    testDelay(10);
-    testDelay(2000);
-
     UNITY_BEGIN();
 
     RUN_TEST(test_setLastSentToMesh_stores_millis);

test/test_utf8/test_main.cpp

@@ -1,197 +0,0 @@
-#include "meshUtils.h"
-#include <cstring>
-#include <unity.h>
-
-void setUp(void) {}
-void tearDown(void) {}
-
-// --- Valid UTF-8 should pass through unchanged ---
-
-void test_ascii_unchanged()
-{
-    char buf[32] = "Hello World";
-    TEST_ASSERT_FALSE(sanitizeUtf8(buf, sizeof(buf)));
-    TEST_ASSERT_EQUAL_STRING("Hello World", buf);
-}
-
-void test_valid_2byte_unchanged()
-{
-    // "café" — é is C3 A9
-    char buf[16] = "caf\xC3\xA9";
-    TEST_ASSERT_FALSE(sanitizeUtf8(buf, sizeof(buf)));
-    TEST_ASSERT_EQUAL_STRING("caf\xC3\xA9", buf);
-}
-
-void test_valid_3byte_unchanged()
-{
-    // "€" is E2 82 AC
-    char buf[16] = "\xE2\x82\xAC";
-    TEST_ASSERT_FALSE(sanitizeUtf8(buf, sizeof(buf)));
-    TEST_ASSERT_EQUAL_STRING("\xE2\x82\xAC", buf);
-}
-
-void test_valid_4byte_emoji_unchanged()
-{
-    // 🌙 is F0 9F 8C 99
-    char buf[16] = "\xF0\x9F\x8C\x99";
-    TEST_ASSERT_FALSE(sanitizeUtf8(buf, sizeof(buf)));
-    TEST_ASSERT_EQUAL_STRING("\xF0\x9F\x8C\x99", buf);
-}
-
-void test_valid_mixed_unchanged()
-{
-    // "Hi 🌙!" — mix of ASCII and 4-byte
-    char buf[16] = "Hi \xF0\x9F\x8C\x99!";
-    TEST_ASSERT_FALSE(sanitizeUtf8(buf, sizeof(buf)));
-    TEST_ASSERT_EQUAL_STRING("Hi \xF0\x9F\x8C\x99!", buf);
-}
-
-void test_empty_string()
-{
-    char buf[8] = "";
-    TEST_ASSERT_FALSE(sanitizeUtf8(buf, sizeof(buf)));
-    TEST_ASSERT_EQUAL_STRING("", buf);
-}
-
-// --- Invalid sequences observed in the wild ---
-
-void test_truncated_4byte_at_end()
-{
-    // Name with valid emoji 🌙 followed by a truncated 4-byte sequence + ASCII
-    char buf[32] = "Lunar Tower \xF0\x9F\x8C\x99\xF0\x9F\x97"
-                   "4";
-    TEST_ASSERT_TRUE(sanitizeUtf8(buf, sizeof(buf)));
-    // The 🌙 should be preserved; F0 9F 97 is an incomplete 4-byte sequence,
-    // '4' (0x34) is not a valid continuation byte
-    TEST_ASSERT_EQUAL_STRING("Lunar Tower \xF0\x9F\x8C\x99???4", buf);
-}
-
-void test_lone_lead_bytes_without_continuations()
-{
-    // Mixed ASCII with stray multibyte lead bytes (E1, F3) lacking proper continuations
-    char buf[32] = "Mesht\xE1\xF3tic 37e2";
-    TEST_ASSERT_TRUE(sanitizeUtf8(buf, sizeof(buf)));
-    // E1 expects 2 continuation bytes, but F3 is not a continuation → E1 replaced
-    // F3 expects 3 continuation bytes, 't','i','c' are not continuations → F3 replaced
-    TEST_ASSERT_EQUAL_STRING("Mesht??tic 37e2", buf);
-}
-
-// --- Edge cases ---
-
-void test_bare_continuation_byte()
-{
-    // 0x80 alone is invalid (continuation byte with no lead)
-    char buf[8] = "\x80";
-    TEST_ASSERT_TRUE(sanitizeUtf8(buf, sizeof(buf)));
-    TEST_ASSERT_EQUAL_STRING("?", buf);
-}
-
-void test_overlong_2byte()
-{
-    // C0 AF is an overlong encoding of U+002F '/'
-    char buf[8] = "\xC0\xAF";
-    TEST_ASSERT_TRUE(sanitizeUtf8(buf, sizeof(buf)));
-    // C0 is a 2-byte lead, AF is valid continuation, but codepoint 0x2F < 0x80 → overlong
-    // C0 replaced, AF (now bare continuation) also replaced
-    TEST_ASSERT_EQUAL_STRING("??", buf);
-}
-
-void test_surrogate_half()
-{
-    // ED A0 80 encodes U+D800 (surrogate half — invalid in UTF-8)
-    char buf[8] = "\xED\xA0\x80";
-    TEST_ASSERT_TRUE(sanitizeUtf8(buf, sizeof(buf)));
-    TEST_ASSERT_EQUAL_STRING("???", buf);
-}
-
-void test_5byte_sequence_rejected()
-{
-    // F8 80 80 80 80 — 5-byte sequence, not valid UTF-8
-    char buf[8] = "\xF8\x80\x80\x80\x80";
-    TEST_ASSERT_TRUE(sanitizeUtf8(buf, sizeof(buf)));
-    // F8 is invalid lead (>= 0xF8), each 0x80 is bare continuation
-    TEST_ASSERT_EQUAL_STRING("?????", buf);
-}
-
-void test_truncated_3byte_at_buffer_end()
-{
-    // Buffer is exactly 4 bytes: E2 82 then forced null at [3]
-    char buf[4];
-    buf[0] = '\xE2';
-    buf[1] = '\x82';
-    buf[2] = '\0'; // String ends before the 3-byte sequence completes
-    buf[3] = '\0';
-    TEST_ASSERT_TRUE(sanitizeUtf8(buf, sizeof(buf)));
-    TEST_ASSERT_EQUAL_STRING("??", buf);
-}
-
-void test_null_termination_enforced()
-{
-    // Fill buffer completely with no null terminator
-    char buf[5];
-    memset(buf, 'A', sizeof(buf));
-    TEST_ASSERT_TRUE(sanitizeUtf8(buf, sizeof(buf)));
-    // Should be null-terminated and content preserved (all ASCII)
-    TEST_ASSERT_EQUAL_STRING("AAAA", buf);
-}
-
-void test_null_buffer()
-{
-    TEST_ASSERT_FALSE(sanitizeUtf8(nullptr, 10));
-}
-
-void test_zero_size()
-{
-    char buf[4] = "Hi";
-    TEST_ASSERT_FALSE(sanitizeUtf8(buf, 0));
-    // Buffer should be untouched
-    TEST_ASSERT_EQUAL_STRING("Hi", buf);
-}
-
-void test_valid_max_codepoint()
-{
-    // U+10FFFF = F4 8F BF BF (maximum valid Unicode codepoint)
-    char buf[8] = "\xF4\x8F\xBF\xBF";
-    TEST_ASSERT_FALSE(sanitizeUtf8(buf, sizeof(buf)));
-    TEST_ASSERT_EQUAL_STRING("\xF4\x8F\xBF\xBF", buf);
-}
-
-void test_above_max_codepoint()
-{
-    // U+110000 = F4 90 80 80 (just above maximum valid Unicode)
-    char buf[8] = "\xF4\x90\x80\x80";
-    TEST_ASSERT_TRUE(sanitizeUtf8(buf, sizeof(buf)));
-}
-
-void setup()
-{
-    UNITY_BEGIN();
-
-    // Valid UTF-8 passthrough
-    RUN_TEST(test_ascii_unchanged);
-    RUN_TEST(test_valid_2byte_unchanged);
-    RUN_TEST(test_valid_3byte_unchanged);
-    RUN_TEST(test_valid_4byte_emoji_unchanged);
-    RUN_TEST(test_valid_mixed_unchanged);
-    RUN_TEST(test_empty_string);
-
-    // Invalid sequences observed in the wild
-    RUN_TEST(test_truncated_4byte_at_end);
-    RUN_TEST(test_lone_lead_bytes_without_continuations);
-
-    // Edge cases
-    RUN_TEST(test_bare_continuation_byte);
-    RUN_TEST(test_overlong_2byte);
-    RUN_TEST(test_surrogate_half);
-    RUN_TEST(test_5byte_sequence_rejected);
-    RUN_TEST(test_truncated_3byte_at_buffer_end);
-    RUN_TEST(test_null_termination_enforced);
-    RUN_TEST(test_null_buffer);
-    RUN_TEST(test_zero_size);
-    RUN_TEST(test_valid_max_codepoint);
-    RUN_TEST(test_above_max_codepoint);
-
-    exit(UNITY_END());
-}
-
-void loop() {}

variants/esp32/chatter2/platformio.ini

@@ -8,6 +8,7 @@ build_flags =
   -I variants/esp32/chatter2
   -DMESHTASTIC_EXCLUDE_WEBSERVER=1
   -DMESHTASTIC_EXCLUDE_PAXCOUNTER=1
+  -ULED_BUILTIN
   
 lib_deps =
   ${esp32_base.lib_deps}

variants/esp32/diy/9m2ibr_aprs_lora_tracker/platformio.ini

@@ -10,6 +10,7 @@ build_flags =
   -D EBYTE_E22
   -D EBYTE_E22_900M30S ; Assume Tx power curve is identical to 900M30S as there is no documentation
   -I variants/esp32/diy/9m2ibr_aprs_lora_tracker
+  -ULED_BUILTIN
 build_src_filter =
   ${esp32_base.build_src_filter}
   +<../variants/esp32/diy/9m2ibr_aprs_lora_tracker>

variants/esp32/diy/hydra/platformio.ini

@@ -14,3 +14,4 @@ build_flags =
   ${esp32_base.build_flags}
   -D DIY_V1
   -I variants/esp32/diy/hydra
+  -ULED_BUILTIN

variants/esp32/diy/v1/platformio.ini

@@ -17,3 +17,4 @@ build_flags =
   -D DIY_V1
   -D EBYTE_E22
   -I variants/esp32/diy/v1
+  -ULED_BUILTIN

variants/esp32/heltec_v2.1/platformio.ini

@@ -14,3 +14,4 @@ build_flags =
   ${esp32_base.build_flags}
   -D HELTEC_V2_1
   -I variants/esp32/heltec_v2.1
+  -ULED_BUILTIN

variants/esp32/heltec_v2/platformio.ini

@@ -14,3 +14,4 @@ build_flags =
   ${esp32_base.build_flags}
   -D HELTEC_V2_0
   -I variants/esp32/heltec_v2
+  -ULED_BUILTIN

variants/esp32/m5stack_coreink/platformio.ini

@@ -19,7 +19,7 @@ build_flags =
 lib_deps = 
   ${esp32_base.lib_deps}
   # renovate: datasource=custom.pio depName=GxEPD2 packageName=zinggjm/library/GxEPD2
-  zinggjm/GxEPD2@1.6.9
+  zinggjm/GxEPD2@1.6.8
   # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
   lewisxhe/SensorLib@0.3.4
 lib_ignore =

variants/esp32/nano-g1-explorer/platformio.ini

@@ -14,3 +14,4 @@ build_flags =
   ${esp32_base.build_flags}
   -D NANO_G1_EXPLORER
   -I variants/esp32/nano-g1-explorer
+  -ULED_BUILTIN

variants/esp32/nano-g1/platformio.ini

@@ -14,3 +14,4 @@ build_flags =
   ${esp32_base.build_flags}
   -D NANO_G1
   -I variants/esp32/nano-g1
+  -ULED_BUILTIN

variants/esp32/radiomaster_900_bandit/platformio.ini

@@ -9,6 +9,7 @@ build_flags =
   -DHAS_STK8XXX=1
   -O2
   -I variants/esp32/radiomaster_900_bandit
+  -ULED_BUILTIN
 board_build.f_cpu = 240000000L
 upload_protocol = esptool
 lib_deps =

variants/esp32/radiomaster_900_bandit_micro/platformio.ini

@@ -13,5 +13,6 @@ build_flags =
   -DCONFIG_DISABLE_HAL_LOCKS=1
   -O2
   -I variants/esp32/radiomaster_900_bandit_nano
+  -ULED_BUILTIN
 board_build.f_cpu = 240000000L
 upload_protocol = esptool

variants/esp32/radiomaster_900_bandit_nano/platformio.ini

@@ -16,5 +16,6 @@ build_flags =
   -DCONFIG_DISABLE_HAL_LOCKS=1
   -O2
   -I variants/esp32/radiomaster_900_bandit_nano
+  -ULED_BUILTIN
 board_build.f_cpu = 240000000L
 upload_protocol = esptool

variants/esp32/station-g1/platformio.ini

@@ -14,3 +14,4 @@ build_flags =
   ${esp32_base.build_flags}
   -D STATION_G1
   -I variants/esp32/station-g1
+  -ULED_BUILTIN

variants/esp32/tbeam/platformio.ini

@@ -16,6 +16,7 @@ board_check = true
 build_flags = ${esp32_base.build_flags}
   -D TBEAM_V10
   -I variants/esp32/tbeam
+  -ULED_BUILTIN
 upload_speed = 921600
 
 [env:tbeam-displayshield]

variants/esp32/tlora_v1/platformio.ini

@@ -13,4 +13,5 @@ build_flags =
   ${esp32_base.build_flags}
   -D TLORA_V1
   -I variants/esp32/tlora_v1
+  -ULED_BUILTIN
 upload_speed = 115200

variants/esp32/tlora_v2_1_16/platformio.ini

@@ -12,7 +12,7 @@ extends = esp32_base
 board = ttgo-lora32-v21
 board_check = true
 build_flags = 
-  ${esp32_base.build_flags} -D TLORA_V2_1_16 -I variants/esp32/tlora_v2_1_16
+  ${esp32_base.build_flags} -D TLORA_V2_1_16 -I variants/esp32/tlora_v2_1_16 -ULED_BUILTIN
 upload_speed = 115200
 
 [env:sugarcube]

variants/esp32/tlora_v2_1_16_tcxo/platformio.ini

@@ -7,4 +7,5 @@ build_flags =
   -D TLORA_V2_1_16
   -I variants/esp32/tlora_v2_1_16
   -D LORA_TCXO_GPIO=33
+  -ULED_BUILTIN
 upload_speed = 115200

variants/esp32/tlora_v3_3_0_tcxo/platformio.ini

@@ -7,3 +7,4 @@ build_flags =
   -I variants/esp32/tlora_v2_1_16
   -D LORA_TCXO_GPIO=12
   -D BUTTON_PIN=0
+  -ULED_BUILTIN

variants/esp32c6/tlora_c6/platformio.ini

@@ -8,3 +8,4 @@ build_flags =
   -I variants/esp32c6/tlora_c6
   -DARDUINO_USB_CDC_ON_BOOT=1
   -DARDUINO_USB_MODE=1
+  -ULED_BUILTIN

variants/esp32s3/diy/my_esp32s3_diy_eink/platformio.ini

@@ -11,7 +11,7 @@ upload_speed = 921600
 lib_deps =
   ${esp32s3_base.lib_deps}
   # renovate: datasource=custom.pio depName=GxEPD2 packageName=zinggjm/library/GxEPD2
-  zinggjm/GxEPD2@1.6.9
+  zinggjm/GxEPD2@1.6.8
 build_unflags =
   ${esp32s3_base.build_unflags}
   -DARDUINO_USB_MODE=1