Merge branch 'develop' into t-display-s3-pro

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

.devcontainer/devcontainer.json

@@ -8,17 +8,21 @@
   "features": {
     "ghcr.io/devcontainers/features/python:1": {
       "installTools": true,
-      "version": "3.14"
+      "version": "3.13"
     }
   },
   "customizations": {
     "vscode": {
       "extensions": [
         "ms-vscode.cpptools",
-        "platformio.platformio-ide",
+        "Jason2866.esp-decoder",
+        "pioarduino.pioarduino-ide",
         "Trunk.io"
       ],
-      "unwantedRecommendations": ["ms-azuretools.vscode-docker"],
+      "unwantedRecommendations": [
+        "ms-azuretools.vscode-docker",
+        "platformio.platformio-ide"
+      ],
       "settings": {
         "extensions.ignoreRecommendations": true
       }

.github/copilot-instructions.md

@@ -193,22 +193,26 @@ Writers go through `setNodeStatus`, `updatePosition`, `updateTelemetry` (which d
 
 Every code path that drops a node from the header table must also evict the satellites. The single chokepoint is `eraseNodeSatellites(NodeNum)`; it's already called from `getOrCreateMeshNode`'s oldest-boring eviction, `removeNodeByNum`, both branches of `resetNodes`, `cleanupMeshDB`, `addFromContact`'s ignored-branch, and `AdminModule`'s `set_ignored_node`. Add new eviction sites here, not by calling `.erase()` directly.
 
-### Gradient sync (opt-in via special nonces)
+### Sync flow: thin NodeInfo + post-COMPLETE_ID replay (no opt-in)
 
-`client_capabilities` is **not** a thing in this branch. Phone clients opt into the new sync flow by sending one of two values in the `ToRadio.want_config_id`:
+There is no capability flag and no special "gradient" nonce. The **default** sync flow is:
 
-- `SPECIAL_NONCE_GRADIENT_SYNC` (69422) — full config + thin NodeInfo + replay phases.
-- `SPECIAL_NONCE_GRADIENT_ONLY_NODES` (69423) — skip config segments, NodeInfo + replay only.
+1. Config / module-config / channel / metadata segments (same as before).
+2. `STATE_SEND_OWN_NODEINFO` — **our own** NodeInfo, still bundled with our position and device_metrics (because the replay snapshot excludes our own NodeNum). Emitted via `ConvertToNodeInfo(lite)`.
+3. `STATE_SEND_OTHER_NODEINFOS` — every other peer's NodeInfo, **always thin** (no `position`, no `device_metrics`). Emitted via `ConvertToNodeInfoThin(lite)`.
+4. `STATE_SEND_FILEMANIFEST` → `STATE_SEND_COMPLETE_ID` — the phone sees `config_complete_id` and treats sync as done.
+5. `STATE_SEND_PACKETS` — live mesh packets, with a trailing replay drain interleaved. The replay drain walks four cached satellite stores in order (positions → telemetry → environment → status) and emits each cached entry as an ordinary `MeshPacket` on the matching portnum (`POSITION_APP`, `TELEMETRY_APP` device + environment variants, `NODE_STATUS_APP`). These are indistinguishable on the wire from live mesh traffic, so clients need no special handling — any code that already updates UI on `POSITION_APP` etc. works.
 
-`PhoneAPI::clientWantsGradientSync()` is the single switch. When true, `STATE_SEND_OTHER_NODEINFOS` is followed by:
+`PhoneAPI::sendConfigComplete()` arms `replayPhase = REPLAY_PHASE_POSITIONS` for default/full sync and `SPECIAL_NONCE_ONLY_NODES`, while `SPECIAL_NONCE_ONLY_CONFIG` skips replay. The drain runs inside `STATE_SEND_PACKETS` via `popReplayPacket()`, lower priority than live traffic. When all four phases drain, `replayPhase` flips back to `REPLAY_PHASE_IDLE` and the snapshot vectors get `shrink_to_fit`ed.
 
-```text
-STATE_REPLAY_POSITIONS → STATE_REPLAY_TELEMETRY → STATE_REPLAY_ENVIRONMENT → STATE_REPLAY_STATUS
-```
+STM32WL and any other build with all four `MESHTASTIC_EXCLUDE_*DB` flags set produces zero replay packets — `popReplayPacket` advances through each phase in microseconds without emitting anything.
 
-Each replay phase walks the corresponding satellite map and emits synthetic `MeshPacket`s on the matching portnum (`POSITION_APP`, `TELEMETRY_APP` for both device + environment variants, `STATUS_MESSAGE_APP`). Legacy clients (no special nonce) get the bundled-NodeInfo path with position/device_metrics joined back in by `ConvertToNodeInfo(lite, pos*, dm*)` — wire bytes are byte-identical to pre-v25 for them.
+Special nonces that still mean something:
 
-`ConvertToNodeInfoThin(lite)` is the gradient-sync emitter (no position/telemetry).
+- `SPECIAL_NONCE_ONLY_CONFIG` (69420) — skip node sync entirely, just config.
+- `SPECIAL_NONCE_ONLY_NODES` (69421) — skip config segments, jump straight to `STATE_SEND_OWN_NODEINFO`. Still gets the post-COMPLETE_ID replay drain.
+
+There are no other reserved nonces; everything else is a fresh random `want_config_id` from the client.
 
 ### v24 → v25 migration
 

.gitignore

@@ -47,6 +47,10 @@ data/boot/logo.*
 managed_components/*
 arduino-lib-builder*
 dependencies.lock
+
+# JLink / RTT debug artifacts (nRF SoCs)
+flash.jlink
+rtt_*.txt
 idf_component.yml
 CMakeLists.txt
 /sdkconfig.*
@@ -56,3 +60,9 @@ CMakeLists.txt
 .python3
 .claude/scheduled_tasks.lock
 userPrefs.jsonc.mcp-session-bak
+
+# Fake-NodeDB fixture pipeline (bin/regen-fake-nodedbs.sh)
+# JSONL seeds are committed (test/fixtures/nodedb/seed_v25_*.jsonl);
+# compiled .proto outputs are ephemeral build artifacts.
+build/fixtures/
+bin/_generated/

.trunk/trunk.yaml

@@ -11,7 +11,7 @@ lint:
     - checkov@3.2.528
     - renovate@43.150.0
     - prettier@3.8.3
-    - trufflehog@3.95.2
+    - trufflehog@3.95.3
     - yamllint@1.38.0
     - bandit@1.9.4
     - trivy@0.70.0
@@ -34,6 +34,13 @@ lint:
     - linters: [ALL]
       paths:
         - bin/**
+    # Fake-NodeDB fixture JSONL files contain deterministic synthetic
+    # public_key_hex (64-char hex) values that gitleaks misidentifies as
+    # generic-api-key. These are not secrets — they're test fixtures
+    # produced by bin/gen-fake-nodedb-seed.py with a fixed RNG seed.
+    - linters: [gitleaks]
+      paths:
+        - test/fixtures/nodedb/seed_v25_*.jsonl
 runtimes:
   enabled:
     - python@3.14.4

.vscode/extensions.json

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

bin/_rewrite_proto_namespace.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""Post-process protoc-generated Python files to live under a local namespace.
+
+Called by bin/regen-py-protos.sh. Walks the generated *_pb2.py files in the
+target directory and rewrites every `meshtastic` reference (imports, dotted
+attribute access) to use the new namespace (e.g., `meshtastic_v25`).
+
+Why: the .proto files declare `package meshtastic;`, so protoc emits
+`from meshtastic import mesh_pb2 as ...` lines. That would shadow the PyPI
+`meshtastic` package which other parts of the mcp-server depend on. Renaming
+to a local namespace keeps both available.
+
+Usage:
+    _rewrite_proto_namespace.py <generated_dir> <new_namespace>
+"""
+
+from __future__ import annotations
+
+import pathlib
+import re
+import sys
+
+
+def rewrite(dir_path: pathlib.Path, new_ns: str) -> int:
+    # Standard protoc import forms:
+    #   from meshtastic.X_pb2 import ...     (rare, for direct symbol pulls)
+    #   from meshtastic import X_pb2 as ...  (common, the cross-file ref)
+    #   import meshtastic.X_pb2              (also possible)
+    pattern_dotted_from = re.compile(r"^from meshtastic\.", re.MULTILINE)
+    pattern_bare_from = re.compile(r"^from meshtastic import ", re.MULTILINE)
+    pattern_dotted_import = re.compile(r"^import meshtastic\.", re.MULTILINE)
+
+    count = 0
+    for p in dir_path.glob("*.py"):
+        text = p.read_text(encoding="utf-8")
+        new = pattern_dotted_from.sub(f"from {new_ns}.", text)
+        new = pattern_bare_from.sub(f"from {new_ns} import ", new)
+        new = pattern_dotted_import.sub(f"import {new_ns}.", new)
+        # NOTE: we deliberately leave `meshtastic/X.proto` source-filename
+        # references inside descriptor strings alone. The descriptor pool is
+        # keyed by source filename (independent of Python package layout), so
+        # those don't collide with the PyPI package's descriptors.
+        if new != text:
+            p.write_text(new, encoding="utf-8")
+            count += 1
+    return count
+
+
+def main(argv: list[str]) -> int:
+    if len(argv) != 2:
+        print("usage: _rewrite_proto_namespace.py <generated_dir> <new_namespace>", file=sys.stderr)
+        return 2
+    dir_path = pathlib.Path(argv[0])
+    new_ns = argv[1]
+    if not dir_path.is_dir():
+        print(f"directory not found: {dir_path}", file=sys.stderr)
+        return 2
+    n = rewrite(dir_path, new_ns)
+    print(f"rewrote {n} file(s) in {dir_path} → namespace {new_ns}", file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

bin/config.d/lora-station-g3.yaml

@@ -0,0 +1,18 @@
+# Station G3 motherboard with a Raspberry Pi Zero 2W as the MCU daughterboard.
+# Verify spidev / I2C device paths for your OS — they may differ.
+Meta:
+  name: Station G3
+  support: community
+  compatible:
+    - raspberry-pi
+
+Lora:
+  Module: sx1262
+  IRQ: 22                       # BCM pin — wiki spec
+  Reset: 16                     # BCM pin — wiki spec
+  Busy: 24                      # BCM pin — wiki spec
+  # CS: 8                       # BCM 8 = SPI0 CE0 (default); uncomment only to override
+  DIO2_AS_RF_SWITCH: true
+  DIO3_TCXO_VOLTAGE: true
+  spidev: spidev0.0
+  # SX126X_MAX_POWER: 19        # matches Station G2 firmware cap; raise carefully per PA jumper mode

bin/gen-fake-nodedb-seed.py

@@ -0,0 +1,439 @@
+#!/usr/bin/env python3
+"""Deterministic seed-data generator for the fake NodeDB fixture pipeline.
+
+Writes a JSONL file describing N fake-but-realistic Meshtastic peers.
+The output is hand-editable and committed; a sibling compile step
+(bin/seed-json-to-proto.py) turns it into a binary `meshtastic_NodeDatabase`
+v25 protobuf with fresh "now-relative" timestamps.
+
+Determinism contract:
+  Same --seed -> byte-identical JSONL output, regardless of wall clock.
+  All timestamps are stored as `*_offset_sec` (seconds before "now"); the
+  compile step resolves them to absolute epochs at compile time.
+
+Structural fields covered:
+  * NodeInfoLite header: num, long_name, short_name, hw_model, role,
+    public_key, snr, channel, hops_away, next_hop, bitfield flags
+  * PositionLite: lat/long Gaussian around --centroid, altitude, source
+  * DeviceMetrics: battery/voltage/util/uptime
+  * EnvironmentMetrics: temp/humidity/pressure/iaq
+  * StatusMessage: error_code (usually zero)
+
+Active-board allow-list:
+  hw_model values are restricted to the intersection of
+    (a) variants with `custom_meshtastic_support_level = 1` in
+        variants/*/*/platformio.ini, AND
+    (b) values present in the `HardwareModel` enum in mesh.proto.
+  See HW_MODEL_WEIGHTS below. Deprecated boards (legacy TLORA / Heltec V1-2 /
+  classic TBEAM / TBEAM_V0P7 / Nano G1 / etc.) and fuzzer-only sentinels
+  (PORTDUINO, ANDROID_SIM, DIY_V1, ...) are excluded.
+
+Active-role allow-list:
+  Excludes ROUTER_CLIENT (deprecated v2.3.15) and REPEATER (deprecated v2.7.11).
+"""
+
+from __future__ import annotations
+
+import argparse
+import datetime as _dt
+import json
+import math
+import pathlib
+import random
+import sys
+
+# --------------------------------------------------------------------------
+# Active-board allow-list (intersection of tier-1 variants + HardwareModel enum).
+# Refresh by running:
+#   for f in $(find variants -name 'platformio.ini' | xargs grep -lE 'custom_meshtastic_support_level = 1'); do
+#       grep custom_meshtastic_hw_model_slug $f | awk -F= '{print $2}' | tr -d ' ';
+#   done | sort -u | comm -12 - <(python3 -c "from meshtastic.protobuf.mesh_pb2 import HardwareModel; print('\\n'.join(HardwareModel.keys()))" | sort)
+# --------------------------------------------------------------------------
+HW_MODEL_WEIGHTS: dict[str, float] = {
+    "HELTEC_V3": 14.0,
+    "T_DECK": 9.0,
+    "HELTEC_V4": 8.0,
+    "RAK4631": 8.0,
+    "HELTEC_MESH_POCKET": 6.0,
+    "TRACKER_T1000_E": 5.0,
+    "HELTEC_MESH_NODE_T114": 5.0,
+    "T_DECK_PRO": 5.0,
+    "LILYGO_TBEAM_S3_CORE": 4.0,
+    "HELTEC_WIRELESS_PAPER": 4.0,
+    "HELTEC_WSL_V3": 3.0,
+    "T_ECHO": 3.0,
+    "HELTEC_WIRELESS_TRACKER": 3.0,
+    "HELTEC_WIRELESS_TRACKER_V2": 2.0,
+    "HELTEC_VISION_MASTER_E290": 2.0,
+    "HELTEC_MESH_SOLAR": 2.0,
+    "SEEED_WIO_TRACKER_L1": 2.0,
+    "T_LORA_PAGER": 1.5,
+    "HELTEC_VISION_MASTER_E213": 1.5,
+    "T_ECHO_PLUS": 1.0,
+    "MUZI_BASE": 1.0,
+    "WISMESH_TAP_V2": 1.0,
+    "THINKNODE_M2": 1.0,
+    "THINKNODE_M5": 1.0,
+    "TLORA_T3_S3": 1.0,
+    # Long tail (uniform low weight across remaining tier-1 boards):
+    "HELTEC_V4_R8": 0.3,
+    "HELTEC_VISION_MASTER_T190": 0.3,
+    "HELTEC_HT62": 0.3,
+    "HELTEC_MESH_NODE_T096": 0.3,
+    "M5STACK_C6L": 0.3,
+    "MINI_EPAPER_S3": 0.3,
+    "MUZI_R1_NEO": 0.3,
+    "NOMADSTAR_METEOR_PRO": 0.3,
+    "RAK3312": 0.3,
+    "RAK3401": 0.3,
+    "SEEED_SOLAR_NODE": 0.3,
+    "SEEED_WIO_TRACKER_L1_EINK": 0.3,
+    "SENSECAP_INDICATOR": 0.3,
+    "TBEAM_1_WATT": 0.3,
+    "THINKNODE_M1": 0.3,
+    "THINKNODE_M3": 0.3,
+    "THINKNODE_M6": 0.3,
+    "T_ECHO_LITE": 0.3,
+    "WISMESH_TAG": 0.3,
+    "WISMESH_TAP": 0.3,
+    "XIAO_NRF52_KIT": 0.3,
+    "CROWPANEL": 0.3,
+}
+
+# Non-deprecated roles only.
+ROLE_WEIGHTS: dict[str, float] = {
+    "CLIENT": 75.0,
+    "CLIENT_MUTE": 5.0,
+    "ROUTER": 7.0,
+    "TRACKER": 3.0,
+    "SENSOR": 2.0,
+    "CLIENT_HIDDEN": 2.0,
+    "ROUTER_LATE": 2.0,
+    "CLIENT_BASE": 2.0,
+    "TAK": 1.0,
+    "TAK_TRACKER": 0.5,
+    "LOST_AND_FOUND": 0.5,
+}
+
+# Name pools — 60 firsts × 60 lasts = 3600 combinations.
+FIRSTS = [
+    "Quick", "Brave", "Silent", "Wild", "Lone", "Bright", "Red", "Blue",
+    "Green", "Black", "White", "Iron", "Steel", "Copper", "Silver", "Gold",
+    "Stone", "River", "Forest", "Mountain", "Canyon", "Desert", "Storm", "Sky",
+    "Solar", "Lunar", "Dawn", "Dusk", "Misty", "Frosty", "Sunny", "Shady",
+    "Happy", "Sleepy", "Drowsy", "Sneaky", "Sharp", "Smooth", "Rough", "Loud",
+    "Soft", "Slow", "Fast", "Tall", "Short", "Old", "New", "Tiny",
+    "Giant", "Hidden", "Lost", "Found", "Wandering", "Roving", "Drifting", "Floating",
+    "Burning", "Frozen", "Whispering", "Howling",
+]
+LASTS = [
+    "Phoenix", "Lion", "Bear", "Wolf", "Hawk", "Eagle", "Fox", "Lynx",
+    "Cougar", "Coyote", "Raven", "Owl", "Crow", "Falcon", "Heron", "Crane",
+    "Otter", "Badger", "Bison", "Elk", "Moose", "Stag", "Doe", "Hare",
+    "Marmot", "Mole", "Beaver", "Squirrel", "Mustang", "Bronco", "Pony", "Colt",
+    "Cobra", "Viper", "Mamba", "Adder", "Gecko", "Iguana", "Tortoise", "Turtle",
+    "Salmon", "Trout", "Bass", "Pike", "Shark", "Whale", "Dolphin", "Seal",
+    "Cactus", "Yucca", "Sage", "Juniper", "Pine", "Cedar", "Aspen", "Oak",
+    "Bluff", "Mesa", "Arroyo", "Ridge",
+]
+
+# Brief callsign pool for licensed-looking suffixes.
+CALLSIGN_PREFIXES = ["KX", "WD", "N5", "KE", "AB", "W5", "K1", "KQ", "AE", "NM"]
+
+# Only emojis that fit in 4 UTF-8 bytes (no variation selectors). short_name's
+# nanopb max_size:5 (incl. NUL) limits content to 4 bytes. ❄️ / ☀️ would be
+# 6 bytes due to U+FE0F variation selector — explicitly excluded.
+EMOJI_SHORTNAMES = ["🦊", "🐺", "🦅", "🐢", "🌵", "🔥", "🌙",
+                    "🌊", "🗻", "🌲", "🦌", "🐝", "🦂", "🦉",
+                    "🦇", "🦋"]
+
+# --------------------------------------------------------------------------
+# Helpers
+# --------------------------------------------------------------------------
+
+NUM_RESERVED = 4         # firmware reserves 0..3 (per NodeDB constants)
+NUM_MAX_EXCLUSIVE = 0x80000000  # restrict to positive int32 range for readability
+
+
+def _weighted_choice(rng: random.Random, weights: dict[str, float]) -> str:
+    """Deterministic weighted pick. Uses sorted keys so dict order is fixed."""
+    keys = sorted(weights.keys())
+    totals = [weights[k] for k in keys]
+    return rng.choices(keys, weights=totals, k=1)[0]
+
+
+def _gen_long_name(rng: random.Random, is_licensed: bool) -> str:
+    base = f"{rng.choice(FIRSTS)} {rng.choice(LASTS)}"
+    if is_licensed:
+        prefix = rng.choice(CALLSIGN_PREFIXES)
+        # Two trailing alpha chars after the digit; keep within 25 - len(base) - 1
+        suffix = f" {prefix}{rng.randint(0,9)}{rng.choice('ABCDEFGHIJKLMNOPQRSTUVWXYZ')}{rng.choice('ABCDEFGHIJKLMNOPQRSTUVWXYZ')}"
+        # nanopb max_size:25 means C string fits 24 bytes + NUL.
+        if len(base) + len(suffix) <= 24:
+            base = base + suffix
+    # Hard cap to 24 chars (nanopb max_size:25 minus NUL).
+    return base[:24]
+
+
+def _gen_short_name(rng: random.Random, long_name: str) -> str:
+    # 10% emoji-only short_name
+    if rng.random() < 0.10:
+        return rng.choice(EMOJI_SHORTNAMES)
+    first_char = long_name[0].upper() if long_name else "X"
+    alphanums = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+    return first_char + "".join(rng.choices(alphanums, k=3))
+
+
+def _gen_hops_away(rng: random.Random) -> int:
+    # Geometric-ish: 0→55%, 1→25%, 2→12%, 3→5%, 4→2%, 5+→1%
+    r = rng.random()
+    if r < 0.55:
+        return 0
+    if r < 0.80:
+        return 1
+    if r < 0.92:
+        return 2
+    if r < 0.97:
+        return 3
+    if r < 0.99:
+        return 4
+    return rng.randint(5, 7)
+
+
+def _gen_position(
+    rng: random.Random,
+    centroid_lat: float,
+    centroid_lon: float,
+    spread_km: float,
+    last_heard_offset_sec: int,
+) -> dict:
+    # 1 deg ≈ 111 km at the equator; we use this as a flat approximation.
+    lat = centroid_lat + rng.gauss(0.0, spread_km / 111.0)
+    lon = centroid_lon + rng.gauss(0.0, spread_km / 111.0)
+    altitude = max(0, round(rng.gauss(1376.0, 250.0)))  # T or C valley floor + relief
+    # Position was reported up to 300s before last_heard.
+    time_offset_sec = last_heard_offset_sec + rng.randint(0, 300)
+    return {
+        "latitude": round(lat, 6),
+        "longitude": round(lon, 6),
+        "altitude": altitude,
+        "time_offset_sec": time_offset_sec,
+        "location_source": "LOC_INTERNAL",
+    }
+
+
+def _gen_telemetry(rng: random.Random) -> dict:
+    # 5% plugged-in (battery_level == 101); rest uniform [10..100].
+    if rng.random() < 0.05:
+        battery_level = 101
+        voltage = 4.20
+    else:
+        battery_level = rng.randint(10, 100)
+        voltage = round(3.3 + (battery_level / 100.0) * 0.9, 3)
+    # Beta distributions for low/right-skewed metrics; randomly draw via gammavariate.
+    def _beta(a: float, b: float) -> float:
+        x = rng.gammavariate(a, 1.0)
+        y = rng.gammavariate(b, 1.0)
+        return x / (x + y)
+    channel_utilization = round(_beta(2.0, 15.0) * 100.0, 2)
+    air_util_tx = round(_beta(1.5, 20.0) * 10.0, 3)
+    uptime_seconds = int(rng.expovariate(1.0 / 86400.0))
+    return {
+        "battery_level": battery_level,
+        "voltage": voltage,
+        "channel_utilization": channel_utilization,
+        "air_util_tx": air_util_tx,
+        "uptime_seconds": uptime_seconds,
+    }
+
+
+def _gen_environment(rng: random.Random) -> dict:
+    return {
+        "temperature": round(rng.gauss(22.0, 8.0), 2),
+        "relative_humidity": round(min(100.0, max(0.0, rng.gauss(55.0, 20.0))), 2),
+        "barometric_pressure": round(rng.gauss(1013.0, 8.0), 2),
+        "iaq": int(min(500, max(0, round(rng.gauss(50.0, 30.0))))),
+    }
+
+
+def _gen_status(rng: random.Random) -> dict:
+    # `StatusMessage` (mesh.proto:1445) has a single free-form `string status`.
+    # Most peers report a healthy short status; occasional alert string.
+    healthy = ["OK", "online", "active", "running", "ready", "nominal"]
+    alert = ["low-batt", "no-gps", "weak-signal", "rebooted", "offline-soon"]
+    if rng.random() < 0.92:
+        return {"status": rng.choice(healthy)}
+    return {"status": rng.choice(alert)}
+
+
+def _gen_node(
+    rng: random.Random,
+    num: int,
+    centroid_lat: float,
+    centroid_lon: float,
+    spread_km: float,
+    coverage: dict[str, float],
+    last_heard_mean_sec: int,
+    last_heard_max_sec: int,
+) -> dict:
+    is_licensed = rng.random() < 0.05
+    long_name = _gen_long_name(rng, is_licensed)
+    short_name = _gen_short_name(rng, long_name)
+    hw_model = _weighted_choice(rng, HW_MODEL_WEIGHTS)
+    role = _weighted_choice(rng, ROLE_WEIGHTS)
+    has_public_key = rng.random() < 0.92
+    public_key_hex = (
+        "".join(f"{rng.randint(0,255):02x}" for _ in range(32)) if has_public_key else ""
+    )
+    snr = round(max(-20.0, min(12.0, rng.gauss(6.0, 4.0))), 2)
+    channel = 0 if rng.random() < 0.90 else rng.randint(1, 7)
+    hops_away = _gen_hops_away(rng)
+    next_hop = rng.randint(0, 255) if hops_away > 0 else 0
+    last_heard_offset_sec = int(min(rng.expovariate(1.0 / last_heard_mean_sec), last_heard_max_sec))
+
+    bitfield = {
+        "has_user": True,
+        "is_favorite": rng.random() < 0.08,
+        "is_muted": rng.random() < 0.03,
+        "via_mqtt": rng.random() < 0.12,
+        "is_ignored": rng.random() < 0.01,
+        "is_licensed": is_licensed,
+        "has_is_unmessagable": True,
+        "is_unmessagable": rng.random() < 0.02,
+        "is_key_manually_verified": rng.random() < 0.04,
+    }
+
+    node: dict = {
+        "num": f"0x{num:08x}",
+        "long_name": long_name,
+        "short_name": short_name,
+        "hw_model": hw_model,
+        "role": role,
+        "public_key_hex": public_key_hex,
+        "snr": snr,
+        "channel": channel,
+        "hops_away": hops_away,
+        "next_hop": next_hop,
+        "last_heard_offset_sec": last_heard_offset_sec,
+        "bitfield": bitfield,
+        "position": (
+            _gen_position(rng, centroid_lat, centroid_lon, spread_km, last_heard_offset_sec)
+            if rng.random() < coverage["position"]
+            else None
+        ),
+        "telemetry": _gen_telemetry(rng) if rng.random() < coverage["telemetry"] else None,
+        "environment": _gen_environment(rng) if rng.random() < coverage["environment"] else None,
+        "status": _gen_status(rng) if rng.random() < coverage["status"] else None,
+    }
+    return node
+
+
+def _parse_my_node_num(s: str | None) -> int | None:
+    if s is None:
+        return None
+    s = s.strip()
+    if s.startswith("0x") or s.startswith("0X"):
+        return int(s, 16)
+    return int(s)
+
+
+def main(argv: list[str]) -> int:
+    p = argparse.ArgumentParser(
+        description="Deterministic JSONL seed for the fake NodeDB fixture.",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    p.add_argument("--count", type=int, required=True, help="Number of fake nodes to emit.")
+    p.add_argument("--seed", type=int, required=True, help="Deterministic seed.")
+    p.add_argument("--out", required=True, help="Output JSONL path.")
+    p.add_argument(
+        "--centroid",
+        default="33.1284,-107.2528",
+        help="LAT,LON centroid (default: Truth or Consequences, NM).",
+    )
+    p.add_argument("--spread-km", type=float, default=60.0, help="Gaussian std-dev in km.")
+    p.add_argument("--position-coverage", type=float, default=0.85)
+    p.add_argument("--telemetry-coverage", type=float, default=0.70)
+    p.add_argument("--environment-coverage", type=float, default=0.25)
+    p.add_argument("--status-coverage", type=float, default=0.40)
+    p.add_argument("--my-node-num", default=None, help="Exclude this NodeNum from generated set (hex or dec).")
+    p.add_argument("--last-heard-mean-sec", type=int, default=3600)
+    p.add_argument("--last-heard-max-sec", type=int, default=7 * 86400)
+    args = p.parse_args(argv)
+
+    if args.count <= 0:
+        print("--count must be positive", file=sys.stderr)
+        return 2
+
+    try:
+        centroid_lat, centroid_lon = (float(s) for s in args.centroid.split(","))
+    except ValueError:
+        print(f"--centroid must be LAT,LON; got {args.centroid!r}", file=sys.stderr)
+        return 2
+
+    my_node_num = _parse_my_node_num(args.my_node_num)
+
+    rng = random.Random(args.seed)
+
+    # 1) Generate a unique deterministic set of NodeNums.
+    nums: set[int] = set()
+    while len(nums) < args.count:
+        n = rng.randrange(NUM_RESERVED, NUM_MAX_EXCLUSIVE)
+        if my_node_num is not None and n == my_node_num:
+            continue
+        nums.add(n)
+    ordered_nums = sorted(nums)  # sort to fix output order independent of set hash
+
+    # 2) Per-node generation (in num order, single RNG continues).
+    coverage = {
+        "position": args.position_coverage,
+        "telemetry": args.telemetry_coverage,
+        "environment": args.environment_coverage,
+        "status": args.status_coverage,
+    }
+    nodes = [
+        _gen_node(
+            rng,
+            n,
+            centroid_lat,
+            centroid_lon,
+            args.spread_km,
+            coverage,
+            args.last_heard_mean_sec,
+            args.last_heard_max_sec,
+        )
+        for n in ordered_nums
+    ]
+
+    # 3) Write JSONL.
+    out_path = pathlib.Path(args.out)
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    # `generated_at_iso` is informational; it does NOT affect determinism because
+    # we derive it from the seed, not from wall clock. (Same seed -> same string.)
+    generated_at = _dt.datetime.fromtimestamp(args.seed, tz=_dt.timezone.utc).isoformat().replace("+00:00", "Z")
+    meta = {
+        "_meta": {
+            "version": 25,
+            "seed": args.seed,
+            "count": args.count,
+            "centroid": [centroid_lat, centroid_lon],
+            "spread_km": args.spread_km,
+            "generated_at_iso": generated_at,
+            "my_node_num_excluded": (None if my_node_num is None else f"0x{my_node_num:08x}"),
+            "coverage": coverage,
+            "last_heard_mean_sec": args.last_heard_mean_sec,
+            "last_heard_max_sec": args.last_heard_max_sec,
+        }
+    }
+    with out_path.open("w", encoding="utf-8") as f:
+        # `ensure_ascii=False` so emoji short_names survive. `sort_keys=True` for
+        # determinism (insertion order varies by Python version otherwise).
+        f.write(json.dumps(meta, ensure_ascii=False, sort_keys=True) + "\n")
+        for node in nodes:
+            f.write(json.dumps(node, ensure_ascii=False, sort_keys=True) + "\n")
+
+    print(f"wrote {args.count} nodes to {out_path} ({out_path.stat().st_size} bytes)", file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

bin/regen-fake-nodedbs.sh

@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+# Regenerate the fake-NodeDB fixtures: produces 250 / 500 / 1000 / 2000-node
+# JSONL seed files + their compiled v25 protobufs.
+#
+# Layout:
+#   test/fixtures/nodedb/seed_v25_<N>.jsonl   — COMMITTED, hand-editable.
+#   build/fixtures/nodedb/nodes_v25_<N>.proto — .gitignored, build artifact.
+#                                               Drop into /prefs/nodes.proto.
+#
+# Daily use:  ./bin/regen-fake-nodedbs.sh
+#   - Recompiles protos from committed seeds (fresh wall-clock timestamps).
+# Intentional seed bump:  REGEN_SEEDS=yes ./bin/regen-fake-nodedbs.sh
+#   - Overwrites the committed JSONL files with freshly-seeded data.
+
+set -euo pipefail
+cd "$(dirname "$0")/.."
+
+# 1) Make sure the Python protobuf bindings exist (in-tree generation; .gitignored).
+if [[ ! -d bin/_generated/meshtastic ]]; then
+    echo "regenerating Python protobuf bindings (one-time)..."
+    ./bin/regen-py-protos.sh
+fi
+
+# 2) Pick a Python interpreter that has the meshtastic deps installed.
+#    Prefer the mcp-server venv (most likely to be set up by the operator).
+PY="python3"
+for cand in mcp-server/.venv/bin/python3 .venv/bin/python3; do
+    if [[ -x "$cand" ]]; then
+        PY="$cand"
+        break
+    fi
+done
+
+# 3) Pinned seeds per size — bump only when you intentionally want different
+#    structural data committed. Parallel arrays so the script works on
+#    macOS bash 3.2 (no `declare -A`).
+SIZES=(250 500 1000 2000)
+SEEDS=(20260511 20260512 20260513 20260514)
+
+REGEN_SEEDS="${REGEN_SEEDS:-no}"
+
+mkdir -p build/fixtures/nodedb test/fixtures/nodedb
+
+for i in 0 1 2 3; do
+    n="${SIZES[$i]}"
+    seed="${SEEDS[$i]}"
+    jsonl=$(printf "test/fixtures/nodedb/seed_v25_%04d.jsonl" "$n")
+    proto=$(printf "build/fixtures/nodedb/nodes_v25_%04d.proto" "$n")
+
+    if [[ "$REGEN_SEEDS" == "yes" || ! -f "$jsonl" ]]; then
+        $PY bin/gen-fake-nodedb-seed.py \
+            --count "$n" \
+            --seed "$seed" \
+            --out "$jsonl" \
+            --centroid 33.1284,-107.2528 \
+            --spread-km 60 \
+            --position-coverage 0.85 \
+            --telemetry-coverage 0.70 \
+            --environment-coverage 0.25 \
+            --status-coverage 0.40
+        echo "  seed:   $jsonl ($(wc -c < "$jsonl") bytes)"
+    fi
+
+    $PY bin/seed-json-to-proto.py --in "$jsonl" --out "$proto"
+    echo "  proto:  $proto ($(wc -c < "$proto") bytes)"
+done
+
+echo ""
+echo "Done. To load on Portduino native:"
+echo "  cp build/fixtures/nodedb/nodes_v25_1000.proto ~/.portduino/default/prefs/nodes.proto"
+echo ""
+echo "To push to a hardware device:"
+echo "  Use the mcp-server tool: push_fake_nodedb(size=1000, target=\"hardware\", port=\"/dev/cu.usbmodemXXXX\", confirm=True)"

bin/regen-py-protos.sh

@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+# Regenerate Python protobuf bindings from the in-tree `protobufs/` submodule
+# into `bin/_generated/`. Called by bin/regen-fake-nodedbs.sh; also useful as
+# a standalone refresh after any change to a .proto file.
+#
+# Output is .gitignored — bindings are a build artifact.
+#
+# Namespace rewrite:
+# The .proto files declare `package meshtastic;`, which makes protoc emit
+# imports like `from meshtastic import mesh_pb2`. That conflicts with the
+# PyPI `meshtastic` package (which the mcp-server relies on for its
+# SerialInterface/BLEInterface transport). We post-process the generated
+# files to live under `meshtastic_v25` instead — both the directory layout
+# and all internal imports — so they coexist cleanly with the PyPI package.
+
+set -euo pipefail
+cd "$(dirname "$0")/.."
+
+if ! command -v protoc >/dev/null 2>&1; then
+    echo "ERROR: protoc not found in PATH." >&2
+    echo "  macOS: brew install protobuf" >&2
+    echo "  Ubuntu/Debian: apt install protobuf-compiler" >&2
+    exit 1
+fi
+
+OUT=bin/_generated
+LOCAL_NS=meshtastic_v25
+
+rm -rf "$OUT"
+mkdir -p "$OUT"
+
+# 1) Generate from the in-tree protos. nanopb.proto first so its descriptor
+#    is available for the [(nanopb).*] options on other messages.
+protoc \
+    --proto_path=protobufs \
+    --python_out="$OUT" \
+    protobufs/nanopb.proto \
+    protobufs/meshtastic/*.proto
+
+# 2) Move the generated `meshtastic/` directory to `meshtastic_v25/`.
+mv "$OUT/meshtastic" "$OUT/$LOCAL_NS"
+
+# 3) Rewrite internal imports: any reference to `meshtastic.X_pb2` or
+#    `from meshtastic import X_pb2` becomes `meshtastic_v25.*`.
+python3 bin/_rewrite_proto_namespace.py "$OUT/$LOCAL_NS" "$LOCAL_NS"
+
+# 4) Make the package importable.
+touch "$OUT/__init__.py"
+touch "$OUT/$LOCAL_NS/__init__.py"
+
+echo "regenerated Python protobuf bindings -> $OUT/$LOCAL_NS/ (namespace: $LOCAL_NS)" >&2

bin/seed-json-to-proto.py

@@ -0,0 +1,342 @@
+#!/usr/bin/env python3
+"""Compile a committed seed JSONL into a binary meshtastic_NodeDatabase v25 proto.
+
+The input is produced by `bin/gen-fake-nodedb-seed.py`. Timestamps in the JSONL
+are stored as `*_offset_sec` (seconds before "now"); this script resolves them
+to absolute epochs using `--now-epoch` (default: current wall clock).
+
+Output is a raw `pb_encode`-compatible binary that can be dropped at
+`/prefs/nodes.proto` on the device (Portduino prefs dir or hardware via
+XModem) and loaded by `NodeDB::loadFromDisk` at boot.
+
+Wire format reference:
+  protobufs/meshtastic/deviceonly.proto  (NodeDatabase, NodeInfoLite, sat entries)
+  src/mesh/NodeDB.h:467-484              (bitfield bit positions)
+  src/mesh/NodeDB.cpp:1523-1524          (pb_decode entry point)
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import pathlib
+import sys
+import time
+from typing import Any
+
+# Prefer the in-tree generated Python protobuf bindings (bin/_generated/meshtastic_v25/)
+# because the firmware branch's protos (v25 NodeDatabase satellite arrays, slim
+# NodeInfoLite) are typically newer than what the PyPI `meshtastic` package
+# ships. Run `bin/regen-py-protos.sh` to (re)generate.
+#
+# Namespace note: the local bindings live under `meshtastic_v25` (NOT `meshtastic`)
+# to avoid shadowing the PyPI `meshtastic` package — bin/regen-py-protos.sh
+# post-processes the protoc output to rename the package.
+_HERE = pathlib.Path(__file__).resolve().parent
+_LOCAL_PROTO_DIR = _HERE / "_generated"
+if _LOCAL_PROTO_DIR.is_dir():
+    sys.path.insert(0, str(_LOCAL_PROTO_DIR))
+
+try:
+    from meshtastic_v25.deviceonly_pb2 import (  # type: ignore[import-not-found]
+        NodeDatabase,
+        NodeInfoLite,
+        NodePositionEntry,
+        NodeTelemetryEntry,
+        NodeEnvironmentEntry,
+        NodeStatusEntry,
+        PositionLite,
+    )
+    from meshtastic_v25.mesh_pb2 import HardwareModel, Position, StatusMessage  # type: ignore[import-not-found]
+    from meshtastic_v25.config_pb2 import Config  # type: ignore[import-not-found]
+    from meshtastic_v25.telemetry_pb2 import DeviceMetrics, EnvironmentMetrics  # type: ignore[import-not-found]
+except ImportError as local_err:
+    # Fall back to the PyPI package if in-tree bindings haven't been generated.
+    # Will fail the v25 assertion below if the PyPI package predates the
+    # satellite-DB schema, but at least gives a clear "run regen-py-protos.sh"
+    # error message instead of an opaque ImportError.
+    try:
+        from meshtastic.protobuf.deviceonly_pb2 import (
+            NodeDatabase,
+            NodeInfoLite,
+            NodePositionEntry,
+            NodeTelemetryEntry,
+            NodeEnvironmentEntry,
+            NodeStatusEntry,
+            PositionLite,
+        )
+        from meshtastic.protobuf.mesh_pb2 import HardwareModel, Position, StatusMessage
+        from meshtastic.protobuf.config_pb2 import Config
+        from meshtastic.protobuf.telemetry_pb2 import DeviceMetrics, EnvironmentMetrics
+    except ImportError as pypi_err:
+        print(
+            "ERROR: could not import meshtastic protobuf bindings.\n"
+            "  In-tree generation: run `bin/regen-py-protos.sh` (requires protoc).\n"
+            "  PyPI fallback: `pip install meshtastic` (may lag firmware branch).\n"
+            f"  local error (meshtastic_v25): {local_err}\n"
+            f"  pypi error  (meshtastic.protobuf): {pypi_err}",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+# Fail loudly if bindings predate v25 (no satellite arrays).
+assert (
+    hasattr(NodeDatabase, "DESCRIPTOR")
+    and "positions" in NodeDatabase.DESCRIPTOR.fields_by_name
+), (
+    "Loaded meshtastic bindings are older than v25 (NodeDatabase.positions missing). "
+    "Run `bin/regen-py-protos.sh` against the in-tree protobufs/ submodule."
+)
+
+# ---------------------------------------------------------------------------
+# Bitfield bit positions (mirror src/mesh/NodeDB.h:467-484).
+# ---------------------------------------------------------------------------
+BIT_IS_KEY_MANUALLY_VERIFIED = 0
+BIT_IS_MUTED = 1
+BIT_VIA_MQTT = 2
+BIT_IS_FAVORITE = 3
+BIT_IS_IGNORED = 4
+BIT_HAS_USER = 5
+BIT_IS_LICENSED = 6
+BIT_IS_UNMESSAGABLE = 7
+BIT_HAS_IS_UNMESSAGABLE = 8
+
+BITFIELD_LAYOUT = (
+    # JSON key            bit position
+    ("is_key_manually_verified", BIT_IS_KEY_MANUALLY_VERIFIED),
+    ("is_muted", BIT_IS_MUTED),
+    ("via_mqtt", BIT_VIA_MQTT),
+    ("is_favorite", BIT_IS_FAVORITE),
+    ("is_ignored", BIT_IS_IGNORED),
+    ("has_user", BIT_HAS_USER),
+    ("is_licensed", BIT_IS_LICENSED),
+    ("is_unmessagable", BIT_IS_UNMESSAGABLE),
+    ("has_is_unmessagable", BIT_HAS_IS_UNMESSAGABLE),
+)
+
+
+def _pack_bitfield(bf: dict[str, bool]) -> int:
+    out = 0
+    for key, shift in BITFIELD_LAYOUT:
+        if bf.get(key, False):
+            out |= (1 << shift)
+    return out
+
+
+def _validate_node(node: dict[str, Any]) -> None:
+    """Friendly errors so hand-editors get clear feedback."""
+    if "num" not in node or not isinstance(node["num"], str):
+        raise ValueError(f"node missing/invalid 'num' (must be hex string): {node!r}")
+    if "long_name" not in node:
+        raise ValueError(f"node {node['num']}: missing 'long_name'")
+    if len(node["long_name"]) > 24:
+        raise ValueError(
+            f"node {node['num']}: long_name {node['long_name']!r} is "
+            f"{len(node['long_name'])} chars; max 24 (nanopb max_size:25 minus NUL)"
+        )
+    if "short_name" in node:
+        # short_name max_size:5 (incl. NUL) → 4 bytes of content.
+        # Char count is irrelevant — emojis with variation selectors (e.g. ❄️ = 6 B)
+        # would slip past a `len(str) > 4` check. Always measure bytes.
+        b = node["short_name"].encode("utf-8")
+        if len(b) > 4:
+            raise ValueError(
+                f"node {node['num']}: short_name {node['short_name']!r} is "
+                f"{len(b)} bytes UTF-8; max 4 (nanopb max_size:5 minus NUL)"
+            )
+    pk = node.get("public_key_hex", "")
+    if pk and len(pk) != 64:
+        raise ValueError(
+            f"node {node['num']}: public_key_hex must be 64 hex chars or empty; "
+            f"got {len(pk)} chars"
+        )
+    if pk:
+        try:
+            bytes.fromhex(pk)
+        except ValueError as e:
+            raise ValueError(f"node {node['num']}: public_key_hex is not valid hex: {e}")
+
+
+def _resolve_time(
+    node: dict[str, Any],
+    field_absolute: str,
+    field_offset: str,
+    now_epoch: int,
+) -> int:
+    """If `field_absolute` is set, use it; else compute `now_epoch - offset`."""
+    if field_absolute in node and node[field_absolute] is not None:
+        return int(node[field_absolute])
+    offset = node.get(field_offset, 0)
+    return max(0, int(now_epoch) - int(offset))
+
+
+def _build_node_info_lite(node: dict[str, Any], now_epoch: int) -> NodeInfoLite:
+    _validate_node(node)
+    info = NodeInfoLite()
+    info.num = int(node["num"], 16) if isinstance(node["num"], str) else int(node["num"])
+    info.long_name = node.get("long_name", "")
+    info.short_name = node.get("short_name", "")
+    # Enum lookups will raise ValueError on unknown names — that's exactly what we want.
+    info.hw_model = HardwareModel.Value(node.get("hw_model", "UNSET"))
+    info.role = Config.DeviceConfig.Role.Value(node.get("role", "CLIENT"))
+    pk_hex = node.get("public_key_hex", "")
+    if pk_hex:
+        info.public_key = bytes.fromhex(pk_hex)
+    info.snr = float(node.get("snr", 0.0))
+    info.channel = int(node.get("channel", 0))
+    if "hops_away" in node:
+        # `optional uint32 hops_away = 9;` — in Python protobuf, assigning the
+        # field implicitly sets HasField("hops_away") to True. No has_hops_away
+        # setter exists (unlike the C++ nanopb-generated header).
+        info.hops_away = int(node["hops_away"])
+    info.next_hop = int(node.get("next_hop", 0))
+    info.last_heard = _resolve_time(node, "last_heard", "last_heard_offset_sec", now_epoch)
+    info.bitfield = _pack_bitfield(node.get("bitfield", {}))
+    return info
+
+
+def _build_position_entry(num: int, pos: dict[str, Any], now_epoch: int) -> NodePositionEntry:
+    entry = NodePositionEntry()
+    entry.num = num
+    pl = PositionLite()
+    # Firmware stores lat/long as int32 in 1e-7 degrees.
+    pl.latitude_i = int(round(float(pos["latitude"]) * 1e7))
+    pl.longitude_i = int(round(float(pos["longitude"]) * 1e7))
+    pl.altitude = int(pos.get("altitude", 0))
+    pl.time = _resolve_time(pos, "time", "time_offset_sec", now_epoch)
+    pl.location_source = Position.LocSource.Value(pos.get("location_source", "LOC_UNSET"))
+    entry.position.CopyFrom(pl)
+    return entry
+
+
+def _build_telemetry_entry(num: int, tel: dict[str, Any]) -> NodeTelemetryEntry:
+    entry = NodeTelemetryEntry()
+    entry.num = num
+    dm = DeviceMetrics()
+    if "battery_level" in tel:
+        dm.battery_level = int(tel["battery_level"])
+    if "voltage" in tel:
+        dm.voltage = float(tel["voltage"])
+    if "channel_utilization" in tel:
+        dm.channel_utilization = float(tel["channel_utilization"])
+    if "air_util_tx" in tel:
+        dm.air_util_tx = float(tel["air_util_tx"])
+    if "uptime_seconds" in tel:
+        dm.uptime_seconds = int(tel["uptime_seconds"])
+    entry.device_metrics.CopyFrom(dm)
+    return entry
+
+
+def _build_environment_entry(num: int, env: dict[str, Any]) -> NodeEnvironmentEntry:
+    entry = NodeEnvironmentEntry()
+    entry.num = num
+    em = EnvironmentMetrics()
+    if "temperature" in env:
+        em.temperature = float(env["temperature"])
+    if "relative_humidity" in env:
+        em.relative_humidity = float(env["relative_humidity"])
+    if "barometric_pressure" in env:
+        em.barometric_pressure = float(env["barometric_pressure"])
+    if "iaq" in env:
+        em.iaq = int(env["iaq"])
+    entry.environment_metrics.CopyFrom(em)
+    return entry
+
+
+def _build_status_entry(num: int, status: dict[str, Any]) -> NodeStatusEntry:
+    # `StatusMessage` (mesh.proto:1445) has a single `string status` field.
+    entry = NodeStatusEntry()
+    entry.num = num
+    sm = StatusMessage()
+    if "status" in status:
+        sm.status = str(status["status"])
+    entry.status.CopyFrom(sm)
+    return entry
+
+
+def compile_jsonl_to_proto(jsonl_path: pathlib.Path, now_epoch: int) -> bytes:
+    """Read a seed JSONL and return the encoded NodeDatabase bytes."""
+    lines = jsonl_path.read_text(encoding="utf-8").splitlines()
+    if not lines:
+        raise ValueError(f"{jsonl_path} is empty")
+    meta_line = lines[0]
+    meta_obj = json.loads(meta_line)
+    meta = meta_obj.get("_meta", {})
+    version = meta.get("version")
+    if version != 25:
+        raise ValueError(
+            f"{jsonl_path}: meta version is {version!r}; this compiler "
+            f"requires version=25. Regenerate the seed with the matching tooling."
+        )
+
+    db = NodeDatabase()
+    db.version = 25
+
+    for ln, raw in enumerate(lines[1:], start=2):
+        raw = raw.strip()
+        if not raw:
+            continue
+        try:
+            node = json.loads(raw)
+        except json.JSONDecodeError as e:
+            raise ValueError(f"{jsonl_path}:{ln} JSON parse error: {e}")
+
+        num = int(node["num"], 16) if isinstance(node["num"], str) else int(node["num"])
+
+        # Header
+        info = _build_node_info_lite(node, now_epoch)
+        db.nodes.append(info)
+
+        # Satellites (nullable)
+        if node.get("position"):
+            db.positions.append(_build_position_entry(num, node["position"], now_epoch))
+        if node.get("telemetry"):
+            db.telemetry.append(_build_telemetry_entry(num, node["telemetry"]))
+        if node.get("environment"):
+            db.environment.append(_build_environment_entry(num, node["environment"]))
+        if node.get("status"):
+            db.status.append(_build_status_entry(num, node["status"]))
+
+    return db.SerializeToString()
+
+
+def main(argv: list[str]) -> int:
+    p = argparse.ArgumentParser(
+        description="Compile a seed JSONL into a binary v25 NodeDatabase proto.",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    p.add_argument("--in", dest="in_path", required=True, help="Input seed JSONL.")
+    p.add_argument("--out", required=True, help="Output binary .proto path.")
+    p.add_argument(
+        "--now-epoch",
+        type=int,
+        default=None,
+        help="Pin 'now' to this Unix epoch (for byte-identical CI). Default: time.time().",
+    )
+    args = p.parse_args(argv)
+
+    in_path = pathlib.Path(args.in_path)
+    if not in_path.is_file():
+        print(f"input not found: {in_path}", file=sys.stderr)
+        return 2
+
+    now_epoch = args.now_epoch if args.now_epoch is not None else int(time.time())
+
+    try:
+        encoded = compile_jsonl_to_proto(in_path, now_epoch)
+    except ValueError as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        return 3
+
+    out_path = pathlib.Path(args.out)
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    out_path.write_bytes(encoded)
+    print(
+        f"compiled {in_path} -> {out_path} ({len(encoded)} bytes, now_epoch={now_epoch})",
+        file=sys.stderr,
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

boards/ThinkNode-M7.json

@@ -0,0 +1,42 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "esp32s3_out.ld",
+      "memory_type": "qio_opi"
+    },
+    "core": "esp32",
+    "extra_flags": [
+      "-D BOARD_HAS_PSRAM",
+      "-D ARDUINO_USB_CDC_ON_BOOT=0",
+      "-D ARDUINO_USB_MODE=0",
+      "-D ARDUINO_RUNNING_CORE=1",
+      "-D ARDUINO_EVENT_RUNNING_CORE=0"
+    ],
+    "f_cpu": "240000000L",
+    "f_flash": "80000000L",
+    "flash_mode": "qio",
+    "psram_type": "qio_opi",
+    "hwids": [["0x303A", "0x1001"]],
+    "mcu": "esp32s3",
+    "variant": "ELECROW-ThinkNode-M7"
+  },
+  "connectivity": ["wifi", "bluetooth", "lora"],
+  "debug": {
+    "default_tool": "esp-builtin",
+    "onboard_tools": ["esp-builtin"],
+    "openocd_target": "esp32s3.cfg"
+  },
+  "frameworks": ["arduino", "espidf"],
+  "name": "ELECROW ThinkNode M7",
+  "upload": {
+    "flash_size": "8MB",
+    "maximum_ram_size": 524288,
+    "maximum_size": 8388608,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": true,
+    "require_upload_port": true,
+    "speed": 921600
+  },
+  "url": "https://www.elecrow.com",
+  "vendor": "ELECROW"
+}

boards/nrf54l15dk.json

@@ -0,0 +1,26 @@
+{
+  "build": {
+    "cpu": "cortex-m33",
+    "f_cpu": "128000000L",
+    "mcu": "nrf54l15",
+    "zephyr": {
+      "variant": "nrf54l15dk/nrf54l15/cpuapp"
+    }
+  },
+  "connectivity": ["bluetooth"],
+  "debug": {
+    "default_tools": ["jlink"],
+    "jlink_device": "nRF54L15_M33",
+    "svd_path": "nrf54l15.svd"
+  },
+  "frameworks": ["zephyr"],
+  "name": "Nordic nRF54L15-DK (PCA10156)",
+  "upload": {
+    "maximum_ram_size": 262144,
+    "maximum_size": 1572864,
+    "protocol": "jlink",
+    "protocols": ["jlink"]
+  },
+  "url": "https://www.nordicsemi.com/Products/nRF54L15",
+  "vendor": "Nordic Semiconductor"
+}

boards/station-g3.json

@@ -0,0 +1,41 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "esp32s3_out.ld",
+      "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=0"
+    ],
+    "f_cpu": "240000000L",
+    "f_flash": "80000000L",
+    "flash_mode": "qio",
+    "hwids": [["0x303A", "0x1001"]],
+    "mcu": "esp32s3",
+    "variant": "station-g3"
+  },
+  "connectivity": ["wifi", "bluetooth", "lora"],
+  "debug": {
+    "default_tool": "esp-builtin",
+    "onboard_tools": ["esp-builtin"],
+    "openocd_target": "esp32s3.cfg"
+  },
+  "frameworks": ["arduino", "espidf"],
+  "name": "BQ Station G3",
+  "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": "",
+  "vendor": "BQ Consulting"
+}

boards/t-display-s3.json

@@ -0,0 +1,39 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "esp32s3_out.ld",
+      "memory_type": "qio_opi"
+    },
+    "core": "esp32",
+    "extra_flags": [
+      "-DBOARD_HAS_PSRAM",
+      "-DARDUINO_USB_CDC_ON_BOOT=1",
+      "-DARDUINO_USB_MODE=0",
+      "-DARDUINO_RUNNING_CORE=1",
+      "-DARDUINO_EVENT_RUNNING_CORE=1"
+    ],
+    "f_cpu": "240000000L",
+    "f_flash": "80000000L",
+    "flash_mode": "qio",
+    "hwids": [["0x303A", "0x1001"]],
+    "mcu": "esp32s3",
+    "variant": "esp32s3"
+  },
+  "connectivity": ["wifi", "bluetooth", "lora"],
+  "debug": {
+    "default_tool": "esp-builtin",
+    "onboard_tools": ["esp-builtin"],
+    "openocd_target": "esp32s3.cfg"
+  },
+  "frameworks": ["arduino", "espidf"],
+  "name": "LilyGO T-Display S3 Pro LR1121 (16 MB FLASH, 8 MB PSRAM)",
+  "upload": {
+    "flash_size": "16MB",
+    "maximum_ram_size": 327680,
+    "maximum_size": 16777216,
+    "require_upload_port": true,
+    "speed": 921600
+  },
+  "url": "https://lilygo.cc/en-de/products/t-display-s3-pro-lr1121",
+  "vendor": "LilyGO"
+}

extra_scripts/nrf54l15_linker.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+# trunk-ignore-all(ruff/F821)
+# trunk-ignore-all(flake8/F821): For SConstruct imports
+#
+# post:extra_scripts/nrf54l15_linker.py
+#
+# Fix for Zephyr two-pass link on nRF54L15:
+# platformio-build.py registers env.Depends("$PROG_PATH", final_ld_script) but
+# the SCons dependency chain is broken (final_ld_script Command never runs).
+# This script adds a PreAction on the final firmware binary that runs the gcc
+# preprocessing command directly (extracted from build.ninja) to generate
+# zephyr/linker.cmd before the link step.
+#
+# PlatformIO bundles an old Ninja that can't handle multi-output depslog rules,
+# so we parse the COMMAND line from build.ninja and run just the gcc -E part,
+# skipping the cmake_transform_depfile step (only needed for Ninja deps tracking).
+
+import os
+import re
+import subprocess
+
+Import("env")
+
+if env.get("PIOENV") != "nrf54l15dk":
+    pass  # Only for the nrf54l15dk environment
+else:
+
+    def _extract_gcc_command(ninja_build):
+        """Parse build.ninja to find the gcc -E command that generates linker.cmd.
+
+        The rule format depends on the host:
+          Windows (CMake's RunCMake wraps every command):
+            COMMAND = cmd.exe /C "cd /D DIR && arm-none-eabi-gcc.exe ... -o linker.cmd && cmake.exe -E cmake_transform_depfile ..."
+          POSIX (Linux/macOS — no wrapper):
+            COMMAND = cd DIR && arm-none-eabi-gcc ... -o linker.cmd && cmake -E cmake_transform_depfile ...
+
+        Returns (gcc_cmd_string, cwd_path) or raises RuntimeError.
+        """
+        in_rule = False
+        with open(ninja_build, "r", encoding="utf-8", errors="replace") as f:
+            for line in f:
+                # Detect start of the linker.cmd custom command rule
+                if not in_rule:
+                    if "build zephyr/linker.cmd" in line and "CUSTOM_COMMAND" in line:
+                        in_rule = True
+                    continue
+
+                stripped = line.strip()
+                if not stripped.startswith("COMMAND = "):
+                    continue
+
+                command_val = stripped[len("COMMAND = ") :]
+
+                # On Windows the value is wrapped in `cmd.exe /C "..."` — strip
+                # the wrapper. On POSIX hosts the inner sequence is the value
+                # itself (no quoting layer).
+                m = re.search(r'/C\s+"(.*)"\s*$', command_val)
+                inner = m.group(1) if m else command_val
+                parts = inner.split(" && ")
+
+                cwd = None
+                gcc_cmd = None
+                for part in parts:
+                    part = part.strip()
+                    if part.startswith("cd /D "):  # Windows form
+                        cwd = part[len("cd /D ") :]
+                    elif part.startswith("cd "):  # POSIX form
+                        cwd = part[len("cd ") :]
+                    elif "arm-none-eabi-gcc" in part:
+                        gcc_cmd = part
+
+                if not gcc_cmd:
+                    raise RuntimeError(
+                        "nRF54L15 linker fix: arm-none-eabi-gcc command not found in:\n%s"
+                        % inner[:400]
+                    )
+
+                return gcc_cmd, cwd
+
+        raise RuntimeError(
+            "nRF54L15 linker fix: 'build zephyr/linker.cmd' rule not found in build.ninja"
+        )
+
+    def _generate_linker_cmd(target, source, env):
+        """Generate zephyr/linker.cmd via direct gcc invocation before the final link."""
+        build_dir = env.subst("$BUILD_DIR")
+        zephyr_dir = os.path.join(build_dir, "zephyr")
+        linker_cmd = os.path.join(zephyr_dir, "linker.cmd")
+
+        if os.path.exists(linker_cmd):
+            return  # Already present — nothing to do
+
+        ninja_build = os.path.join(build_dir, "build.ninja")
+        if not os.path.exists(ninja_build):
+            raise RuntimeError(
+                "nRF54L15 linker fix: build.ninja not found at %s\n"
+                "Run a full build first so CMake generates the Ninja files."
+                % ninja_build
+            )
+
+        gcc_cmd, cwd = _extract_gcc_command(ninja_build)
+        run_cwd = cwd if cwd else zephyr_dir
+
+        print(
+            "==> nRF54L15: Generating zephyr/linker.cmd (LINKER_ZEPHYR_FINAL) via GCC"
+        )
+        # gcc_cmd comes verbatim from our own build.ninja (never user input) and
+        # contains Windows-style paths with spaces that cannot be safely argv-split
+        # with shlex, so we run it via the platform shell. nosec/nosemgrep below
+        # acknowledge this deliberate, scoped use of shell=True.
+        result = subprocess.run(  # nosec B602
+            gcc_cmd,
+            shell=True,  # nosemgrep: python.lang.security.audit.subprocess-shell-true.subprocess-shell-true
+            cwd=run_cwd,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            print("GCC stdout:", result.stdout[:2000])
+            print("GCC stderr:", result.stderr[:2000])
+            raise RuntimeError(
+                "nRF54L15 linker fix: GCC failed to generate linker.cmd (rc=%d)"
+                % result.returncode
+            )
+        if not os.path.exists(linker_cmd):
+            raise RuntimeError(
+                "nRF54L15 linker fix: GCC returned 0 but linker.cmd was not created at %s"
+                % linker_cmd
+            )
+        print("==> linker.cmd generated successfully")
+
+    # Use PIOMAINPROG (set by ZephyrBuildProgram) to get the exact SCons node
+    prog = env.get("PIOMAINPROG")
+    if prog:
+        env.AddPreAction(prog, _generate_linker_cmd)
+    else:
+        print(
+            "[nrf54l15_linker] WARNING: PIOMAINPROG not set, falling back to $PROG_PATH"
+        )
+        env.AddPreAction(env.subst("$PROG_PATH"), _generate_linker_cmd)

mcp-server/src/meshtastic_mcp/fixtures.py

@@ -0,0 +1,382 @@
+"""Fake NodeDB fixture push — Portduino file copy + hardware XModem upload.
+
+The fixture pipeline is two-stage:
+  1. `bin/gen-fake-nodedb-seed.py` produces a deterministic JSONL describing N
+     fake-but-realistic peers. Committed under `test/fixtures/nodedb/`.
+  2. `bin/seed-json-to-proto.py` compiles JSONL → binary v25 NodeDatabase
+     protobuf with fresh wall-clock timestamps.
+
+This module exposes `push_fake_nodedb(...)`, the MCP tool that:
+  - target="portduino": compiles the JSONL into the device's prefs dir on
+    the local filesystem (`~/.portduino/<config>/prefs/nodes.proto`).
+  - target="hardware":  compiles to a temp file, then streams it over the
+    XModem protocol (via the meshtastic SerialInterface/BLEInterface +
+    `meshtastic.xmodempacket` pubsub topic) to `/prefs/nodes.proto` on the
+    device. Triggers a reboot so the firmware loads the new state on next
+    boot.
+
+XModem wire details (mirrors firmware impl at src/xmodem.cpp:115-260):
+  * 128-byte chunks; final chunk padded to 128 B with 0x1A (SUB) bytes.
+  * CRC16-CCITT (poly 0x1021, init 0x0000).
+  * SOH/seq=0 carries the destination filename in `buffer.bytes`. ACK if
+    `FSCom.open(filename, FILE_O_WRITE)` succeeds; NAK otherwise.
+  * SOH/seq≥1 carries a 128-byte chunk. ACK = advance; NAK = retransmit.
+  * EOT after the last chunk flushes + closes the file on-device.
+
+Hardware push requires `confirm=True` (mirrors factory_reset / erase_and_flash
+in the .github/copilot-instructions.md "never do these without asking" list).
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import hashlib
+import pathlib
+import queue
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+from typing import Any, Literal
+
+from .connection import connect, is_tcp_port
+
+# Resolve repo root so the tool works regardless of mcp-server cwd.
+_REPO_ROOT = pathlib.Path(__file__).resolve().parents[3]
+_SEED_DIR = _REPO_ROOT / "test" / "fixtures" / "nodedb"
+_COMPILE_SCRIPT = _REPO_ROOT / "bin" / "seed-json-to-proto.py"
+
+_DEFAULT_NODES_FILENAME = "/prefs/nodes.proto"
+_XMODEM_CHUNK = 128
+_XMODEM_SUB = 0x1A
+_ACK_TIMEOUT_INIT_S = 5.0
+_ACK_TIMEOUT_CHUNK_S = 2.0
+_MAX_CHUNK_RETRIES = 5
+
+_VALID_SIZES = (250, 500, 1000, 2000)
+
+
+class FixtureError(RuntimeError):
+    """Raised for any fixture-push failure (compile, transport, ack timeout, …)."""
+
+
+# ---------------------------------------------------------------------------
+# CRC16-CCITT (poly 0x1021, init 0x0000). Matches the firmware's `crc16_ccitt`.
+# Hand-rolled to avoid the optional `crcmod` dep.
+# ---------------------------------------------------------------------------
+def _crc16_ccitt(data: bytes, *, init: int = 0x0000) -> int:
+    crc = init
+    for b in data:
+        crc ^= b << 8
+        for _ in range(8):
+            if crc & 0x8000:
+                crc = ((crc << 1) ^ 0x1021) & 0xFFFF
+            else:
+                crc = (crc << 1) & 0xFFFF
+    return crc
+
+
+# ---------------------------------------------------------------------------
+# Compile step — shells out to bin/seed-json-to-proto.py so the MCP module
+# doesn't have to duplicate the proto-encoding logic.
+# ---------------------------------------------------------------------------
+def _compile_proto(jsonl_path: pathlib.Path, out_path: pathlib.Path) -> None:
+    if not _COMPILE_SCRIPT.is_file():
+        raise FixtureError(f"compile script missing at {_COMPILE_SCRIPT}")
+    cmd = [
+        sys.executable,
+        str(_COMPILE_SCRIPT),
+        "--in",
+        str(jsonl_path),
+        "--out",
+        str(out_path),
+    ]
+    try:
+        subprocess.run(cmd, check=True, capture_output=True, text=True)
+    except subprocess.CalledProcessError as exc:
+        raise FixtureError(
+            f"seed-json-to-proto.py failed (exit {exc.returncode}):\n"
+            f"  stdout: {exc.stdout}\n  stderr: {exc.stderr}"
+        ) from exc
+
+
+def _resolve_seed_jsonl(size: int, custom: str | None) -> pathlib.Path:
+    if custom is not None:
+        p = pathlib.Path(custom).expanduser().resolve()
+        if not p.is_file():
+            raise FixtureError(f"custom_seed_jsonl not found: {p}")
+        return p
+    p = _SEED_DIR / f"seed_v25_{size:04d}.jsonl"
+    if not p.is_file():
+        raise FixtureError(
+            f"missing committed seed at {p}. "
+            f"Run `./bin/regen-fake-nodedbs.sh` to generate it."
+        )
+    return p
+
+
+# ---------------------------------------------------------------------------
+# Portduino push — file copy into ~/.portduino/<config>/prefs/
+# ---------------------------------------------------------------------------
+def _portduino_prefs_dir(config_name: str) -> pathlib.Path:
+    home = pathlib.Path.home()
+    return home / ".portduino" / config_name / "prefs"
+
+
+def _push_portduino(
+    size: int,
+    jsonl: pathlib.Path,
+    portduino_config: str,
+    backup_existing: bool,
+) -> dict[str, Any]:
+    prefs = _portduino_prefs_dir(portduino_config)
+    prefs.mkdir(parents=True, exist_ok=True)
+    target = prefs / "nodes.proto"
+    backed_up_to: str | None = None
+    if backup_existing and target.is_file():
+        ts = int(time.time())
+        backup = prefs / f"nodes.proto.bak.{ts}"
+        shutil.move(str(target), str(backup))
+        backed_up_to = str(backup)
+    _compile_proto(jsonl, target)
+    raw = target.read_bytes()
+    return {
+        "transport": "portduino",
+        "path": str(target),
+        "bytes": len(raw),
+        "sha256": hashlib.sha256(raw).hexdigest(),
+        "jsonl_source": str(jsonl),
+        "backed_up_to": backed_up_to,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Hardware push — XModem over BLE/serial via the meshtastic Python interface.
+# ---------------------------------------------------------------------------
+@dataclasses.dataclass
+class _AckEvent:
+    control: int
+    seq: int
+
+
+def _wait_for_response(q: "queue.Queue[_AckEvent]", timeout_s: float) -> _AckEvent:
+    try:
+        return q.get(timeout=timeout_s)
+    except queue.Empty as exc:
+        raise FixtureError(
+            f"XModem response timeout after {timeout_s:.1f}s — device not responding"
+        ) from exc
+
+
+def _push_hardware(
+    size: int,
+    jsonl: pathlib.Path,
+    port: str | None,
+    reboot_after: bool,
+) -> dict[str, Any]:
+    # Lazy imports so the module loads even when the meshtastic deps aren't
+    # available (e.g. CI in a Python env without the package installed).
+    try:
+        from meshtastic.protobuf import mesh_pb2, xmodem_pb2
+        from pubsub import pub
+    except ImportError as exc:  # pragma: no cover — dep missing
+        raise FixtureError(
+            f"hardware push requires the meshtastic + pypubsub packages: {exc}"
+        ) from exc
+
+    if is_tcp_port(port):
+        raise FixtureError(
+            "hardware push over TCP/portduino is not supported — use "
+            "target='portduino' to drop the fixture directly into the prefs dir."
+        )
+
+    # Compile the fixture to a temp file with fresh timestamps.
+    with tempfile.NamedTemporaryFile(suffix=".proto", delete=False) as tf:
+        proto_path = pathlib.Path(tf.name)
+    try:
+        _compile_proto(jsonl, proto_path)
+        payload = proto_path.read_bytes()
+    finally:
+        proto_path.unlink(missing_ok=True)
+
+    sha256 = hashlib.sha256(payload).hexdigest()
+    total_bytes = len(payload)
+
+    # Subscribe to XModem responses BEFORE we open the interface, so we don't
+    # race the first ACK that arrives during the SOH/seq=0 handshake.
+    #
+    # NB: the signature MUST declare every kwarg pypubsub will see for this
+    # topic, or pubsub locks the topic spec to a smaller set (whichever
+    # subscribe arrives first) and then *rejects* the meshtastic library's
+    # publish call with `SenderUnknownMsgDataError: unknown ... interface`.
+    # The meshtastic lib publishes both `packet=` and `interface=`
+    # (mesh_interface.py:1389-1395), so both must appear here.
+    response_q: "queue.Queue[_AckEvent]" = queue.Queue()
+
+    def _on_xmodem(packet: Any = None, interface: Any = None, **_kw: Any) -> None:
+        if packet is None:
+            return
+        response_q.put(_AckEvent(control=int(packet.control), seq=int(packet.seq)))
+
+    pub.subscribe(_on_xmodem, "meshtastic.xmodempacket")
+
+    chunks_sent = 0
+    retried = 0
+    rebooted = False
+
+    XMC = xmodem_pb2.XModem.Control
+    try:
+        with connect(port=port) as iface:
+            # 1) Send the filename (SOH, seq=0).
+            init_pkt = xmodem_pb2.XModem(
+                control=XMC.Value("SOH"),
+                seq=0,
+                buffer=_DEFAULT_NODES_FILENAME.encode("utf-8"),
+            )
+            iface._sendToRadio(mesh_pb2.ToRadio(xmodemPacket=init_pkt))
+            ack = _wait_for_response(response_q, _ACK_TIMEOUT_INIT_S)
+            if ack.control != XMC.Value("ACK"):
+                raise FixtureError(
+                    f"device refused filename {_DEFAULT_NODES_FILENAME!r} "
+                    f"(got control={ack.control}, expected ACK). "
+                    f"Filesystem full or permissions issue?"
+                )
+
+            # 2) Stream the payload in 128 B chunks.
+            for offset in range(0, total_bytes, _XMODEM_CHUNK):
+                chunk = payload[offset : offset + _XMODEM_CHUNK]
+                if len(chunk) < _XMODEM_CHUNK:
+                    # Pad final chunk to 128 B with SUB. The trailing 0x1A bytes
+                    # become part of the file on-device, but nanopb ignores
+                    # bytes past the end of the top-level message.
+                    chunk = chunk + bytes([_XMODEM_SUB] * (_XMODEM_CHUNK - len(chunk)))
+                seq = ((offset // _XMODEM_CHUNK) + 1) % 256
+                # Retry loop on NAK / timeout.
+                attempts = 0
+                while True:
+                    pkt = xmodem_pb2.XModem(
+                        control=XMC.Value("SOH"),
+                        seq=seq,
+                        buffer=chunk,
+                        crc16=_crc16_ccitt(chunk),
+                    )
+                    iface._sendToRadio(mesh_pb2.ToRadio(xmodemPacket=pkt))
+                    ack = _wait_for_response(response_q, _ACK_TIMEOUT_CHUNK_S)
+                    if ack.control == XMC.Value("ACK"):
+                        chunks_sent += 1
+                        break
+                    if ack.control == XMC.Value("NAK"):
+                        attempts += 1
+                        retried += 1
+                        if attempts >= _MAX_CHUNK_RETRIES:
+                            # Abort: send CAN so the firmware removes the half-
+                            # written file via FSCom.remove(filename).
+                            iface._sendToRadio(
+                                mesh_pb2.ToRadio(
+                                    xmodemPacket=xmodem_pb2.XModem(
+                                        control=XMC.Value("CAN")
+                                    )
+                                )
+                            )
+                            raise FixtureError(
+                                f"chunk seq={seq} NAK'd {attempts} times; "
+                                f"aborted transfer (file removed on-device)."
+                            )
+                        continue  # retry the same chunk
+                    raise FixtureError(
+                        f"unexpected XModem control={ack.control} on seq={seq}"
+                    )
+
+            # 3) Tell the device we're done.
+            iface._sendToRadio(
+                mesh_pb2.ToRadio(
+                    xmodemPacket=xmodem_pb2.XModem(control=XMC.Value("EOT"))
+                )
+            )
+            ack = _wait_for_response(response_q, _ACK_TIMEOUT_CHUNK_S)
+            if ack.control != XMC.Value("ACK"):
+                raise FixtureError(f"EOT not ACKed (got control={ack.control})")
+
+            # 4) Reboot so loadFromDisk picks up the new file.
+            if reboot_after:
+                iface.localNode.reboot(secs=1)
+                rebooted = True
+    finally:
+        try:
+            pub.unsubscribe(_on_xmodem, "meshtastic.xmodempacket")
+        except Exception:
+            pass
+
+    return {
+        "transport": "hardware",
+        "port": port,
+        "filename_on_device": _DEFAULT_NODES_FILENAME,
+        "bytes": total_bytes,
+        "chunks_sent": chunks_sent,
+        "retried": retried,
+        "sha256": sha256,
+        "jsonl_source": str(jsonl),
+        "rebooted": rebooted,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Public entry point — registered as an MCP tool in server.py.
+# ---------------------------------------------------------------------------
+def push_fake_nodedb(
+    size: int,
+    target: Literal["portduino", "hardware"] = "portduino",
+    *,
+    port: str | None = None,
+    portduino_config: str = "default",
+    backup_existing: bool = True,
+    confirm: bool = False,
+    reboot_after: bool = True,
+    custom_seed_jsonl: str | None = None,
+) -> dict[str, Any]:
+    """Compile a fresh-timestamp NodeDatabase fixture and push it to a device.
+
+    Args:
+      size: 250, 500, 1000, or 2000 — selects which committed seed JSONL to use.
+      target: "portduino" (file copy to ~/.portduino/<config>/prefs/) or
+              "hardware" (XModem upload to /prefs/nodes.proto + reboot).
+      port: required for target="hardware". Serial path (e.g. /dev/cu.usbmodemXXXX)
+            or BLE identifier. TCP endpoints are rejected — use target="portduino"
+            instead.
+      portduino_config: which Portduino instance dir under ~/.portduino/. Default "default".
+      backup_existing: portduino only. Move nodes.proto -> nodes.proto.bak.<ts>
+                        if present, so you can roll back.
+      confirm: required True for target="hardware" (writes flash + reboots).
+      reboot_after: hardware only. If True, send a 1-second reboot after the
+                    final ACK so loadFromDisk picks up the new file at next boot.
+      custom_seed_jsonl: override the committed JSONL. Use to push a hand-edited
+                         test scenario.
+
+    Returns:
+        dict with transport, bytes, sha256, etc. — depends on target.
+
+    """
+    if size not in _VALID_SIZES:
+        raise FixtureError(
+            f"size must be one of {_VALID_SIZES}; got {size!r}. "
+            f"Add a new committed seed if you need a different cardinality."
+        )
+
+    jsonl = _resolve_seed_jsonl(size, custom_seed_jsonl)
+
+    if target == "portduino":
+        return _push_portduino(size, jsonl, portduino_config, backup_existing)
+
+    if target == "hardware":
+        if not confirm:
+            raise FixtureError(
+                "hardware push writes flash and triggers a reboot — pass confirm=True."
+            )
+        if not port:
+            raise FixtureError(
+                "target='hardware' requires a port (e.g. /dev/cu.usbmodemXXXX)."
+            )
+        return _push_hardware(size, jsonl, port, reboot_after)
+
+    raise FixtureError(f"unknown target {target!r}; expected 'portduino' or 'hardware'")

mcp-server/src/meshtastic_mcp/server.py

@@ -15,6 +15,7 @@ from . import (
     admin,
     boards,
     devices,
+    fixtures,
     flash,
     hw_tools,
     info,
@@ -963,3 +964,45 @@ def recorder_export(
         dest_dir=dest_dir,
         streams=streams,
     )
+
+
+# ---------- Fixture / test-data push --------------------------------------
+
+
+@app.tool()
+def push_fake_nodedb(
+    size: int,
+    target: str = "portduino",
+    port: str | None = None,
+    portduino_config: str = "default",
+    backup_existing: bool = True,
+    confirm: bool = False,
+    reboot_after: bool = True,
+    custom_seed_jsonl: str | None = None,
+) -> dict[str, Any]:
+    """Push a fake-NodeDB v25 fixture (250/500/1000/2000 nodes) onto a device.
+
+    Two transports:
+      target="portduino" — file copy to ~/.portduino/<portduino_config>/prefs/nodes.proto.
+                            Fast, no device connection needed.
+      target="hardware"  — XModem upload over serial/BLE to /prefs/nodes.proto.
+                            Requires `port` + `confirm=True`. Triggers a reboot
+                            so loadFromDisk picks up the new file at next boot.
+
+    Compiles a fresh-timestamp proto from the committed JSONL seed under
+    test/fixtures/nodedb/seed_v25_<N>.jsonl each invocation, so the loaded
+    NodeDB always looks "recent" to the connecting phone. Structural data
+    (names, IDs, positions, telemetries) is deterministic per the seed.
+
+    Override the JSONL via `custom_seed_jsonl` to push a hand-edited scenario.
+    """
+    return fixtures.push_fake_nodedb(
+        size=size,
+        target=target,  # type: ignore[arg-type]
+        port=port,
+        portduino_config=portduino_config,
+        backup_existing=backup_existing,
+        confirm=confirm,
+        reboot_after=reboot_after,
+        custom_seed_jsonl=custom_seed_jsonl,
+    )

mcp-server/tests/unit/test_fake_nodedb_generator.py

@@ -0,0 +1,364 @@
+"""Tests for the fake-NodeDB fixture pipeline (bin/gen-fake-nodedb-seed.py
++ bin/seed-json-to-proto.py + mcp-server fixtures.push_fake_nodedb).
+
+Lives under tests/unit/ because none of these touch real hardware — they
+shell out to the bin/ scripts and decode the resulting protobufs in-process.
+"""
+
+from __future__ import annotations
+
+import json
+import pathlib
+import subprocess
+import sys
+import time
+
+import pytest
+
+REPO_ROOT = pathlib.Path(__file__).resolve().parents[3]
+SEED_GEN = REPO_ROOT / "bin" / "gen-fake-nodedb-seed.py"
+COMPILE = REPO_ROOT / "bin" / "seed-json-to-proto.py"
+FIXTURES_DIR = REPO_ROOT / "test" / "fixtures" / "nodedb"
+
+# Ensure the locally-generated Python protobuf bindings are importable.
+# These live under `meshtastic_v25` (not `meshtastic`) so they don't shadow
+# the PyPI `meshtastic` package that the rest of the mcp-server depends on.
+_BINDINGS_DIR = REPO_ROOT / "bin" / "_generated"
+if _BINDINGS_DIR.is_dir() and str(_BINDINGS_DIR) not in sys.path:
+    sys.path.insert(0, str(_BINDINGS_DIR))
+
+try:
+    from meshtastic_v25.deviceonly_pb2 import (
+        NodeDatabase,  # type: ignore[import-not-found]
+    )
+except ImportError:
+    NodeDatabase = None  # type: ignore[assignment]
+
+
+def _require_v25_bindings() -> None:
+    if NodeDatabase is None:
+        pytest.skip(
+            "v25 Python protobuf bindings missing; run `./bin/regen-py-protos.sh`."
+        )
+    if "positions" not in NodeDatabase.DESCRIPTOR.fields_by_name:
+        pytest.skip(
+            "Loaded NodeDatabase predates v25 — run `./bin/regen-py-protos.sh`."
+        )
+
+
+def _run(cmd: list[str]) -> None:
+    subprocess.check_call(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
+
+
+# ---------------------------------------------------------------------------
+# Seed generator: deterministic for given --seed (no wall-clock dependence).
+# ---------------------------------------------------------------------------
+def test_seed_generator_is_deterministic(tmp_path: pathlib.Path) -> None:
+    a = tmp_path / "a.jsonl"
+    b = tmp_path / "b.jsonl"
+    _run(
+        [
+            sys.executable,
+            str(SEED_GEN),
+            "--count",
+            "100",
+            "--seed",
+            "42",
+            "--out",
+            str(a),
+        ]
+    )
+    # Sleep so any sneaky wall-clock leak in the generator would surface as
+    # a byte diff between the two runs.
+    time.sleep(0.8)
+    _run(
+        [
+            sys.executable,
+            str(SEED_GEN),
+            "--count",
+            "100",
+            "--seed",
+            "42",
+            "--out",
+            str(b),
+        ]
+    )
+    assert a.read_bytes() == b.read_bytes()
+
+
+def test_seed_generator_meta_line(tmp_path: pathlib.Path) -> None:
+    out = tmp_path / "seed.jsonl"
+    _run(
+        [
+            sys.executable,
+            str(SEED_GEN),
+            "--count",
+            "50",
+            "--seed",
+            "1",
+            "--out",
+            str(out),
+        ]
+    )
+    lines = out.read_text(encoding="utf-8").splitlines()
+    assert len(lines) == 51  # 1 meta + 50 nodes
+    meta = json.loads(lines[0])
+    assert "_meta" in meta
+    assert meta["_meta"]["version"] == 25
+    assert meta["_meta"]["count"] == 50
+    assert meta["_meta"]["seed"] == 1
+
+
+def test_seed_only_uses_active_hardware_and_roles(tmp_path: pathlib.Path) -> None:
+    """Confirm no deprecated roles + no off-list HW models leak through."""
+    out = tmp_path / "seed.jsonl"
+    _run(
+        [
+            sys.executable,
+            str(SEED_GEN),
+            "--count",
+            "500",
+            "--seed",
+            "7",
+            "--out",
+            str(out),
+        ]
+    )
+    forbidden_roles = {"ROUTER_CLIENT", "REPEATER"}
+    forbidden_hw = {
+        "TLORA_V1",
+        "TLORA_V2",
+        "TLORA_V1_1P3",
+        "TLORA_V2_1_1P6",
+        "TLORA_V2_1_1P8",
+        "HELTEC_V1",
+        "HELTEC_V2_0",
+        "HELTEC_V2_1",
+        "TBEAM",
+        "TBEAM_V0P7",
+        "NANO_G1",
+        "NANO_G1_EXPLORER",
+        "NANO_G2_ULTRA",
+        "STATION_G1",
+        "STATION_G2",
+        "PORTDUINO",
+        "ANDROID_SIM",
+        "DIY_V1",
+        "LORA_RELAY_V1",
+        "NRF52840_PCA10059",
+        "NRF52_UNKNOWN",
+        "DR_DEV",
+        "GENIEBLOCKS",
+        "M5STACK",
+        "RP2040_LORA",
+        "PPR",
+    }
+    for raw in out.read_text(encoding="utf-8").splitlines()[1:]:
+        node = json.loads(raw)
+        assert node["role"] not in forbidden_roles, f"deprecated role: {node['role']}"
+        assert (
+            node["hw_model"] not in forbidden_hw
+        ), f"non-tier-1 HW: {node['hw_model']}"
+
+
+# ---------------------------------------------------------------------------
+# Compile step + committed seeds.
+# ---------------------------------------------------------------------------
+@pytest.mark.parametrize("size", [250, 500, 1000, 2000])
+def test_committed_seed_compiles_and_decodes(size: int, tmp_path: pathlib.Path) -> None:
+    _require_v25_bindings()
+    proto = tmp_path / "out.proto"
+    jsonl = FIXTURES_DIR / f"seed_v25_{size:04d}.jsonl"
+    if not jsonl.is_file():
+        pytest.skip(f"{jsonl} not present — run ./bin/regen-fake-nodedbs.sh")
+    _run([sys.executable, str(COMPILE), "--in", str(jsonl), "--out", str(proto)])
+
+    db = NodeDatabase()
+    db.ParseFromString(proto.read_bytes())
+    assert db.version == 25
+    assert len(db.nodes) == size
+    nums = {n.num for n in db.nodes}
+    assert len(nums) == size, "node numbers must be unique"
+    assert all(n.long_name and n.short_name for n in db.nodes)
+    assert all(len(n.long_name) <= 24 for n in db.nodes)  # max_size:25 - NUL
+
+    # Coverage sanity (±10pp tolerance for binomial fluctuation).
+    def in_range(actual: int, expected_ratio: float, tol_pp: float = 0.10) -> bool:
+        lo = max(0, int((expected_ratio - tol_pp) * size))
+        hi = min(size, int((expected_ratio + tol_pp) * size))
+        return lo <= actual <= hi
+
+    assert in_range(len(db.positions), 0.85)
+    assert in_range(len(db.telemetry), 0.70)
+    assert in_range(len(db.environment), 0.25)
+    assert in_range(len(db.status), 0.40)
+
+
+def test_compile_freshens_timestamps(tmp_path: pathlib.Path) -> None:
+    """Same JSONL compiled twice → identical structure, different timestamps."""
+    _require_v25_bindings()
+    jsonl = FIXTURES_DIR / "seed_v25_0250.jsonl"
+    if not jsonl.is_file():
+        pytest.skip("250-node seed not present — run ./bin/regen-fake-nodedbs.sh")
+    a = tmp_path / "a.proto"
+    b = tmp_path / "b.proto"
+    _run([sys.executable, str(COMPILE), "--in", str(jsonl), "--out", str(a)])
+    time.sleep(1.2)
+    _run([sys.executable, str(COMPILE), "--in", str(jsonl), "--out", str(b)])
+
+    da = NodeDatabase()
+    db_ = NodeDatabase()
+    da.ParseFromString(a.read_bytes())
+    db_.ParseFromString(b.read_bytes())
+
+    # Zero out timestamp fields and confirm everything else is byte-identical.
+    for d in (da, db_):
+        for n in d.nodes:
+            n.last_heard = 0
+        for p in d.positions:
+            p.position.time = 0
+    assert da.SerializeToString() == db_.SerializeToString()
+
+    # Re-load fresh copies to confirm timestamps actually moved.
+    aa = NodeDatabase()
+    bb = NodeDatabase()
+    aa.ParseFromString(a.read_bytes())
+    bb.ParseFromString(b.read_bytes())
+    aa_max = max(n.last_heard for n in aa.nodes if n.last_heard)
+    bb_max = max(n.last_heard for n in bb.nodes if n.last_heard)
+    assert bb_max >= aa_max
+    assert bb_max - aa_max < 5  # within a few seconds
+
+
+def test_compile_pinned_now_epoch_is_byte_identical(tmp_path: pathlib.Path) -> None:
+    """With --now-epoch pinned, two compiles produce identical bytes."""
+    _require_v25_bindings()
+    jsonl = FIXTURES_DIR / "seed_v25_0250.jsonl"
+    if not jsonl.is_file():
+        pytest.skip("250-node seed not present")
+    a = tmp_path / "a.proto"
+    b = tmp_path / "b.proto"
+    for o in (a, b):
+        _run(
+            [
+                sys.executable,
+                str(COMPILE),
+                "--in",
+                str(jsonl),
+                "--now-epoch",
+                "1700000000",
+                "--out",
+                str(o),
+            ]
+        )
+    assert a.read_bytes() == b.read_bytes()
+
+
+def test_compile_timestamps_are_recent(tmp_path: pathlib.Path) -> None:
+    _require_v25_bindings()
+    jsonl = FIXTURES_DIR / "seed_v25_0250.jsonl"
+    if not jsonl.is_file():
+        pytest.skip("250-node seed not present")
+    out = tmp_path / "out.proto"
+    _run([sys.executable, str(COMPILE), "--in", str(jsonl), "--out", str(out)])
+    db = NodeDatabase()
+    db.ParseFromString(out.read_bytes())
+    now = int(time.time())
+    # No timestamp older than 7 days, none in the future.
+    for n in db.nodes:
+        if n.last_heard:
+            assert now - 7 * 86400 <= n.last_heard <= now
+    # At least half should be within the last hour
+    # (matches expovariate(mean=3600s)).
+    recent = sum(1 for n in db.nodes if n.last_heard and n.last_heard >= now - 3600)
+    assert recent >= 0.4 * len(db.nodes)
+
+
+def test_compile_hand_edit_round_trip(tmp_path: pathlib.Path) -> None:
+    """Edit one JSONL line, recompile, confirm edit appears in the proto."""
+    _require_v25_bindings()
+    src = FIXTURES_DIR / "seed_v25_0250.jsonl"
+    if not src.is_file():
+        pytest.skip("250-node seed not present")
+    dst = tmp_path / "edited.jsonl"
+    lines = src.read_text(encoding="utf-8").splitlines()
+
+    # Find a node that already has telemetry so the index relationship is
+    # easy to assert on the other side.
+    edit_idx = None
+    for i, raw in enumerate(lines[1:], start=1):
+        node = json.loads(raw)
+        if node.get("telemetry") is not None:
+            edit_idx = i
+            break
+    assert edit_idx is not None, "expected at least one node with telemetry"
+
+    node = json.loads(lines[edit_idx])
+    target_num = int(node["num"], 16)
+    node["long_name"] = "Hand Edited Node"
+    node["telemetry"] = {
+        "battery_level": 42,
+        "voltage": 3.71,
+        "channel_utilization": 0.0,
+        "air_util_tx": 0.0,
+        "uptime_seconds": 1,
+    }
+    lines[edit_idx] = json.dumps(node, ensure_ascii=False, sort_keys=True)
+    dst.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+    out = tmp_path / "out.proto"
+    _run([sys.executable, str(COMPILE), "--in", str(dst), "--out", str(out)])
+    db = NodeDatabase()
+    db.ParseFromString(out.read_bytes())
+    edited = next((n for n in db.nodes if n.num == target_num), None)
+    assert edited is not None
+    assert edited.long_name == "Hand Edited Node"
+    tel = next((t for t in db.telemetry if t.num == target_num), None)
+    assert tel is not None
+    assert tel.device_metrics.battery_level == 42
+
+
+# ---------------------------------------------------------------------------
+# Misc smoke checks on the module surface.
+# ---------------------------------------------------------------------------
+def test_crc16_ccitt_matches_known_vectors() -> None:
+    """Sanity-check the hand-rolled CRC16-CCITT matches well-known vectors.
+
+    Test vectors from the XModem-CRC spec (init=0, poly=0x1021):
+      crc16("123456789") = 0x31C3
+      crc16("")          = 0x0000
+    """
+    from meshtastic_mcp.fixtures import _crc16_ccitt
+
+    assert _crc16_ccitt(b"") == 0x0000
+    assert _crc16_ccitt(b"123456789") == 0x31C3
+
+
+def test_push_fake_nodedb_rejects_invalid_size() -> None:
+    from meshtastic_mcp.fixtures import FixtureError, push_fake_nodedb
+
+    with pytest.raises(FixtureError, match="size must be one of"):
+        push_fake_nodedb(size=999, target="portduino")  # type: ignore[arg-type]
+
+
+def test_push_fake_nodedb_hardware_requires_confirm() -> None:
+    from meshtastic_mcp.fixtures import FixtureError, push_fake_nodedb
+
+    with pytest.raises(FixtureError, match="confirm=True"):
+        push_fake_nodedb(size=250, target="hardware", port="/dev/cu.fake")
+
+
+def test_push_fake_nodedb_hardware_requires_port() -> None:
+    from meshtastic_mcp.fixtures import FixtureError, push_fake_nodedb
+
+    with pytest.raises(FixtureError, match="requires a port"):
+        push_fake_nodedb(size=250, target="hardware", confirm=True)
+
+
+def test_push_fake_nodedb_hardware_rejects_tcp_port() -> None:
+    from meshtastic_mcp.fixtures import FixtureError, push_fake_nodedb
+
+    with pytest.raises(FixtureError, match="not supported"):
+        push_fake_nodedb(
+            size=250, target="hardware", confirm=True, port="tcp://localhost:4403"
+        )

platformio.ini

@@ -17,6 +17,7 @@ test_build_src = true
 extra_scripts =
 	pre:bin/platformio-pre.py
 	bin/platformio-custom.py
+	post:extra_scripts/nrf54l15_linker.py
 ; note: we add src to our include search path so that lmic_project_config can override
 ; note: TINYGPS_OPTION_NO_CUSTOM_FIELDS is VERY important.  We don't use custom fields and somewhere in that pile
 ; of code is a heap corruption bug!
@@ -49,6 +50,7 @@ build_flags = -Wno-missing-field-initializers
 	-DRADIOLIB_EXCLUDE_PAGER=1
 	-DRADIOLIB_EXCLUDE_FSK4=1
 	-DRADIOLIB_EXCLUDE_APRS=1
+	-DRADIOLIB_EXCLUDE_ADSB=1
 	-DRADIOLIB_EXCLUDE_LORAWAN=1
 	-DMESHTASTIC_EXCLUDE_DROPZONE=1
 	-DMESHTASTIC_EXCLUDE_REPLYBOT=1
@@ -125,7 +127,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/91d4f76d9fc523fb86ea31ebf48fd4bcdaea43c9.zip
 
 ; Common libs for environmental measurements in telemetry module
 [environmental_base]
@@ -137,7 +139,7 @@ lib_deps =
 	# renovate: datasource=github-tags depName=Adafruit GFX packageName=adafruit/Adafruit-GFX-Library
 	https://github.com/adafruit/Adafruit-GFX-Library/archive/refs/tags/1.12.6.zip
 	# renovate: datasource=github-tags depName=NeoPixel packageName=adafruit/Adafruit_NeoPixel
-	https://github.com/adafruit/Adafruit_NeoPixel/archive/refs/tags/1.15.4.zip
+	https://github.com/adafruit/Adafruit_NeoPixel/archive/1.15.5.zip
 	# renovate: datasource=github-tags depName=Adafruit SSD1306 packageName=adafruit/Adafruit_SSD1306
 	https://github.com/adafruit/Adafruit_SSD1306/archive/refs/tags/2.5.16.zip
 	# renovate: datasource=github-tags depName=Adafruit BMP280 packageName=adafruit/Adafruit_BMP280_Library

src/DebugConfiguration.cpp

@@ -151,7 +151,7 @@ inline bool Syslog::_sendLog(uint16_t pri, const char *appName, const char *mess
     if (!this->_enabled)
         return false;
 
-    if ((this->_server == NULL && this->_ip == INADDR_NONE) || this->_port == 0)
+    if ((this->_server == NULL && this->_ip == IPAddress(0, 0, 0, 0)) || this->_port == 0)
         return false;
 
     // Check priority against priMask values.

src/DebugConfiguration.h

@@ -13,6 +13,11 @@ extern MemGet memGet;
 #define LED_STATE_ON 1
 #endif
 
+// WIFI LED
+#ifndef WIFI_STATE_ON
+#define WIFI_STATE_ON 1
+#endif
+
 // -----------------------------------------------------------------------------
 // DEBUG
 // -----------------------------------------------------------------------------
@@ -147,7 +152,9 @@ extern "C" void logLegacy(const char *level, const char *fmt, ...);
 // Default Bluetooth PIN
 #define defaultBLEPin 123456
 
-#if HAS_ETHERNET && !defined(USE_WS5500)
+#if HAS_ETHERNET && defined(USE_CH390D)
+#include <ESP32_CH390.h>
+#elif HAS_ETHERNET && !defined(USE_WS5500)
 #include <RAK13800_W5100S.h>
 #endif // HAS_ETHERNET
 

src/FSCommon.h

@@ -48,6 +48,14 @@ using namespace STM32_LittleFS_Namespace;
 using namespace Adafruit_LittleFS_Namespace;
 #endif
 
+#if defined(ARCH_NRF54L15)
+// nRF54L15 — Zephyr LittleFS on 36 KB storage_partition (internal RRAM)
+#include "InternalFileSystem.h"
+#define FSCom InternalFS
+#define FSBegin() FSCom.begin()
+using namespace Adafruit_LittleFS_Namespace;
+#endif
+
 void fsInit();
 void fsListFiles();
 bool copyFile(const char *from, const char *to);

src/MessageStore.cpp

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

src/MessageStore.h

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

src/Power.cpp

@@ -176,6 +176,12 @@ XPowersPPM *PPM = NULL;
 #include "bq27220.h"
 #endif
 
+#ifdef HAS_SY6970
+#include "hardware/Arduino_HWIIC.h"
+#include "power_chip/Arduino_SY6970.h"
+Arduino_SY6970 *SY6970 = NULL;
+#endif
+
 #ifdef HAS_PMU
 XPowersLibInterface *PMU = NULL;
 #else
@@ -904,7 +910,16 @@ void Power::readPowerStatus()
 
     // Notify any status instances that are observing us
     const PowerStatus powerStatus2 = PowerStatus(hasBattery, usbPowered, isChargingNow, batteryVoltageMv, batteryChargePercent);
-    if (millis() > lastLogTime + 50 * 1000) {
+
+    // Log battery-presence transitions once; skip OptUnknown so we don't lie before the first probe.
+    static OptionalBool prevHasBattery = OptUnknown;
+    if (hasBattery != OptUnknown && hasBattery != prevHasBattery) {
+        LOG_INFO("Power: battery hardware %s", hasBattery == OptTrue ? "detected" : "absent (USB-only)");
+        prevHasBattery = hasBattery;
+    }
+
+    // Periodic telemetry only emits when a battery is actually present (otherwise values are constant -1/0).
+    if (hasBattery == OptTrue && !Throttle::isWithinTimespanMs(lastLogTime, 50 * 1000)) {
         LOG_DEBUG("Battery: usbPower=%d, isCharging=%d, batMv=%d, batPct=%d", powerStatus2.getHasUSB(),
                   powerStatus2.getIsCharging(), powerStatus2.getBatteryVoltageMv(), powerStatus2.getBatteryChargePercent());
         lastLogTime = millis();
@@ -1582,7 +1597,7 @@ bool Power::cw2015Init()
 }
 #endif
 
-#if defined(HAS_PPM) && HAS_PPM
+#ifdef HAS_PPM
 
 /**
  * Adapter class for BQ25896/BQ27220 Lipo battery charger.
@@ -1699,6 +1714,96 @@ class LipoCharger : public HasBatteryLevel
     }
 };
 
+#elif defined(HAS_SY6970)
+
+/**
+ * Adapter class for SY6970 battery charger.
+ */
+class LipoCharger : public HasBatteryLevel
+{
+  public:
+    /**
+     * Init the I2C SY6970 Lipo battery charger
+     */
+    bool runOnce()
+    {
+        if (SY6970 == nullptr) {
+            SY6970 = new Arduino_SY6970(std::make_shared<Arduino_HWIIC>(Arduino_HWIIC(SDA, SCL, &Wire)), SY6970_DEVICE_ADDRESS);
+            bool result = SY6970->begin();
+            if (result) {
+                // some boards can boot with HIZ set, which suppresses normal input/battery behavior
+                result |=
+                    SY6970->IIC_Write_Device_State(Arduino_IIC_Power::POWER_DEVICE_HIZ_MODE, Arduino_IIC_Power::POWER_DEVICE_OFF);
+                result |= SY6970->IIC_Write_Device_State(Arduino_IIC_Power::POWER_DEVICE_CHARGING_MODE,
+                                                         Arduino_IIC_Power::POWER_DEVICE_ON);
+                result |= SY6970->IIC_Write_Device_State(Arduino_IIC_Power::POWER_DEVICE_ADC_MEASURE,
+                                                         Arduino_IIC_Power::POWER_DEVICE_ON);
+                // clear watchdog timer once, then keep watchdog disabled
+                result |= SY6970->IIC_Write_Device_State(Arduino_IIC_Power::POWER_DEVICE_WATCHDOG_TIMER_RESET,
+                                                         Arduino_IIC_Power::POWER_DEVICE_ON);
+
+                if (result) {
+                    SY6970->IIC_Write_Device_Value(Arduino_IIC_Power::POWER_DEVICE_WATCHDOG_TIMER, 0);
+                    SY6970->IIC_Write_Device_Value(Arduino_IIC_Power::POWER_DEVICE_CHARGING_TARGET_VOLTAGE_LIMIT, 4284);
+                    SY6970->IIC_Write_Device_Value(Arduino_IIC_Power::POWER_DEVICE_MINIMUM_SYSTEM_VOLTAGE_LIMIT, 3300);
+                    SY6970->IIC_Write_Device_Value(Arduino_IIC_Power::POWER_DEVICE_INPUT_CURRENT_LIMIT, 500);
+                    SY6970->IIC_Write_Device_Value(Arduino_IIC_Power::POWER_DEVICE_FAST_CHARGING_CURRENT_LIMIT, 2112);
+                    SY6970->IIC_Write_Device_Value(Arduino_IIC_Power::POWER_DEVICE_PRECHARGE_CHARGING_CURRENT_LIMIT, 192);
+                    SY6970->IIC_Write_Device_Value(Arduino_IIC_Power::POWER_DEVICE_TERMINATION_CHARGING_CURRENT_LIMIT, 320);
+                    LOG_INFO("SY6970 init succeeded");
+                    return true;
+                }
+            }
+            LOG_WARN("SY6970 init failed");
+            delete SY6970;
+            SY6970 = nullptr;
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Battery state of charge, from 0 to 100 or -1 for unknown
+     */
+    virtual int getBatteryPercent() override { return -1; }
+
+    /**
+     * The raw voltage of the battery in millivolts, or NAN if unknown
+     */
+    virtual uint16_t getBattVoltage() override
+    {
+        double battVoltage = SY6970->IIC_Read_Device_Value(Arduino_IIC_Power::POWER_BATTERY_VOLTAGE);
+        return (battVoltage > 0.0) ? static_cast<uint16_t>(battVoltage) : 0;
+    }
+
+    /**
+     * return true if there is a battery installed in this unit
+     */
+    virtual bool isBatteryConnect() override { return true; }
+
+    /**
+     * return true if there is an external power source detected
+     */
+    virtual bool isVbusIn() override { return SY6970->IIC_Read_Device_Value(Arduino_IIC_Power::POWER_SYSTEM_VOLTAGE) > 4200.0; }
+
+    /**
+     * return true if the battery is currently charging
+     */
+    virtual bool isCharging() override { return SY6970->IIC_Read_Device_Value(Arduino_IIC_Power::POWER_CHARGING_CURRENT) > 1.0; }
+};
+
+#else
+
+/**
+ * The Lipo battery level sensor is unavailable - default to AnalogBatteryLevel
+ */
+bool Power::lipoChargerInit()
+{
+    return false;
+}
+#endif
+
+#if defined(HAS_PPM) || defined(HAS_SY6970)
 LipoCharger lipoCharger;
 
 /**
@@ -1707,21 +1812,12 @@ LipoCharger lipoCharger;
 bool Power::lipoChargerInit()
 {
     bool result = lipoCharger.runOnce();
-    LOG_DEBUG("Power::lipoChargerInit lipo sensor is %s", result ? "ready" : "not ready yet");
+    LOG_DEBUG("Power::lipoChargerInit lipo charger is %s", result ? "ready" : "not ready yet");
     if (!result)
         return false;
     batteryLevel = &lipoCharger;
     return true;
 }
-
-#else
-/**
- * The Lipo battery level sensor is unavailable - default to AnalogBatteryLevel
- */
-bool Power::lipoChargerInit()
-{
-    return false;
-}
 #endif
 
 #ifdef HELTEC_MESH_SOLAR

src/RedirectablePrint.cpp

@@ -225,14 +225,16 @@ void RedirectablePrint::log_to_ble(const char *logLevel, const char *format, va_
         isBleConnected = nimbleBluetooth && nimbleBluetooth->isActive() && nimbleBluetooth->isConnected();
 #elif defined(ARCH_NRF52)
         isBleConnected = nrf52Bluetooth != nullptr && nrf52Bluetooth->isConnected();
+#elif defined(ARCH_NRF54L15)
+        isBleConnected = nrf54l15Bluetooth != nullptr && nrf54l15Bluetooth->isConnected();
 #endif
         if (isBleConnected) {
             auto thread = concurrency::OSThread::currentThread;
             meshtastic_LogRecord logRecord = meshtastic_LogRecord_init_zero;
             logRecord.level = getLogLevel(logLevel);
-            vsprintf(logRecord.message, format, arg);
+            vsnprintf(logRecord.message, sizeof(logRecord.message), format, arg);
             if (thread)
-                strcpy(logRecord.source, thread->ThreadName.c_str());
+                strlcpy(logRecord.source, thread->ThreadName.c_str(), sizeof(logRecord.source));
             logRecord.time = getValidTime(RTCQuality::RTCQualityDevice, true);
 
             auto buffer = std::unique_ptr<uint8_t[]>(new uint8_t[meshtastic_LogRecord_size]);
@@ -241,6 +243,8 @@ void RedirectablePrint::log_to_ble(const char *logLevel, const char *format, va_
             nimbleBluetooth->sendLog(buffer.get(), size);
 #elif defined(ARCH_NRF52)
             nrf52Bluetooth->sendLog(buffer.get(), size);
+#elif defined(ARCH_NRF54L15)
+            nrf54l15Bluetooth->sendLog(buffer.get(), size);
 #endif
         }
     }

src/configuration.h

@@ -274,6 +274,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define LTR553ALS_ADDR 0x23
 #define SEN5X_ADDR 0x69
 #define SCD30_ADDR 0x61
+#define SY6970_ADDR 0x6A // same address as LSM6DS3
 
 // -----------------------------------------------------------------------------
 // ACCELEROMETER

src/detect/ScanI2C.h

@@ -97,6 +97,7 @@ class ScanI2C
         CW2015,
         SCD30,
         ADS1115,
+        SY6970
     } DeviceType;
 
     // typedef uint8_t DeviceAddress;

src/detect/ScanI2CTwoWire.cpp

@@ -607,7 +607,23 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
 
                 break;
 
-                SCAN_SIMPLE_CASE(LSM6DS3_ADDR, LSM6DS3, "LSM6DS3", (uint8_t)addr.address);
+            case LSM6DS3_ADDR: {
+                // 1) Try SY6970 signature first: REG14[5:3] == 0b001
+                uint8_t registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x14), 1);
+                if (((registerValue >> 3) & 0x07) == 0x01) {
+                    type = SY6970;
+                    logFoundDevice("SY6970", (uint8_t)addr.address);
+                    break;
+                }
+
+                // 2) Fallback to LSM6DS3 signature: WHO_AM_I == 0x6A
+                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x0F), 1);
+                if (registerValue == 0x6A) {
+                    type = LSM6DS3;
+                    logFoundDevice("LSM6DS3", (uint8_t)addr.address);
+                }
+                break;
+            }
                 SCAN_SIMPLE_CASE(VEML7700_ADDR, VEML7700, "VEML7700", (uint8_t)addr.address);
             case TCA9555_ADDR:
                 registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x01), 1);

src/graphics/Screen.cpp

@@ -65,7 +65,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "mesh/Default.h"
 #include "mesh/generated/meshtastic/deviceonly.pb.h"
 #include "modules/ExternalNotificationModule.h"
-#include "modules/TextMessageModule.h"
 #include "modules/WaypointModule.h"
 #include "sleep.h"
 #include "target_specific.h"
@@ -231,6 +230,7 @@ void Screen::showOverlayBanner(BannerOverlayOptions banner_overlay_options)
 #endif
     // Store the message and set the expiration timestamp
     strncpy(NotificationRenderer::alertBannerMessage, banner_overlay_options.message, 255);
+    NotificationRenderer::parseBannerMessageWithFonts(NotificationRenderer::alertBannerMessage);
     NotificationRenderer::alertBannerMessage[255] = '\0'; // Ensure null termination
     NotificationRenderer::alertBannerUntil =
         (banner_overlay_options.durationMs == 0) ? 0 : millis() + banner_overlay_options.durationMs;
@@ -240,9 +240,9 @@ void Screen::showOverlayBanner(BannerOverlayOptions banner_overlay_options)
     NotificationRenderer::alertBannerCallback = banner_overlay_options.bannerCallback;
     NotificationRenderer::curSelected = banner_overlay_options.InitialSelected;
     NotificationRenderer::pauseBanner = false;
-    NotificationRenderer::current_notification_type = notificationTypeEnum::selection_picker;
+    NotificationRenderer::current_notification_type = banner_overlay_options.notificationType;
     static OverlayCallback overlays[] = {graphics::UIRenderer::drawNavigationBar, NotificationRenderer::drawBannercallback};
-    ui->setOverlays(overlays, sizeof(overlays) / sizeof(overlays[0]));
+    ui->setOverlays(overlays, 2);
     ui->setTargetFPS(60);
     updateUiFrame(ui);
 }
@@ -264,7 +264,7 @@ void Screen::showNodePicker(const char *message, uint32_t durationMs, std::funct
     NotificationRenderer::current_notification_type = notificationTypeEnum::node_picker;
 
     static OverlayCallback overlays[] = {graphics::UIRenderer::drawNavigationBar, NotificationRenderer::drawBannercallback};
-    ui->setOverlays(overlays, sizeof(overlays) / sizeof(overlays[0]));
+    ui->setOverlays(overlays, 2);
     ui->setTargetFPS(60);
     updateUiFrame(ui);
 }
@@ -288,7 +288,7 @@ void Screen::showNumberPicker(const char *message, uint32_t durationMs, uint8_t
     NotificationRenderer::currentNumber = 0;
 
     static OverlayCallback overlays[] = {graphics::UIRenderer::drawNavigationBar, NotificationRenderer::drawBannercallback};
-    ui->setOverlays(overlays, sizeof(overlays) / sizeof(overlays[0]));
+    ui->setOverlays(overlays, 2);
     ui->setTargetFPS(60);
     updateUiFrame(ui);
 }
@@ -311,7 +311,7 @@ void Screen::showTextInput(const char *header, const char *initialText, uint32_t
 
     // Set the overlay using the same pattern as other notification types
     static OverlayCallback overlays[] = {graphics::UIRenderer::drawNavigationBar, NotificationRenderer::drawBannercallback};
-    ui->setOverlays(overlays, sizeof(overlays) / sizeof(overlays[0]));
+    ui->setOverlays(overlays, 2);
     ui->setTargetFPS(60);
     updateUiFrame(ui);
 }
@@ -696,7 +696,7 @@ void Screen::setup()
     static OverlayCallback overlays[] = {
         graphics::UIRenderer::drawNavigationBar // Custom indicator icons for each frame
     };
-    ui->setOverlays(overlays, sizeof(overlays) / sizeof(overlays[0]));
+    ui->setOverlays(overlays, 1);
 
     // Enable UTF-8 to display mapping
     dispdev->setFontTableLookupFunction(customFontTableLookup);
@@ -1313,7 +1313,7 @@ void Screen::setFrames(FrameFocus focus)
 
     // Add overlays: frame icons and alert banner)
     static OverlayCallback overlays[] = {graphics::UIRenderer::drawNavigationBar, NotificationRenderer::drawBannercallback};
-    ui->setOverlays(overlays, sizeof(overlays) / sizeof(overlays[0]));
+    ui->setOverlays(overlays, 2);
 
     prevFrame = -1; // Force drawFavoriteNode to pick a new node (because our list just changed)
 
@@ -1643,138 +1643,6 @@ int Screen::handleStatusUpdate(const meshtastic::Status *arg)
     return 0;
 }
 
-// Handles when message is received; will jump to text message frame.
-int Screen::handleTextMessage(const meshtastic_MeshPacket *packet)
-{
-    if (showingNormalScreen) {
-        if (packet->from == 0) {
-            // Outgoing message (likely sent from phone)
-            devicestate.has_rx_text_message = false;
-            memset(&devicestate.rx_text_message, 0, sizeof(devicestate.rx_text_message));
-            hiddenFrames.textMessage = true;
-            hasUnreadMessage = false; // Clear unread state when user replies
-
-            setFrames(FOCUS_PRESERVE); // Stay on same frame, silently update frame list
-        } else {
-            // Incoming message
-            devicestate.has_rx_text_message = true; // Needed to include the message frame
-            hasUnreadMessage = true;                // Enables mail icon in the header
-            setFrames(FOCUS_PRESERVE);              // Refresh frame list without switching view (no-op during text_input)
-
-            // Only wake/force display if the configuration allows it
-            if (shouldWakeOnReceivedMessage()) {
-                setOn(true);    // Wake up the screen first
-                forceDisplay(); // Forces screen redraw
-            }
-            // === Prepare banner/popup content ===
-            const meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(packet->from);
-            const meshtastic_Channel channel =
-                channels.getByIndex(packet->channel ? packet->channel : channels.getPrimaryIndex());
-            const char *longName = nodeInfoLiteHasUser(node) ? node->long_name : nullptr;
-
-            const char *msgRaw = reinterpret_cast<const char *>(packet->decoded.payload.bytes);
-
-            char banner[256];
-
-            bool isAlert = false;
-
-            if (moduleConfig.external_notification.alert_bell || moduleConfig.external_notification.alert_bell_vibra ||
-                moduleConfig.external_notification.alert_bell_buzzer)
-                // Check for bell character to determine if this message is an alert
-                for (size_t i = 0; i < packet->decoded.payload.size && i < 100; i++) {
-                    if (msgRaw[i] == ASCII_BELL) {
-                        isAlert = true;
-                        break;
-                    }
-                }
-
-            // Unlike generic messages, alerts (when enabled via the ext notif module) ignore any
-            // 'mute' preferences set to any specific node or channel.
-            // If on-screen keyboard is active, show a transient popup over keyboard instead of interrupting it
-            if (NotificationRenderer::current_notification_type == notificationTypeEnum::text_input) {
-                // Wake and force redraw so popup is visible immediately
-                if (shouldWakeOnReceivedMessage()) {
-                    setOn(true);
-                    forceDisplay();
-                }
-
-                // Build popup: title = message source name, content = message text (sanitized)
-                // Title
-                char titleBuf[64] = {0};
-                if (longName && longName[0]) {
-                    // Sanitize sender name
-                    std::string t = sanitizeString(longName);
-                    strncpy(titleBuf, t.c_str(), sizeof(titleBuf) - 1);
-                } else {
-                    strncpy(titleBuf, "Message", sizeof(titleBuf) - 1);
-                }
-
-                // Content: payload bytes may not be null-terminated, remove ASCII_BELL and sanitize
-                char content[256] = {0};
-                {
-                    std::string raw;
-                    raw.reserve(packet->decoded.payload.size);
-                    for (size_t i = 0; i < packet->decoded.payload.size; ++i) {
-                        char c = msgRaw[i];
-                        if (c == ASCII_BELL)
-                            continue; // strip bell
-                        raw.push_back(c);
-                    }
-                    std::string sanitized = sanitizeString(raw);
-                    strncpy(content, sanitized.c_str(), sizeof(content) - 1);
-                }
-
-                NotificationRenderer::showKeyboardMessagePopupWithTitle(titleBuf, content, 3000);
-
-// Maintain existing buzzer behavior on M5 if applicable
-#if defined(M5STACK_UNITC6L)
-                if (config.device.buzzer_mode != meshtastic_Config_DeviceConfig_BuzzerMode_DIRECT_MSG_ONLY ||
-                    (isAlert && moduleConfig.external_notification.alert_bell_buzzer) ||
-                    (!isBroadcast(packet->to) && isToUs(packet))) {
-                    playLongBeep();
-                }
-#endif
-            } else {
-                // No keyboard active: use regular banner flow, respecting mute settings
-                if (isAlert) {
-                    if (longName && longName[0]) {
-                        snprintf(banner, sizeof(banner), "Alert Received from\n%s", longName);
-                    } else {
-                        strcpy(banner, "Alert Received");
-                    }
-                    screen->showSimpleBanner(banner, 3000);
-                } else if (!channel.settings.has_module_settings || !channel.settings.module_settings.is_muted) {
-                    if (longName && longName[0]) {
-                        if (currentResolution == ScreenResolution::UltraLow) {
-                            strcpy(banner, "New Message");
-                        } else {
-                            snprintf(banner, sizeof(banner), "New Message from\n%s", longName);
-                        }
-                    } else {
-                        strcpy(banner, "New Message");
-                    }
-#if defined(M5STACK_UNITC6L)
-                    screen->setOn(true);
-                    screen->showSimpleBanner(banner, 1500);
-                    if (config.device.buzzer_mode != meshtastic_Config_DeviceConfig_BuzzerMode_DIRECT_MSG_ONLY ||
-                        (isAlert && moduleConfig.external_notification.alert_bell_buzzer) ||
-                        (!isBroadcast(packet->to) && isToUs(packet))) {
-                        // Beep if not in DIRECT_MSG_ONLY mode or if in DIRECT_MSG_ONLY mode and either
-                        // - packet contains an alert and alert bell buzzer is enabled
-                        // - packet is a non-broadcast that is addressed to this node
-                        playLongBeep();
-                    }
-#else
-                    screen->showSimpleBanner(banner, 3000);
-#endif
-                }
-            }
-        }
-    }
-
-    return 0;
-}
-
 // Triggered by MeshModules
 int Screen::handleUIFrameEvent(const UIFrameEvent *event)
 {
@@ -1820,7 +1688,7 @@ int Screen::handleInputEvent(const InputEvent *event)
     if (NotificationRenderer::current_notification_type == notificationTypeEnum::text_input) {
         NotificationRenderer::inEvent = *event;
         static OverlayCallback overlays[] = {graphics::UIRenderer::drawNavigationBar, NotificationRenderer::drawBannercallback};
-        ui->setOverlays(overlays, sizeof(overlays) / sizeof(overlays[0]));
+        ui->setOverlays(overlays, 2);
         setFastFramerate(); // Draw ASAP
         updateUiFrame(ui);
         return 0;
@@ -1835,7 +1703,7 @@ int Screen::handleInputEvent(const InputEvent *event)
     if (NotificationRenderer::isOverlayBannerShowing()) {
         NotificationRenderer::inEvent = *event;
         static OverlayCallback overlays[] = {graphics::UIRenderer::drawNavigationBar, NotificationRenderer::drawBannercallback};
-        ui->setOverlays(overlays, sizeof(overlays) / sizeof(overlays[0]));
+        ui->setOverlays(overlays, 2);
         setFastFramerate(); // Draw ASAP
         updateUiFrame(ui);
 

src/graphics/Screen.h

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

src/graphics/ScreenFonts.h

@@ -88,6 +88,16 @@
 #endif
 #endif
 
+// nRF52 flash optimization: re-route FONT_LARGE_LOCAL to the 16pt glyph so
+// the display-tier dispatch below picks up 16pt everywhere it would have used
+// 24pt. Drops the ~9.6 KB ArialMT_Plain_24 table from the linked binary.
+// Set MESHTASTIC_LARGE_FONT_24PT=1 in build_flags to opt out per variant
+// (undefined or 0 keeps the optimization on).
+#if defined(ARCH_NRF52) && (!defined(MESHTASTIC_LARGE_FONT_24PT) || MESHTASTIC_LARGE_FONT_24PT == 0)
+#undef FONT_LARGE_LOCAL
+#define FONT_LARGE_LOCAL FONT_MEDIUM_LOCAL
+#endif
+
 #if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ILI9342_DRIVER) || defined(ST7701_CS) || defined(ST7735_CS) ||      \
      defined(ST7789_CS) || defined(USE_ST7789) || defined(HX8357_CS) || defined(ILI9488_CS) || defined(ST7796_CS) ||             \
      defined(USE_ST7796) || defined(HACKADAY_COMMUNICATOR)) &&                                                                   \

src/graphics/TFTDisplay.cpp

@@ -1606,7 +1606,7 @@ bool TFTDisplay::connect()
     attachInterrupt(digitalPinToInterrupt(SCREEN_TOUCH_INT), rak14014_tpIntHandle, FALLING);
 #elif defined(T_DECK) || defined(PICOMPUTER_S3) || defined(CHATTER_2) || defined(HELTEC_MESH_NODE_T096)
     tft->setRotation(1); // T-Deck has the TFT in landscape
-#elif defined(T_WATCH_S3)
+#elif defined(T_WATCH_S3) || defined(T_DISPLAY_S3_PRO)
     tft->setRotation(2); // T-Watch S3 left-handed orientation
 #elif ARCH_PORTDUINO || defined(SENSECAP_INDICATOR) || defined(T_LORA_PAGER)
     tft->setRotation(0); // use config.yaml to set rotation

src/graphics/draw/MenuHandler.cpp

@@ -57,6 +57,70 @@ BannerOverlayOptions createStaticBannerOptions(const char *message, const MenuOp
     return bannerOptions;
 }
 
+const StoredMessage *getNewestMessageForActiveThread()
+{
+    const auto &messages = messageStore.getMessages();
+    if (messages.empty()) {
+        return nullptr;
+    }
+
+    const auto mode = graphics::MessageRenderer::getThreadMode();
+    const int channel = graphics::MessageRenderer::getThreadChannel();
+    const uint32_t peer = graphics::MessageRenderer::getThreadPeer();
+    const uint32_t localNode = nodeDB->getNodeNum();
+
+    if (mode == graphics::MessageRenderer::ThreadMode::ALL) {
+        return &messages.back();
+    }
+
+    for (auto it = messages.rbegin(); it != messages.rend(); ++it) {
+        const StoredMessage &m = *it;
+
+        if (mode == graphics::MessageRenderer::ThreadMode::CHANNEL) {
+            if (m.type == MessageType::BROADCAST && static_cast<int>(m.channelIndex) == channel) {
+                return &m;
+            }
+            continue;
+        }
+
+        if (mode == graphics::MessageRenderer::ThreadMode::DIRECT) {
+            if (m.type != MessageType::DM_TO_US) {
+                continue;
+            }
+            const uint32_t other = (m.sender == localNode) ? m.dest : m.sender;
+            if (other == peer) {
+                return &m;
+            }
+        }
+    }
+
+    return nullptr;
+}
+
+void launchReplyForMessage(const StoredMessage &message, bool freetext)
+{
+    if (message.type == MessageType::BROADCAST || message.dest == NODENUM_BROADCAST) {
+        if (freetext) {
+            cannedMessageModule->LaunchFreetextWithDestination(NODENUM_BROADCAST, message.channelIndex);
+        } else {
+            cannedMessageModule->LaunchWithDestination(NODENUM_BROADCAST, message.channelIndex);
+        }
+        return;
+    }
+
+    const uint32_t localNode = nodeDB->getNodeNum();
+    const uint32_t peer = (message.sender == localNode) ? message.dest : message.sender;
+    if (peer == 0 || peer == NODENUM_BROADCAST) {
+        return;
+    }
+
+    if (freetext) {
+        cannedMessageModule->LaunchFreetextWithDestination(peer);
+    } else {
+        cannedMessageModule->LaunchWithDestination(peer);
+    }
+}
+
 } // namespace
 
 menuHandler::screenMenus menuHandler::menuQueue = MenuNone;
@@ -594,9 +658,12 @@ void menuHandler::messageResponseMenu()
 
 #ifdef HAS_I2S
         } else if (selected == Aloud) {
-            const meshtastic_MeshPacket &mp = devicestate.rx_text_message;
-            const char *msg = reinterpret_cast<const char *>(mp.decoded.payload.bytes);
-            audioThread->readAloud(msg);
+            if (const StoredMessage *latest = getNewestMessageForActiveThread()) {
+                const char *msg = MessageStore::getText(*latest);
+                if (msg && msg[0]) {
+                    audioThread->readAloud(msg);
+                }
+            }
 #endif
         }
     };
@@ -656,20 +723,12 @@ void menuHandler::replyMenu()
 
         // Preset reply
         if (selected == ReplyPreset) {
-
             if (mode == graphics::MessageRenderer::ThreadMode::CHANNEL) {
                 cannedMessageModule->LaunchWithDestination(NODENUM_BROADCAST, ch);
-
             } else if (mode == graphics::MessageRenderer::ThreadMode::DIRECT) {
                 cannedMessageModule->LaunchWithDestination(peer);
-
-            } else {
-                // Fallback for last received message
-                if (devicestate.rx_text_message.to == NODENUM_BROADCAST) {
-                    cannedMessageModule->LaunchWithDestination(NODENUM_BROADCAST, devicestate.rx_text_message.channel);
-                } else {
-                    cannedMessageModule->LaunchWithDestination(devicestate.rx_text_message.from);
-                }
+            } else if (const StoredMessage *latest = getNewestMessageForActiveThread()) {
+                launchReplyForMessage(*latest, false);
             }
 
             return;
@@ -677,20 +736,12 @@ void menuHandler::replyMenu()
 
         // Freetext reply
         if (selected == ReplyFreetext) {
-
             if (mode == graphics::MessageRenderer::ThreadMode::CHANNEL) {
                 cannedMessageModule->LaunchFreetextWithDestination(NODENUM_BROADCAST, ch);
-
             } else if (mode == graphics::MessageRenderer::ThreadMode::DIRECT) {
                 cannedMessageModule->LaunchFreetextWithDestination(peer);
-
-            } else {
-                // Fallback for last received message
-                if (devicestate.rx_text_message.to == NODENUM_BROADCAST) {
-                    cannedMessageModule->LaunchFreetextWithDestination(NODENUM_BROADCAST, devicestate.rx_text_message.channel);
-                } else {
-                    cannedMessageModule->LaunchFreetextWithDestination(devicestate.rx_text_message.from);
-                }
+            } else if (const StoredMessage *latest = getNewestMessageForActiveThread()) {
+                launchReplyForMessage(*latest, true);
             }
 
             return;

src/graphics/draw/NotificationRenderer.cpp

@@ -66,6 +66,110 @@ uint32_t pow_of_10(uint32_t n)
     return ret;
 }
 
+char graphics::NotificationRenderer::alertBannerLines[MAX_LINES + 1][64] = {};
+uint8_t graphics::NotificationRenderer::alertBannerLineCount = 0;
+graphics::NotificationRenderer::BannerFont graphics::NotificationRenderer::alertBannerLineFonts[MAX_LINES + 1] = {};
+
+static inline graphics::NotificationRenderer::BannerFont parseFontTagPrefix(const char *&p)
+{
+    // Tags must be at the start of the line:
+    // [S] small, [M] medium, [L] large
+    if (p && p[0] == '[' && p[2] == ']' && p[1] != '\0') {
+        char t = p[1];
+        if (t == 'S') {
+            p += 3;
+            return graphics::NotificationRenderer::BANNER_FONT_SMALL;
+        }
+        if (t == 'M') {
+            p += 3;
+            return graphics::NotificationRenderer::BANNER_FONT_MEDIUM;
+        }
+        if (t == 'L') {
+            p += 3;
+            return graphics::NotificationRenderer::BANNER_FONT_LARGE;
+        }
+    }
+    return graphics::NotificationRenderer::BANNER_FONT_DEFAULT;
+}
+
+static inline const uint8_t *fontForBannerLine(graphics::NotificationRenderer::BannerFont f)
+{
+    switch (f) {
+    case graphics::NotificationRenderer::BANNER_FONT_SMALL:
+        return FONT_SMALL;
+    case graphics::NotificationRenderer::BANNER_FONT_MEDIUM:
+        return FONT_MEDIUM;
+    case graphics::NotificationRenderer::BANNER_FONT_LARGE:
+        return FONT_LARGE;
+    case graphics::NotificationRenderer::BANNER_FONT_DEFAULT:
+    default:
+        return FONT_SMALL;
+    }
+}
+
+static inline uint8_t effectiveLineHeightForBannerLine(graphics::NotificationRenderer::BannerFont f)
+{
+    uint8_t height = FONT_HEIGHT_SMALL;
+    switch (f) {
+    case graphics::NotificationRenderer::BANNER_FONT_MEDIUM:
+        height = FONT_HEIGHT_MEDIUM;
+        break;
+    case graphics::NotificationRenderer::BANNER_FONT_LARGE:
+        height = FONT_HEIGHT_LARGE;
+        break;
+    case graphics::NotificationRenderer::BANNER_FONT_SMALL:
+    case graphics::NotificationRenderer::BANNER_FONT_DEFAULT:
+    default:
+        height = FONT_HEIGHT_SMALL;
+        break;
+    }
+    return (height > 3) ? (height - 3) : height;
+}
+
+void graphics::NotificationRenderer::parseBannerMessageWithFonts(const char *message)
+{
+    alertBannerLineCount = 0;
+    for (uint8_t i = 0; i < (MAX_LINES + 1); i++) {
+        alertBannerLines[i][0] = '\0';
+        alertBannerLineFonts[i] = BANNER_FONT_DEFAULT;
+    }
+
+    if (!message || !message[0]) {
+        return;
+    }
+
+    const char *p = message;
+
+    while (*p && alertBannerLineCount < (MAX_LINES + 1)) {
+        const char *lineStart = p;
+        while (*p && *p != '\n') {
+            p++;
+        }
+
+        char tmp[64] = {0};
+        size_t len = (size_t)(p - lineStart);
+        if (len > (sizeof(tmp) - 1)) {
+            len = sizeof(tmp) - 1;
+        }
+        memcpy(tmp, lineStart, len);
+        tmp[len] = '\0';
+
+        // Tag at start
+        const char *tp = tmp;
+        BannerFont f = parseFontTagPrefix(tp);
+        alertBannerLineFonts[alertBannerLineCount] = f;
+
+        // Store stripped text
+        strncpy(alertBannerLines[alertBannerLineCount], tp, sizeof(alertBannerLines[0]) - 1);
+        alertBannerLines[alertBannerLineCount][sizeof(alertBannerLines[0]) - 1] = '\0';
+        alertBannerLineCount++;
+
+        if (*p == '\n') {
+            p++;
+        }
+    }
+}
+
 // Used on boot when a certificate is being created
 void NotificationRenderer::drawSSLScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
@@ -375,23 +479,37 @@ void NotificationRenderer::drawAlertBannerOverlay(OLEDDisplay *display, OLEDDisp
     const char *lineStarts[MAX_LINES + 1] = {0};
     uint16_t lineCount = 0;
     char lineBuffer[40] = {0};
+    bool useTaggedTextBanner =
+        (current_notification_type == notificationTypeEnum::text_banner && alertBannerOptions == 0 && alertBannerLineCount > 0);
 
-    // Parse lines
-    char *alertEnd = alertBannerMessage + strnlen(alertBannerMessage, sizeof(alertBannerMessage));
-    lineStarts[lineCount] = alertBannerMessage;
+    if (useTaggedTextBanner) {
+        lineCount = std::min<uint8_t>(alertBannerLineCount, MAX_LINES);
+        for (uint16_t i = 0; i < lineCount; i++) {
+            lineStarts[i] = alertBannerLines[i];
+            lineLengths[i] = strlen(lineStarts[i]);
+            display->setFont(fontForBannerLine(alertBannerLineFonts[i]));
+            lineWidths[i] = display->getStringWidth(lineStarts[i], lineLengths[i], true);
+            if (lineWidths[i] > maxWidth)
+                maxWidth = lineWidths[i];
+        }
+    } else {
+        char *alertEnd = alertBannerMessage + strnlen(alertBannerMessage, sizeof(alertBannerMessage));
+        lineStarts[lineCount] = alertBannerMessage;
 
-    while ((lineCount < MAX_LINES) && (lineStarts[lineCount] < alertEnd)) {
-        lineStarts[lineCount + 1] = std::find((char *)lineStarts[lineCount], alertEnd, '\n');
-        lineLengths[lineCount] = lineStarts[lineCount + 1] - lineStarts[lineCount];
-        if (lineStarts[lineCount + 1][0] == '\n')
-            lineStarts[lineCount + 1] += 1;
-        lineWidths[lineCount] = display->getStringWidth(lineStarts[lineCount], lineLengths[lineCount], true);
-        if (lineWidths[lineCount] > maxWidth)
-            maxWidth = lineWidths[lineCount];
-        lineCount++;
+        while ((lineCount < MAX_LINES) && (lineStarts[lineCount] < alertEnd)) {
+            lineStarts[lineCount + 1] = std::find((char *)lineStarts[lineCount], alertEnd, '\n');
+            lineLengths[lineCount] = lineStarts[lineCount + 1] - lineStarts[lineCount];
+            if (lineStarts[lineCount + 1][0] == '\n')
+                lineStarts[lineCount + 1] += 1;
+            lineWidths[lineCount] = display->getStringWidth(lineStarts[lineCount], lineLengths[lineCount], true);
+            if (lineWidths[lineCount] > maxWidth)
+                maxWidth = lineWidths[lineCount];
+            lineCount++;
+        }
     }
 
     // Measure option widths
+    display->setFont(FONT_SMALL);
     for (int i = 0; i < alertBannerOptions; i++) {
         optionWidths[i] = display->getStringWidth(optionsArrayPtr[i], strlen(optionsArrayPtr[i]), true);
         if (optionWidths[i] > maxWidth)
@@ -505,6 +623,10 @@ void NotificationRenderer::drawNotificationBox(OLEDDisplay *display, OLEDDisplay
     bool needs_bell = false;
     uint16_t lineWidths[totalLines] = {0};
     uint16_t lineLengths[totalLines] = {0};
+    BannerFont lineFonts[totalLines] = {};
+    uint8_t lineEffectiveHeights[totalLines] = {0};
+    const char *renderLines[totalLines] = {0};
+    bool useTaggedBannerFonts = (current_notification_type == notificationTypeEnum::text_banner && alertBannerOptions == 0);
 
     if (maxWidth != 0)
         is_picker = true;
@@ -517,11 +639,22 @@ void NotificationRenderer::drawNotificationBox(OLEDDisplay *display, OLEDDisplay
     uint16_t widestLineWithBars = 0;
 
     while (lines[lineCount] != nullptr) {
-        auto newlinePointer = strchr(lines[lineCount], '\n');
+        const char *renderText = lines[lineCount];
+        BannerFont lineFont = BANNER_FONT_DEFAULT;
+        if (useTaggedBannerFonts && lineCount < alertBannerLineCount) {
+            renderText = alertBannerLines[lineCount];
+            lineFont = alertBannerLineFonts[lineCount];
+        }
+        renderLines[lineCount] = renderText;
+        lineFonts[lineCount] = lineFont;
+        lineEffectiveHeights[lineCount] = effectiveLineHeightForBannerLine(lineFont);
+        display->setFont(fontForBannerLine(lineFont));
+
+        auto newlinePointer = strchr(renderText, '\n');
         if (newlinePointer)
-            lineLengths[lineCount] = (newlinePointer - lines[lineCount]); // Check for newlines first
-        else // if the newline wasn't found, then pull string length from strlen
-            lineLengths[lineCount] = strlen(lines[lineCount]);
+            lineLengths[lineCount] = (newlinePointer - renderText);
+        else
+            lineLengths[lineCount] = strlen(renderText);
 
         if (current_notification_type == notificationTypeEnum::node_picker) {
             char measureBuffer[64] = {0};
@@ -533,7 +666,7 @@ void NotificationRenderer::drawNotificationBox(OLEDDisplay *display, OLEDDisplay
 
         // Consider extra width for signal bars on lines that contain "Signal:"
         uint16_t potentialWidth = lineWidths[lineCount];
-        if (graphics::bannerSignalBars >= 0 && strncmp(lines[lineCount], "Signal:", 7) == 0) {
+        if (graphics::bannerSignalBars >= 0 && strncmp(renderText, "Signal:", 7) == 0) {
             const int totalBars = 5;
             const int barWidth = 3;
             const int barSpacing = 2;
@@ -569,8 +702,21 @@ void NotificationRenderer::drawNotificationBox(OLEDDisplay *display, OLEDDisplay
 
     uint16_t screenHeight = display->height();
     uint8_t effectiveLineHeight = FONT_HEIGHT_SMALL - 3;
-    uint8_t visibleTotalLines = std::min<uint8_t>(lineCount, (screenHeight - vPadding * 2) / effectiveLineHeight);
-    uint16_t contentHeight = visibleTotalLines * effectiveLineHeight;
+    uint8_t visibleTotalLines = 0;
+    uint16_t contentHeight = 0;
+    const uint16_t availableHeight = (screenHeight > (vPadding * 2)) ? (screenHeight - vPadding * 2) : 0;
+    for (uint8_t i = 0; i < lineCount; i++) {
+        uint8_t thisLineHeight = lineEffectiveHeights[i] ? lineEffectiveHeights[i] : effectiveLineHeight;
+        if (contentHeight + thisLineHeight > availableHeight) {
+            break;
+        }
+        contentHeight += thisLineHeight;
+        visibleTotalLines++;
+    }
+    if (visibleTotalLines == 0 && lineCount > 0) {
+        visibleTotalLines = 1;
+        contentHeight = lineEffectiveHeights[0] ? lineEffectiveHeights[0] : effectiveLineHeight;
+    }
     uint16_t boxHeight = contentHeight + vPadding * 2;
     if (visibleTotalLines == 1) {
         boxHeight += (currentResolution == ScreenResolution::High) ? 4 : 3;
@@ -616,15 +762,18 @@ void NotificationRenderer::drawNotificationBox(OLEDDisplay *display, OLEDDisplay
 
     // Draw Content
     int16_t lineY = boxTop + vPadding;
-    for (int i = 0; i < lineCount; i++) {
+    for (int i = 0; i < visibleTotalLines; i++) {
+        display->setFont(fontForBannerLine(lineFonts[i]));
+        int16_t thisLineHeight = lineEffectiveHeights[i] ? lineEffectiveHeights[i] : effectiveLineHeight;
         int16_t textX = boxLeft + (boxWidth - lineWidths[i]) / 2;
         if (needs_bell && i == 0) {
-            int bellY = lineY + (FONT_HEIGHT_SMALL - 8) / 2;
+            int fontHeight = thisLineHeight + 3;
+            int bellY = lineY + (fontHeight - 8) / 2;
             display->drawXbm(textX - 10, bellY, 8, 8, bell_alert);
             display->drawXbm(textX + lineWidths[i] + 2, bellY, 8, 8, bell_alert);
         }
         char lineBuffer[lineLengths[i] + 1];
-        strncpy(lineBuffer, lines[i], lineLengths[i]);
+        strncpy(lineBuffer, renderLines[i], lineLengths[i]);
         lineBuffer[lineLengths[i]] = '\0';
         // Determine if this is a pop-up or a pick list
         if (alertBannerOptions > 0 && i == 0) {
@@ -658,7 +807,7 @@ void NotificationRenderer::drawNotificationBox(OLEDDisplay *display, OLEDDisplay
                 display->drawString(textX, lineY - yOffset, lineBuffer);
             }
             display->setColor(WHITE);
-            lineY += (effectiveLineHeight - 2 - background_yOffset);
+            lineY += (thisLineHeight - 2 - background_yOffset);
         } else {
             // Pop-up
             // If this is the Signal line, center text + bars as one group
@@ -716,7 +865,7 @@ void NotificationRenderer::drawNotificationBox(OLEDDisplay *display, OLEDDisplay
                     display->drawString(textX, lineY, lineBuffer);
                 }
             }
-            lineY += (effectiveLineHeight);
+            lineY += thisLineHeight;
         }
     }
 

src/graphics/draw/NotificationRenderer.h

@@ -31,6 +31,12 @@ class NotificationRenderer
 
     static bool pauseBanner;
 
+    enum BannerFont : uint8_t { BANNER_FONT_DEFAULT = 0, BANNER_FONT_SMALL, BANNER_FONT_MEDIUM, BANNER_FONT_LARGE };
+
+    static char alertBannerLines[MAX_LINES + 1][64]; // parsed text per line
+    static uint8_t alertBannerLineCount;
+    static BannerFont alertBannerLineFonts[MAX_LINES + 1];
+    static void parseBannerMessageWithFonts(const char *message);
     static void resetBanner();
     static void showKeyboardMessagePopupWithTitle(const char *title, const char *content, uint32_t durationMs);
     static void drawBannercallback(OLEDDisplay *display, OLEDDisplayUiState *state);

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

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

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

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

src/graphics/niche/InkHUD/Events.cpp

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

src/graphics/niche/InkHUD/Persistence.h

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

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

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

src/input/InputBroker.cpp

@@ -333,6 +333,12 @@ void InputBroker::Init()
             BaseType_t higherWake = 0;
             concurrency::mainDelay.interruptFromISR(&higherWake);
         };
+#if defined(ELECROW_ThinkNode_M7)
+        userConfigNoScreen.longLongPressTime = 15 * 1000;
+        userConfigNoScreen.longLongPress = INPUT_BROKER_FACTORY_RST;
+#else
+        userConfigNoScreen.longLongPress = INPUT_BROKER_SHUTDOWN;
+#endif
         userConfigNoScreen.singlePress = INPUT_BROKER_USER_PRESS;
         userConfigNoScreen.longPress = INPUT_BROKER_NONE;
         userConfigNoScreen.longPressTime = 500;

src/input/InputBroker.h

@@ -25,6 +25,7 @@ enum input_broker_event {
     INPUT_BROKER_USER_PRESS,
     INPUT_BROKER_ALT_PRESS,
     INPUT_BROKER_ALT_LONG,
+    INPUT_BROKER_FACTORY_RST = 0x9a,
     INPUT_BROKER_SHUTDOWN = 0x9b,
     INPUT_BROKER_GPS_TOGGLE = 0x9e,
     INPUT_BROKER_SEND_PING = 0xaf,

src/main.cpp

@@ -2,6 +2,9 @@
 #if !MESHTASTIC_EXCLUDE_GPS
 #include "GPS.h"
 #endif
+#if !MESHTASTIC_EXCLUDE_INPUTBROKER
+#include "input/InputBroker.h"
+#endif
 #include "MeshRadio.h"
 #include "MeshService.h"
 #include "NodeDB.h"
@@ -59,12 +62,18 @@ NimbleBluetooth *nimbleBluetooth = nullptr;
 NRF52Bluetooth *nrf52Bluetooth = nullptr;
 #endif
 
-#if HAS_WIFI || defined(USE_WS5500)
+#ifdef ARCH_NRF54L15
+void nrf54l15Setup();
+void nrf54l15Loop();
+NRF54L15Bluetooth *nrf54l15Bluetooth = nullptr;
+#endif
+
+#if HAS_WIFI || defined(USE_WS5500) || defined(USE_CH390D)
 #include "mesh/api/WiFiServerAPI.h"
 #include "mesh/wifi/WiFiAPClient.h"
 #endif
 
-#if HAS_ETHERNET && !defined(USE_WS5500)
+#if HAS_ETHERNET && !defined(USE_WS5500) && !defined(USE_CH390D)
 #include "mesh/api/ethServerAPI.h"
 #include "mesh/eth/ethClient.h"
 #endif
@@ -245,7 +254,7 @@ const char *getDeviceName()
 uint32_t timeLastPowered = 0;
 
 static OSThread *powerFSMthread;
-OSThread *ambientLightingThread;
+AmbientLightingThread *ambientLightingThread;
 
 RadioLibHal *RadioLibHAL = NULL;
 
@@ -335,7 +344,7 @@ void setup()
 
 #ifdef WIFI_LED
     pinMode(WIFI_LED, OUTPUT);
-    digitalWrite(WIFI_LED, LOW);
+    digitalWrite(WIFI_LED, HIGH ^ WIFI_STATE_ON);
 #endif
 
 #ifdef BLE_LED
@@ -696,6 +705,9 @@ void setup()
 #ifdef ARCH_NRF52
     nrf52Setup();
 #endif
+#ifdef ARCH_NRF54L15
+    nrf54l15Setup();
+#endif
 
 #ifdef ARCH_RP2040
     rp2040Setup();
@@ -1126,6 +1138,9 @@ void loop()
 #endif
 #ifdef ARCH_NRF52
     nrf52Loop();
+#endif
+#ifdef ARCH_NRF54L15
+    nrf54l15Loop();
 #endif
     power->powerCommandsCheck();
 

src/main.h

@@ -19,6 +19,10 @@ extern NimbleBluetooth *nimbleBluetooth;
 #include "NRF52Bluetooth.h"
 extern NRF52Bluetooth *nrf52Bluetooth;
 #endif
+#ifdef ARCH_NRF54L15
+#include "NRF54L15Bluetooth.h"
+extern NRF54L15Bluetooth *nrf54l15Bluetooth;
+#endif
 #if !MESHTASTIC_EXCLUDE_I2C
 #include "detect/ScanI2CTwoWire.h"
 #endif

src/mesh/Channels.cpp

@@ -93,6 +93,23 @@ void Channels::initDefaultLoraConfig()
 #ifdef USERPREFS_LORACONFIG_CHANNEL_NUM
     loraConfig.channel_num = USERPREFS_LORACONFIG_CHANNEL_NUM;
 #endif
+
+    // Apply any hardcoded USERPREFS overrides for custom modem config (e.g. region-locked boards)
+#ifdef USERPREFS_LORACONFIG_USE_PRESET
+    loraConfig.use_preset = USERPREFS_LORACONFIG_USE_PRESET;
+#endif
+#ifdef USERPREFS_LORACONFIG_BANDWIDTH
+    loraConfig.bandwidth = USERPREFS_LORACONFIG_BANDWIDTH;
+#endif
+#ifdef USERPREFS_LORACONFIG_SPREAD_FACTOR
+    loraConfig.spread_factor = USERPREFS_LORACONFIG_SPREAD_FACTOR;
+#endif
+#ifdef USERPREFS_LORACONFIG_CODING_RATE
+    loraConfig.coding_rate = USERPREFS_LORACONFIG_CODING_RATE;
+#endif
+#ifdef USERPREFS_LORACONFIG_OVERRIDE_FREQUENCY
+    loraConfig.override_frequency = USERPREFS_LORACONFIG_OVERRIDE_FREQUENCY;
+#endif
 }
 
 bool Channels::ensureLicensedOperation()

src/mesh/InterfacesTemplates.cpp

@@ -32,7 +32,7 @@ template class LR20x0Interface<LR2021>;
 template class SX126xInterface<STM32WLx>;
 #endif
 
-#if HAS_ETHERNET && !defined(USE_WS5500)
+#if HAS_ETHERNET && !defined(USE_WS5500) && !defined(USE_CH390D)
 #include "api/ethServerAPI.h"
 template class ServerAPI<EthernetClient>;
 template class APIServerPort<ethServerAPI, EthernetServer>;

src/mesh/MeshService.cpp

@@ -334,7 +334,9 @@ void MeshService::sendToPhone(meshtastic_MeshPacket *p)
 
     if (toPhoneQueue.enqueue(p, 0) == false) {
         LOG_CRIT("Failed to queue a packet into toPhoneQueue!");
-        abort();
+        releaseToPool(p);
+        fromNum++; // notify observers so phone can resync
+        return;
     }
     fromNum++;
 }
@@ -351,7 +353,8 @@ void MeshService::sendMqttMessageToClientProxy(meshtastic_MqttClientProxyMessage
 
     if (toPhoneMqttProxyQueue.enqueue(m, 0) == false) {
         LOG_CRIT("Failed to queue a packet into toPhoneMqttProxyQueue!");
-        abort();
+        releaseMqttClientProxyMessageToPool(m);
+        return;
     }
     fromNum++;
 }
@@ -383,7 +386,8 @@ void MeshService::sendClientNotification(meshtastic_ClientNotification *n)
 
     if (toPhoneClientNotificationQueue.enqueue(n, 0) == false) {
         LOG_CRIT("Failed to queue a notification into toPhoneClientNotificationQueue!");
-        abort();
+        releaseClientNotificationToPool(n);
+        return;
     }
     fromNum++;
 }

src/mesh/NodeDB.cpp

@@ -25,6 +25,7 @@
 #include "mesh/generated/meshtastic/deviceonly_legacy.pb.h"
 #include "meshUtils.h"
 #include "modules/NeighborInfoModule.h"
+#include "xmodem.h"
 #include <ErriezCRC32.h>
 #include <algorithm>
 #include <pb_decode.h>
@@ -81,6 +82,14 @@ static unsigned char userprefs_admin_key_1[] = USERPREFS_USE_ADMIN_KEY_1;
 static unsigned char userprefs_admin_key_2[] = USERPREFS_USE_ADMIN_KEY_2;
 #endif
 
+// Weak empty variant initialization function.
+// May be redefined by variant files.
+void variantDefaultConfig() __attribute__((weak));
+void variantDefaultConfig() {}
+
+void variantDefaultModuleConfig() __attribute__((weak));
+void variantDefaultModuleConfig() {}
+
 #ifdef HELTEC_MESH_NODE_T114
 
 uint32_t read8(uint8_t bits, uint8_t dummy, uint8_t cs, uint8_t sck, uint8_t mosi, uint8_t dc, uint8_t rst)
@@ -152,6 +161,25 @@ uint32_t get_st7789_id(uint8_t cs, uint8_t sck, uint8_t mosi, uint8_t dc, uint8_
 
 #endif
 
+// When armed by loadFromDisk, the decode callback writes satellite entries
+// straight into these maps instead of the temp vectors. Nullptr = legacy
+// push_back-to-vector path for backup/restore and other decoders.
+namespace
+{
+#if !MESHTASTIC_EXCLUDE_POSITIONDB
+std::map<NodeNum, meshtastic_PositionLite> *s_decodePositionsTarget = nullptr;
+#endif
+#if !MESHTASTIC_EXCLUDE_TELEMETRYDB
+std::map<NodeNum, meshtastic_DeviceMetrics> *s_decodeTelemetryTarget = nullptr;
+#endif
+#if !MESHTASTIC_EXCLUDE_ENVIRONMENTDB
+std::map<NodeNum, meshtastic_EnvironmentMetrics> *s_decodeEnvironmentTarget = nullptr;
+#endif
+#if !MESHTASTIC_EXCLUDE_STATUSDB
+std::map<NodeNum, meshtastic_StatusMessage> *s_decodeStatusTarget = nullptr;
+#endif
+} // namespace
+
 bool meshtastic_NodeDatabase_callback(pb_istream_t *istream, pb_ostream_t *ostream, const pb_field_t *field)
 {
     const auto *iter = reinterpret_cast<const pb_field_iter_t *>(field);
@@ -166,10 +194,10 @@ bool meshtastic_NodeDatabase_callback(pb_istream_t *istream, pb_ostream_t *ostre
                     return false;
             }
         }
-        if (istream) {
-            meshtastic_NodeInfoLite node;
+        if (istream && istream->bytes_left) {
+            meshtastic_NodeInfoLite node = meshtastic_NodeInfoLite_init_zero;
             auto *vec = static_cast<std::vector<meshtastic_NodeInfoLite> *>(iter->pData);
-            if (istream->bytes_left && pb_decode(istream, meshtastic_NodeInfoLite_fields, &node))
+            if (pb_decode(istream, meshtastic_NodeInfoLite_fields, &node))
                 vec->push_back(node);
         }
         return true;
@@ -184,11 +212,19 @@ bool meshtastic_NodeDatabase_callback(pb_istream_t *istream, pb_ostream_t *ostre
                     return false;
             }
         }
-        if (istream) {
-            meshtastic_NodePositionEntry entry;
-            auto *vec = static_cast<std::vector<meshtastic_NodePositionEntry> *>(iter->pData);
-            if (istream->bytes_left && pb_decode(istream, meshtastic_NodePositionEntry_fields, &entry))
+        if (istream && istream->bytes_left) {
+            meshtastic_NodePositionEntry entry = meshtastic_NodePositionEntry_init_zero;
+            if (pb_decode(istream, meshtastic_NodePositionEntry_fields, &entry)) {
+#if !MESHTASTIC_EXCLUDE_POSITIONDB
+                if (s_decodePositionsTarget) {
+                    if (entry.has_position)
+                        (*s_decodePositionsTarget)[entry.num] = entry.position;
+                    return true;
+                }
+#endif
+                auto *vec = static_cast<std::vector<meshtastic_NodePositionEntry> *>(iter->pData);
                 vec->push_back(entry);
+            }
         }
         return true;
     }
@@ -202,11 +238,19 @@ bool meshtastic_NodeDatabase_callback(pb_istream_t *istream, pb_ostream_t *ostre
                     return false;
             }
         }
-        if (istream) {
-            meshtastic_NodeTelemetryEntry entry;
-            auto *vec = static_cast<std::vector<meshtastic_NodeTelemetryEntry> *>(iter->pData);
-            if (istream->bytes_left && pb_decode(istream, meshtastic_NodeTelemetryEntry_fields, &entry))
+        if (istream && istream->bytes_left) {
+            meshtastic_NodeTelemetryEntry entry = meshtastic_NodeTelemetryEntry_init_zero;
+            if (pb_decode(istream, meshtastic_NodeTelemetryEntry_fields, &entry)) {
+#if !MESHTASTIC_EXCLUDE_TELEMETRYDB
+                if (s_decodeTelemetryTarget) {
+                    if (entry.has_device_metrics)
+                        (*s_decodeTelemetryTarget)[entry.num] = entry.device_metrics;
+                    return true;
+                }
+#endif
+                auto *vec = static_cast<std::vector<meshtastic_NodeTelemetryEntry> *>(iter->pData);
                 vec->push_back(entry);
+            }
         }
         return true;
     }
@@ -220,11 +264,19 @@ bool meshtastic_NodeDatabase_callback(pb_istream_t *istream, pb_ostream_t *ostre
                     return false;
             }
         }
-        if (istream) {
-            meshtastic_NodeStatusEntry entry;
-            auto *vec = static_cast<std::vector<meshtastic_NodeStatusEntry> *>(iter->pData);
-            if (istream->bytes_left && pb_decode(istream, meshtastic_NodeStatusEntry_fields, &entry))
+        if (istream && istream->bytes_left) {
+            meshtastic_NodeStatusEntry entry = meshtastic_NodeStatusEntry_init_zero;
+            if (pb_decode(istream, meshtastic_NodeStatusEntry_fields, &entry)) {
+#if !MESHTASTIC_EXCLUDE_STATUSDB
+                if (s_decodeStatusTarget) {
+                    if (entry.has_status)
+                        (*s_decodeStatusTarget)[entry.num] = entry.status;
+                    return true;
+                }
+#endif
+                auto *vec = static_cast<std::vector<meshtastic_NodeStatusEntry> *>(iter->pData);
                 vec->push_back(entry);
+            }
         }
         return true;
     }
@@ -238,11 +290,19 @@ bool meshtastic_NodeDatabase_callback(pb_istream_t *istream, pb_ostream_t *ostre
                     return false;
             }
         }
-        if (istream) {
-            meshtastic_NodeEnvironmentEntry entry;
-            auto *vec = static_cast<std::vector<meshtastic_NodeEnvironmentEntry> *>(iter->pData);
-            if (istream->bytes_left && pb_decode(istream, meshtastic_NodeEnvironmentEntry_fields, &entry))
+        if (istream && istream->bytes_left) {
+            meshtastic_NodeEnvironmentEntry entry = meshtastic_NodeEnvironmentEntry_init_zero;
+            if (pb_decode(istream, meshtastic_NodeEnvironmentEntry_fields, &entry)) {
+#if !MESHTASTIC_EXCLUDE_ENVIRONMENTDB
+                if (s_decodeEnvironmentTarget) {
+                    if (entry.has_environment_metrics)
+                        (*s_decodeEnvironmentTarget)[entry.num] = entry.environment_metrics;
+                    return true;
+                }
+#endif
+                auto *vec = static_cast<std::vector<meshtastic_NodeEnvironmentEntry> *>(iter->pData);
                 vec->push_back(entry);
+            }
         }
         return true;
     }
@@ -251,6 +311,42 @@ bool meshtastic_NodeDatabase_callback(pb_istream_t *istream, pb_ostream_t *ostre
     }
 }
 
+void NodeDB::armNodeDatabaseDecodeTargets()
+{
+#if !MESHTASTIC_EXCLUDE_POSITIONDB
+    nodePositions.clear();
+    s_decodePositionsTarget = &nodePositions;
+#endif
+#if !MESHTASTIC_EXCLUDE_TELEMETRYDB
+    nodeTelemetry.clear();
+    s_decodeTelemetryTarget = &nodeTelemetry;
+#endif
+#if !MESHTASTIC_EXCLUDE_ENVIRONMENTDB
+    nodeEnvironment.clear();
+    s_decodeEnvironmentTarget = &nodeEnvironment;
+#endif
+#if !MESHTASTIC_EXCLUDE_STATUSDB
+    nodeStatus.clear();
+    s_decodeStatusTarget = &nodeStatus;
+#endif
+}
+
+void NodeDB::disarmNodeDatabaseDecodeTargets()
+{
+#if !MESHTASTIC_EXCLUDE_POSITIONDB
+    s_decodePositionsTarget = nullptr;
+#endif
+#if !MESHTASTIC_EXCLUDE_TELEMETRYDB
+    s_decodeTelemetryTarget = nullptr;
+#endif
+#if !MESHTASTIC_EXCLUDE_ENVIRONMENTDB
+    s_decodeEnvironmentTarget = nullptr;
+#endif
+#if !MESHTASTIC_EXCLUDE_STATUSDB
+    s_decodeStatusTarget = nullptr;
+#endif
+}
+
 /** The current change # for radio settings.  Starts at 0 on boot and any time the radio settings
  * might have changed is incremented.  Allows others to detect they might now be on a new channel.
  */
@@ -297,6 +393,13 @@ NodeDB::NodeDB()
     } else {
         LOG_WARN("Failed to read unique id from efuse");
     }
+#elif defined(ARCH_NRF54L15)
+    // nRF54L15: DEVICEID is under FICR->INFO sub-struct (not top-level as on nRF52)
+    uint64_t device_id_start = ((uint64_t)NRF_FICR->INFO.DEVICEID[1] << 32) | NRF_FICR->INFO.DEVICEID[0];
+    uint64_t device_id_end = ((uint64_t)NRF_FICR->DEVICEADDR[1] << 32) | NRF_FICR->DEVICEADDR[0];
+    memcpy(myNodeInfo.device_id.bytes, &device_id_start, sizeof(device_id_start));
+    memcpy(myNodeInfo.device_id.bytes + sizeof(device_id_start), &device_id_end, sizeof(device_id_end));
+    myNodeInfo.device_id.size = 16;
 #elif defined(ARCH_NRF52)
     // Nordic applies a FIPS compliant Random ID to each chip at the factory
     // We concatenate the device address to the Random ID to create a unique ID for now
@@ -730,6 +833,23 @@ void NodeDB::installDefaultConfig(bool preserveKey = false)
     config.lora.modem_preset = USERPREFS_LORACONFIG_MODEM_PRESET;
 #else
     config.lora.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST;
+#endif
+#ifdef USERPREFS_LORACONFIG_USE_PRESET
+    config.lora.use_preset = USERPREFS_LORACONFIG_USE_PRESET;
+#else
+    config.lora.use_preset = true;
+#endif
+#ifdef USERPREFS_LORACONFIG_BANDWIDTH
+    config.lora.bandwidth = USERPREFS_LORACONFIG_BANDWIDTH;
+#endif
+#ifdef USERPREFS_LORACONFIG_SPREAD_FACTOR
+    config.lora.spread_factor = USERPREFS_LORACONFIG_SPREAD_FACTOR;
+#endif
+#ifdef USERPREFS_LORACONFIG_CODING_RATE
+    config.lora.coding_rate = USERPREFS_LORACONFIG_CODING_RATE;
+#endif
+#ifdef USERPREFS_LORACONFIG_OVERRIDE_FREQUENCY
+    config.lora.override_frequency = USERPREFS_LORACONFIG_OVERRIDE_FREQUENCY;
 #endif
     config.lora.hop_limit = HOP_RELIABLE;
 #ifdef USERPREFS_CONFIG_LORA_IGNORE_MQTT
@@ -807,7 +927,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) || defined(HELTEC_V4_R8_TFT) || defined(T_DISPLAY_S3_PRO)) &&              \
     HAS_TFT
     // switch BT off by default; use TFT programming mode or hotkey to enable
     config.bluetooth.enabled = false;
@@ -904,6 +1024,8 @@ void NodeDB::installDefaultConfig(bool preserveKey = false)
 #endif
 
     initConfigIntervals();
+    variantDefaultConfig();
+    variantDefaultModuleConfig();
 }
 
 void NodeDB::initConfigIntervals()
@@ -1119,7 +1241,14 @@ void NodeDB::initModuleConfigIntervals()
 #else
     moduleConfig.telemetry.device_update_interval = MAX_INTERVAL;
 #endif
+#ifdef USERPREFS_CONFIG_ENV_TELEM_UPDATE_INTERVAL
+    moduleConfig.telemetry.environment_update_interval = USERPREFS_CONFIG_ENV_TELEM_UPDATE_INTERVAL;
+#else
     moduleConfig.telemetry.environment_update_interval = 0;
+#endif
+#ifdef USERPREFS_CONFIG_ENVIRONMENT_MEASUREMENT_ENABLED
+    moduleConfig.telemetry.environment_measurement_enabled = USERPREFS_CONFIG_ENVIRONMENT_MEASUREMENT_ENABLED;
+#endif
     moduleConfig.telemetry.air_quality_interval = 0;
     moduleConfig.telemetry.power_update_interval = 0;
     moduleConfig.telemetry.health_update_interval = 0;
@@ -1161,7 +1290,6 @@ void NodeDB::resetNodes(bool keepFavorites)
         std::fill(nodeDatabase.nodes.begin() + 1, nodeDatabase.nodes.end(), meshtastic_NodeInfoLite());
     }
     (void)ourNum;
-    devicestate.has_rx_text_message = false;
     devicestate.has_rx_waypoint = false;
     saveNodeDatabaseToDisk();
     saveDeviceStateToDisk();
@@ -1368,7 +1496,6 @@ void NodeDB::installDefaultDeviceState()
     devicestate.version = DEVICESTATE_CUR_VER;
     devicestate.receive_queue_count = 0; // Not yet implemented FIXME
     devicestate.has_rx_waypoint = false;
-    devicestate.has_rx_text_message = false;
 
     generatePacketId(); // FIXME - ugly way to init current_packet_id;
 
@@ -1510,6 +1637,19 @@ void NodeDB::loadFromDisk()
     }
 
 #endif
+    // Arm the direct-into-map decode so satellite entries skip the temp vectors.
+    {
+        concurrency::LockGuard guard(&satelliteMutex);
+        armNodeDatabaseDecodeTargets();
+    }
+    struct Disarm {
+        NodeDB &self;
+        ~Disarm() { self.disarmNodeDatabaseDecodeTargets(); }
+    } disarm{*this};
+
+    // Avoid push_back's power-of-2 capacity growth wasting RAM at small N.
+    nodeDatabase.nodes.reserve(MAX_NUM_NODES);
+
     auto state = loadProto(nodeDatabaseFileName, getMaxNodesAllocatedSize(), sizeof(meshtastic_NodeDatabase),
                            &meshtastic_NodeDatabase_msg, &nodeDatabase);
     if (nodeDatabase.version < DEVICESTATE_MIN_VER) {
@@ -1523,50 +1663,33 @@ void NodeDB::loadFromDisk()
     } else {
         meshNodes = &nodeDatabase.nodes;
         numMeshNodes = nodeDatabase.nodes.size();
-        // Hydrate the satellite maps; the on-disk vectors stay empty in steady
-        // state and are repopulated only at save time.
-        concurrency::LockGuard guard(&satelliteMutex);
+        // Counts computed outside LOG_INFO() so cppcheck doesn't choke on #if in macro args.
+        const unsigned posCount =
 #if !MESHTASTIC_EXCLUDE_POSITIONDB
-        nodePositions.clear();
-        nodePositions.reserve(nodeDatabase.positions.size());
-        for (const auto &entry : nodeDatabase.positions) {
-            if (entry.has_position)
-                nodePositions[entry.num] = entry.position;
-        }
-        nodeDatabase.positions.clear();
-        nodeDatabase.positions.shrink_to_fit();
+            (unsigned)nodePositions.size();
+#else
+            0u;
 #endif
+        const unsigned telCount =
 #if !MESHTASTIC_EXCLUDE_TELEMETRYDB
-        nodeTelemetry.clear();
-        nodeTelemetry.reserve(nodeDatabase.telemetry.size());
-        for (const auto &entry : nodeDatabase.telemetry) {
-            if (entry.has_device_metrics)
-                nodeTelemetry[entry.num] = entry.device_metrics;
-        }
-        nodeDatabase.telemetry.clear();
-        nodeDatabase.telemetry.shrink_to_fit();
+            (unsigned)nodeTelemetry.size();
+#else
+            0u;
 #endif
+        const unsigned envCount =
 #if !MESHTASTIC_EXCLUDE_ENVIRONMENTDB
-        nodeEnvironment.clear();
-        nodeEnvironment.reserve(nodeDatabase.environment.size());
-        for (const auto &entry : nodeDatabase.environment) {
-            if (entry.has_environment_metrics)
-                nodeEnvironment[entry.num] = entry.environment_metrics;
-        }
-        nodeDatabase.environment.clear();
-        nodeDatabase.environment.shrink_to_fit();
+            (unsigned)nodeEnvironment.size();
+#else
+            0u;
 #endif
+        const unsigned statusCount =
 #if !MESHTASTIC_EXCLUDE_STATUSDB
-        nodeStatus.clear();
-        nodeStatus.reserve(nodeDatabase.status.size());
-        for (const auto &entry : nodeDatabase.status) {
-            if (entry.has_status)
-                nodeStatus[entry.num] = entry.status;
-        }
-        nodeDatabase.status.clear();
-        nodeDatabase.status.shrink_to_fit();
+            (unsigned)nodeStatus.size();
+#else
+            0u;
 #endif
-        LOG_INFO("Loaded saved nodedatabase version %d, with nodes count: %d", nodeDatabase.version, nodeDatabase.nodes.size());
+        LOG_INFO("Loaded saved nodedatabase v%d: %d nodes, %u pos, %u tel, %u env, %u status", nodeDatabase.version,
+                 nodeDatabase.nodes.size(), posCount, telCount, envCount, statusCount);
     }
 
     if (numMeshNodes > MAX_NUM_NODES) {
@@ -1634,6 +1757,28 @@ void NodeDB::loadFromDisk()
     config.lora.tx_enabled = false;
 #endif
 
+    // Always-apply LoRa overrides: applied after loading saved config so they
+    // take effect even when NVS already has a valid config (e.g. region-locked
+    // dev boards with no BLE/serial to set the region at runtime).
+#ifdef USERPREFS_CONFIG_LORA_REGION
+    config.lora.region = USERPREFS_CONFIG_LORA_REGION;
+#endif
+#ifdef USERPREFS_LORACONFIG_USE_PRESET
+    config.lora.use_preset = USERPREFS_LORACONFIG_USE_PRESET;
+#endif
+#ifdef USERPREFS_LORACONFIG_BANDWIDTH
+    config.lora.bandwidth = USERPREFS_LORACONFIG_BANDWIDTH;
+#endif
+#ifdef USERPREFS_LORACONFIG_SPREAD_FACTOR
+    config.lora.spread_factor = USERPREFS_LORACONFIG_SPREAD_FACTOR;
+#endif
+#ifdef USERPREFS_LORACONFIG_CODING_RATE
+    config.lora.coding_rate = USERPREFS_LORACONFIG_CODING_RATE;
+#endif
+#ifdef USERPREFS_LORACONFIG_OVERRIDE_FREQUENCY
+    config.lora.override_frequency = USERPREFS_LORACONFIG_OVERRIDE_FREQUENCY;
+#endif
+
     if (backupSecurity.private_key.size > 0) {
         LOG_DEBUG("Restoring backup of security config");
         config.security = backupSecurity;
@@ -1844,6 +1989,15 @@ bool NodeDB::saveNodeDatabaseToDisk()
         return false;
     }
 
+    // Defer (don't fail) while xmodem holds the prefs file handle. Returning false
+    // would propagate through saveToDisk() and trigger fsFormat() mid-transfer.
+#ifdef FSCom
+    if (xModem.isBusy()) {
+        LOG_DEBUG("Deferring NodeDB save: xmodem transfer in progress");
+        return true;
+    }
+#endif
+
 #ifdef FSCom
     spiLock->lock();
     FSCom.mkdir("/prefs");

src/mesh/NodeDB.h

@@ -4,9 +4,9 @@
 #include <Arduino.h>
 #include <algorithm>
 #include <assert.h>
+#include <map>
 #include <pb_encode.h>
 #include <string>
-#include <unordered_map>
 #include <vector>
 
 #include "MeshTypes.h"
@@ -170,19 +170,19 @@ class NodeDB
     Observable<const meshtastic::NodeStatus *> newStatus;
     pb_size_t numMeshNodes;
 
-    // Satellite per-NodeNum maps for data we used to inline into NodeInfoLite,
-    // gated by MESHTASTIC_EXCLUDE_*DB so STM32WL can omit them.
+    // Satellite per-NodeNum maps. std::map avoids unordered_map's bucket-array
+    // preallocation; O(log N) lookup is fine at these sizes.
 #if !MESHTASTIC_EXCLUDE_POSITIONDB
-    std::unordered_map<NodeNum, meshtastic_PositionLite> nodePositions;
+    std::map<NodeNum, meshtastic_PositionLite> nodePositions;
 #endif
 #if !MESHTASTIC_EXCLUDE_TELEMETRYDB
-    std::unordered_map<NodeNum, meshtastic_DeviceMetrics> nodeTelemetry;
+    std::map<NodeNum, meshtastic_DeviceMetrics> nodeTelemetry;
 #endif
 #if !MESHTASTIC_EXCLUDE_ENVIRONMENTDB
-    std::unordered_map<NodeNum, meshtastic_EnvironmentMetrics> nodeEnvironment;
+    std::map<NodeNum, meshtastic_EnvironmentMetrics> nodeEnvironment;
 #endif
 #if !MESHTASTIC_EXCLUDE_STATUSDB
-    std::unordered_map<NodeNum, meshtastic_StatusMessage> nodeStatus;
+    std::map<NodeNum, meshtastic_StatusMessage> nodeStatus;
 #endif
 
     bool keyIsLowEntropy = false;
@@ -429,6 +429,11 @@ class NodeDB
     // the legacy descriptor and copies entries into the v25 layout. Caller
     // is responsible for save / install-default on the result.
     bool migrateLegacyNodeDatabase();
+
+    // Route satellite-store decode entries straight into our maps instead of
+    // temp vectors. Must be paired — disarm before any other NodeDatabase decode.
+    void armNodeDatabaseDecodeTargets();
+    void disarmNodeDatabaseDecodeTargets();
 };
 
 extern NodeDB *nodeDB;

src/mesh/PacketHistory.cpp

@@ -9,8 +9,8 @@
 #include "Throttle.h"
 
 #define PACKETHISTORY_MAX                                                                                                        \
-    max((u_int32_t)(MAX_NUM_NODES * 2.0),                                                                                        \
-        (u_int32_t)100) // x2..3  Should suffice. Empirical setup. 16B per record malloc'ed, but no less than 100
+    max((uint32_t)(MAX_NUM_NODES * 2.0),                                                                                         \
+        (uint32_t)100) // x2..3  Should suffice. Empirical setup. 16B per record malloc'ed, but no less than 100
 
 #define RECENT_WARN_AGE (10 * 60 * 1000L) // Warn if the packet that gets removed was more recent than 10 min
 

src/mesh/PhoneAPI.cpp

@@ -62,7 +62,7 @@ void PhoneAPI::handleStartConfig()
     onConfigStart();
 
     // even if we were already connected - restart our state machine
-    if (config_nonce == SPECIAL_NONCE_ONLY_NODES || config_nonce == SPECIAL_NONCE_GRADIENT_ONLY_NODES) {
+    if (config_nonce == SPECIAL_NONCE_ONLY_NODES) {
         // If client only wants node info, jump directly to sending nodes
         state = STATE_SEND_OWN_NODEINFO;
         LOG_INFO("Client only wants node info, skipping other config");
@@ -71,7 +71,15 @@ void PhoneAPI::handleStartConfig()
     }
     pauseBluetoothLogging = true;
     spiLock->lock();
+#if defined(MESHTASTIC_EXCLUDE_FILES_MANIFEST)
+    // Skip the recursive FS walk. Used by platforms whose Zephyr LittleFS
+    // backend can't safely traverse a deep tree (e.g. nRF54L15) and platforms
+    // that don't support OTA browsing — the manifest is only consumed by
+    // companion apps for those flows.
+    filesManifest.clear();
+#else
     filesManifest = getFiles("/", 10);
+#endif
     spiLock->unlock();
     LOG_DEBUG("Got %d files in manifest", filesManifest.size());
 
@@ -138,6 +146,7 @@ void PhoneAPI::close()
             replayTelemetryIndex = 0;
             replayEnvironmentIndex = 0;
             replayStatusIndex = 0;
+            replayPhase = REPLAY_PHASE_IDLE;
         }
         packetForPhone = NULL;
         filesManifest.clear();
@@ -320,7 +329,7 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
                 nodeInfoForPhone.num = 0;
             }
         }
-        if (config_nonce == SPECIAL_NONCE_ONLY_NODES || config_nonce == SPECIAL_NONCE_GRADIENT_ONLY_NODES) {
+        if (config_nonce == SPECIAL_NONCE_ONLY_NODES) {
             // If client only wants node info, jump directly to sending nodes
             state = STATE_SEND_OTHER_NODEINFOS;
             onNowHasData(0);
@@ -535,135 +544,16 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
             // Just in case we stored a different user.id in the past, but should never happen going forward
             sprintf(infoToSend.user.id, "!%08x", infoToSend.num);
 
-            // Logging this really slows down sending nodes on initial connection because the serial console is so slow, so only
-            // uncomment if you really need to:
-            // LOG_INFO("nodeinfo: num=0x%x, lastseen=%u, id=%s, name=%s", nodeInfoForPhone.num, nodeInfoForPhone.last_heard,
-            // nodeInfoForPhone.user.id, nodeInfoForPhone.user.long_name);
-
             fromRadioScratch.which_payload_variant = meshtastic_FromRadio_node_info_tag;
             fromRadioScratch.node_info = infoToSend;
             prefetchNodeInfos();
         } else {
             LOG_DEBUG("Done sending %d of %d nodeinfos millis=%u", readIndex, nodeDB->getNumMeshNodes(), millis());
-            concurrency::LockGuard guard(&nodeInfoMutex);
+            nodeInfoMutex.lock();
             nodeInfoQueue.clear();
-            // Replay states no-op for legacy clients / excluded DBs.
-            state = STATE_REPLAY_POSITIONS;
-            return getFromRadio(buf);
-        }
-        break;
-    }
-
-    case STATE_REPLAY_POSITIONS: {
-        if (replayPositionOrder.empty() && replayPositionIndex == 0)
-            beginReplayPositions();
-        prefetchReplayPositions();
-
-        meshtastic_MeshPacket pkt = {};
-        bool havePkt = false;
-        {
-            concurrency::LockGuard guard(&nodeInfoMutex);
-            if (!replayQueue.empty()) {
-                pkt = replayQueue.front();
-                replayQueue.pop_front();
-                havePkt = true;
-            }
-        }
-
-        if (havePkt) {
-            fromRadioScratch.which_payload_variant = meshtastic_FromRadio_packet_tag;
-            fromRadioScratch.packet = pkt;
-        } else {
-            LOG_DEBUG("Done replaying positions count=%u millis=%u", (unsigned)replayPositionIndex, millis());
-            state = STATE_REPLAY_TELEMETRY;
-            return getFromRadio(buf);
-        }
-        break;
-    }
-
-    case STATE_REPLAY_TELEMETRY: {
-        if (replayTelemetryOrder.empty() && replayTelemetryIndex == 0)
-            beginReplayTelemetry();
-        prefetchReplayTelemetry();
-
-        meshtastic_MeshPacket pkt = {};
-        bool havePkt = false;
-        {
-            concurrency::LockGuard guard(&nodeInfoMutex);
-            if (!replayQueue.empty()) {
-                pkt = replayQueue.front();
-                replayQueue.pop_front();
-                havePkt = true;
-            }
-        }
-
-        if (havePkt) {
-            fromRadioScratch.which_payload_variant = meshtastic_FromRadio_packet_tag;
-            fromRadioScratch.packet = pkt;
-        } else {
-            LOG_DEBUG("Done replaying telemetry count=%u millis=%u", (unsigned)replayTelemetryIndex, millis());
-            state = STATE_REPLAY_ENVIRONMENT;
-            return getFromRadio(buf);
-        }
-        break;
-    }
-
-    case STATE_REPLAY_ENVIRONMENT: {
-        if (replayEnvironmentOrder.empty() && replayEnvironmentIndex == 0)
-            beginReplayEnvironment();
-        prefetchReplayEnvironment();
-
-        meshtastic_MeshPacket pkt = {};
-        bool havePkt = false;
-        {
-            concurrency::LockGuard guard(&nodeInfoMutex);
-            if (!replayQueue.empty()) {
-                pkt = replayQueue.front();
-                replayQueue.pop_front();
-                havePkt = true;
-            }
-        }
-
-        if (havePkt) {
-            fromRadioScratch.which_payload_variant = meshtastic_FromRadio_packet_tag;
-            fromRadioScratch.packet = pkt;
-        } else {
-            LOG_DEBUG("Done replaying environment count=%u millis=%u", (unsigned)replayEnvironmentIndex, millis());
-            state = STATE_REPLAY_STATUS;
-            return getFromRadio(buf);
-        }
-        break;
-    }
-
-    case STATE_REPLAY_STATUS: {
-        if (replayStatusOrder.empty() && replayStatusIndex == 0)
-            beginReplayStatus();
-        prefetchReplayStatus();
-
-        meshtastic_MeshPacket pkt = {};
-        bool havePkt = false;
-        {
-            concurrency::LockGuard guard(&nodeInfoMutex);
-            if (!replayQueue.empty()) {
-                pkt = replayQueue.front();
-                replayQueue.pop_front();
-                havePkt = true;
-            }
-        }
-
-        if (havePkt) {
-            fromRadioScratch.which_payload_variant = meshtastic_FromRadio_packet_tag;
-            fromRadioScratch.packet = pkt;
-        } else {
-            LOG_DEBUG("Done replaying status count=%u millis=%u", (unsigned)replayStatusIndex, millis());
-            replayPositionOrder.clear();
-            replayPositionOrder.shrink_to_fit();
-            replayTelemetryOrder.clear();
-            replayTelemetryOrder.shrink_to_fit();
-            replayEnvironmentOrder.clear();
-            replayEnvironmentOrder.shrink_to_fit();
-            replayStatusOrder.clear();
-            replayStatusOrder.shrink_to_fit();
+            nodeInfoMutex.unlock();
+            // Satellite-DB replay (positions/telemetry/environment/status) now happens
+            // *after* config_complete_id, interleaved with live traffic in STATE_SEND_PACKETS.
             state = STATE_SEND_FILEMANIFEST;
             return getFromRadio(buf);
         }
@@ -673,8 +563,7 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
     case STATE_SEND_FILEMANIFEST: {
         LOG_DEBUG("FromRadio=STATE_SEND_FILEMANIFEST");
         // ONLY_NODES variants skip the manifest.
-        if (config_state == filesManifest.size() || config_nonce == SPECIAL_NONCE_ONLY_NODES ||
-            config_nonce == SPECIAL_NONCE_GRADIENT_ONLY_NODES) {
+        if (config_state == filesManifest.size() || config_nonce == SPECIAL_NONCE_ONLY_NODES) {
             config_state = 0;
             filesManifest.clear();
             // Skip to complete packet
@@ -719,6 +608,16 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
             fromRadioScratch.which_payload_variant = meshtastic_FromRadio_packet_tag;
             fromRadioScratch.packet = *packetForPhone;
             releasePhonePacket();
+        } else if (replayPending()) {
+            // No live packet pending — feed the phone one cached satellite-DB packet.
+            // popReplayPacket advances through positions->telemetry->environment->status,
+            // and flips replayPhase back to IDLE when everything has been drained.
+            meshtastic_MeshPacket replayPkt;
+            if (popReplayPacket(replayPkt)) {
+                printPacket("replay packet to phone", &replayPkt);
+                fromRadioScratch.which_payload_variant = meshtastic_FromRadio_packet_tag;
+                fromRadioScratch.packet = replayPkt;
+            }
         }
         break;
 
@@ -743,10 +642,19 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
 void PhoneAPI::sendConfigComplete()
 {
     LOG_INFO("Config Send Complete millis=%u", millis());
+    const bool shouldReplaySatellites = (config_nonce != SPECIAL_NONCE_ONLY_CONFIG);
+    // The phone sees config_complete_id first (treats sync as done), then the cached
+    // satellite-DB packets (positions / telemetry / environment / status) trickle in
+    // afterward as ordinary mesh packets (except SPECIAL_NONCE_ONLY_CONFIG, which
+    // skips node/satellite sync entirely). Any client that handles live POSITION_APP /
+    // TELEMETRY_APP / NODE_STATUS_APP packets handles these identically. STM32WL and
+    // other builds that compile the satellite DBs out produce no replay packets and
+    // the phase advances to IDLE in microseconds.
     fromRadioScratch.which_payload_variant = meshtastic_FromRadio_config_complete_id_tag;
     fromRadioScratch.config_complete_id = config_nonce;
     config_nonce = 0;
     state = STATE_SEND_PACKETS;
+    replayPhase = shouldReplaySatellites ? REPLAY_PHASE_POSITIONS : REPLAY_PHASE_IDLE;
     if (api_type == TYPE_BLE) {
         service->api_state = service->STATE_BLE;
     } else if (api_type == TYPE_WIFI) {
@@ -787,7 +695,8 @@ void PhoneAPI::prefetchNodeInfos()
 {
     bool added = false;
     bool wasEmpty = false;
-    const bool gradient = clientWantsGradientSync();
+    // Other-node NodeInfos always go out thin (no bundled position/device_metrics).
+    // The post-config_complete_id replay drain delivers those as ordinary mesh packets.
     // Keep the queue topped up so BLE reads stay responsive even if DB fetches take a moment.
     {
         concurrency::LockGuard guard(&nodeInfoMutex);
@@ -797,8 +706,7 @@ void PhoneAPI::prefetchNodeInfos()
             if (!nextNode)
                 break;
 
-            auto info =
-                gradient ? TypeConversions::ConvertToNodeInfoThin(nextNode) : TypeConversions::ConvertToNodeInfo(nextNode);
+            auto info = TypeConversions::ConvertToNodeInfoThin(nextNode);
             bool isUs = info.num == nodeDB->getNodeNum();
             info.hops_away = isUs ? 0 : info.hops_away;
             info.last_heard = isUs ? getValidTime(RTCQualityFromNet) : info.last_heard;
@@ -820,11 +728,20 @@ void PhoneAPI::prefetchNodeInfos()
 
 meshtastic_MeshPacket PhoneAPI::makeReplayPositionPacket(NodeNum num, const meshtastic_PositionLite &pos)
 {
+    // Shape this exactly like a fresh live broadcast Position from the peer so the
+    // phone runs it through its normal "live position broadcast" handler path.
+    // to=ourNum would read as a DM-from-peer and never lands in node detail UI.
     meshtastic_MeshPacket pkt = meshtastic_MeshPacket_init_default;
     pkt.from = num;
-    pkt.to = nodeDB->getNodeNum();
+    pkt.to = NODENUM_BROADCAST;
     pkt.id = generatePacketId();
     pkt.rx_time = pos.time;
+    pkt.channel = 0;
+    pkt.hop_limit = Default::getConfiguredOrDefaultHopLimit(config.lora.hop_limit);
+    pkt.hop_start = pkt.hop_limit;
+    pkt.priority = meshtastic_MeshPacket_Priority_BACKGROUND;
+    // Mark as if heard over the air, not internally generated
+    pkt.transport_mechanism = meshtastic_MeshPacket_TransportMechanism_TRANSPORT_LORA;
     pkt.which_payload_variant = meshtastic_MeshPacket_decoded_tag;
     pkt.decoded.portnum = meshtastic_PortNum_POSITION_APP;
     meshtastic_Position fullPos = TypeConversions::ConvertToPosition(pos);
@@ -838,11 +755,18 @@ meshtastic_MeshPacket PhoneAPI::makeReplayTelemetryPacket(NodeNum num, const mes
 {
     meshtastic_MeshPacket pkt = meshtastic_MeshPacket_init_default;
     pkt.from = num;
-    pkt.to = nodeDB->getNodeNum();
+    pkt.to = NODENUM_BROADCAST;
     pkt.id = generatePacketId();
     // No native timestamp on telemetry packets here; use last_heard.
     const meshtastic_NodeInfoLite *header = nodeDB->getMeshNode(num);
     pkt.rx_time = header ? header->last_heard : 0;
+    pkt.channel = 0;
+    pkt.hop_limit = Default::getConfiguredOrDefaultHopLimit(config.lora.hop_limit);
+    pkt.hop_start = pkt.hop_limit;
+    pkt.priority = meshtastic_MeshPacket_Priority_BACKGROUND;
+    // Mark as if heard over the air, not internally generated — iOS client filters
+    // TRANSPORT_INTERNAL packets out of broadcast peer state updates.
+    pkt.transport_mechanism = meshtastic_MeshPacket_TransportMechanism_TRANSPORT_LORA;
     pkt.which_payload_variant = meshtastic_MeshPacket_decoded_tag;
     pkt.decoded.portnum = meshtastic_PortNum_TELEMETRY_APP;
     meshtastic_Telemetry fullTel = meshtastic_Telemetry_init_default;
@@ -858,16 +782,12 @@ meshtastic_MeshPacket PhoneAPI::makeReplayTelemetryPacket(NodeNum num, const mes
 void PhoneAPI::beginReplayPositions()
 {
 #if MESHTASTIC_EXCLUDE_POSITIONDB
-    // Build excluded entirely - leave the order list empty so the state arm
+    // Build excluded entirely - leave the order list empty so the phase
     // immediately drains and advances.
     replayPositionOrder.clear();
     replayPositionIndex = 0;
 #else
-    if (!clientWantsGradientSync()) {
-        replayPositionOrder.clear();
-        replayPositionIndex = 0;
-        return;
-    }
+    // Caller (popReplayPacket) only invokes us when replayPhase is armed.
     // Snapshot the keyset at phase start so concurrent inserts/erases on the
     // map don't invalidate iteration. Skip our own node - the phone already
     // got our position bundled in STATE_SEND_OWN_NODEINFO.
@@ -882,8 +802,6 @@ void PhoneAPI::prefetchReplayPositions()
 #if MESHTASTIC_EXCLUDE_POSITIONDB
     return;
 #else
-    if (!clientWantsGradientSync())
-        return;
     bool added = false;
     bool wasEmpty = false;
     {
@@ -909,11 +827,6 @@ void PhoneAPI::beginReplayTelemetry()
     replayTelemetryOrder.clear();
     replayTelemetryIndex = 0;
 #else
-    if (!clientWantsGradientSync()) {
-        replayTelemetryOrder.clear();
-        replayTelemetryIndex = 0;
-        return;
-    }
     replayTelemetryOrder = nodeDB->snapshotTelemetryNodeNums(nodeDB->getNodeNum());
     replayTelemetryIndex = 0;
     LOG_INFO("Begin telemetry replay: %u entries millis=%u", (unsigned)replayTelemetryOrder.size(), millis());
@@ -925,8 +838,6 @@ void PhoneAPI::prefetchReplayTelemetry()
 #if MESHTASTIC_EXCLUDE_TELEMETRYDB
     return;
 #else
-    if (!clientWantsGradientSync())
-        return;
     bool added = false;
     bool wasEmpty = false;
     {
@@ -950,10 +861,17 @@ meshtastic_MeshPacket PhoneAPI::makeReplayEnvironmentPacket(uint32_t num, const
 {
     meshtastic_MeshPacket pkt = meshtastic_MeshPacket_init_default;
     pkt.from = num;
-    pkt.to = nodeDB->getNodeNum();
+    pkt.to = NODENUM_BROADCAST;
     pkt.id = generatePacketId();
     const meshtastic_NodeInfoLite *header = nodeDB->getMeshNode(num);
     pkt.rx_time = header ? header->last_heard : 0;
+    pkt.channel = 0;
+    pkt.hop_limit = Default::getConfiguredOrDefaultHopLimit(config.lora.hop_limit);
+    pkt.hop_start = pkt.hop_limit;
+    pkt.priority = meshtastic_MeshPacket_Priority_BACKGROUND;
+    // Mark as if heard over the air, not internally generated — iOS client filters
+    // TRANSPORT_INTERNAL packets out of broadcast peer state updates.
+    pkt.transport_mechanism = meshtastic_MeshPacket_TransportMechanism_TRANSPORT_LORA;
     pkt.which_payload_variant = meshtastic_MeshPacket_decoded_tag;
     pkt.decoded.portnum = meshtastic_PortNum_TELEMETRY_APP;
     meshtastic_Telemetry fullTel = meshtastic_Telemetry_init_default;
@@ -972,11 +890,6 @@ void PhoneAPI::beginReplayEnvironment()
     replayEnvironmentOrder.clear();
     replayEnvironmentIndex = 0;
 #else
-    if (!clientWantsGradientSync()) {
-        replayEnvironmentOrder.clear();
-        replayEnvironmentIndex = 0;
-        return;
-    }
     replayEnvironmentOrder = nodeDB->snapshotEnvironmentNodeNums(nodeDB->getNodeNum());
     replayEnvironmentIndex = 0;
     LOG_INFO("Begin environment replay: %u entries millis=%u", (unsigned)replayEnvironmentOrder.size(), millis());
@@ -988,8 +901,6 @@ void PhoneAPI::prefetchReplayEnvironment()
 #if MESHTASTIC_EXCLUDE_ENVIRONMENTDB
     return;
 #else
-    if (!clientWantsGradientSync())
-        return;
     bool added = false;
     bool wasEmpty = false;
     {
@@ -1013,11 +924,17 @@ meshtastic_MeshPacket PhoneAPI::makeReplayStatusPacket(uint32_t num, const mesht
 {
     meshtastic_MeshPacket pkt = meshtastic_MeshPacket_init_default;
     pkt.from = num;
-    pkt.to = nodeDB->getNodeNum();
+    pkt.to = NODENUM_BROADCAST;
     pkt.id = generatePacketId();
     // StatusMessage has no native timestamp; use last_heard.
     const meshtastic_NodeInfoLite *header = nodeDB->getMeshNode(num);
     pkt.rx_time = header ? header->last_heard : 0;
+    pkt.channel = 0;
+    pkt.hop_limit = Default::getConfiguredOrDefaultHopLimit(config.lora.hop_limit);
+    pkt.hop_start = pkt.hop_limit;
+    pkt.priority = meshtastic_MeshPacket_Priority_BACKGROUND;
+    // Mark as if heard over the air, not internally generated — client filters
+    pkt.transport_mechanism = meshtastic_MeshPacket_TransportMechanism_TRANSPORT_LORA;
     pkt.which_payload_variant = meshtastic_MeshPacket_decoded_tag;
     pkt.decoded.portnum = meshtastic_PortNum_NODE_STATUS_APP;
     size_t len =
@@ -1032,11 +949,6 @@ void PhoneAPI::beginReplayStatus()
     replayStatusOrder.clear();
     replayStatusIndex = 0;
 #else
-    if (!clientWantsGradientSync()) {
-        replayStatusOrder.clear();
-        replayStatusIndex = 0;
-        return;
-    }
     replayStatusOrder = nodeDB->snapshotStatusNodeNums(nodeDB->getNodeNum());
     replayStatusIndex = 0;
     LOG_INFO("Begin status replay: %u entries millis=%u", (unsigned)replayStatusOrder.size(), millis());
@@ -1048,8 +960,6 @@ void PhoneAPI::prefetchReplayStatus()
 #if MESHTASTIC_EXCLUDE_STATUSDB
     return;
 #else
-    if (!clientWantsGradientSync())
-        return;
     bool added = false;
     bool wasEmpty = false;
     {
@@ -1069,6 +979,94 @@ void PhoneAPI::prefetchReplayStatus()
 #endif
 }
 
+// Pop one cached satellite-DB packet from the active replay phase.
+// Phases drain in order: positions -> telemetry -> environment -> status.
+// When the current phase's cursor is exhausted (queue empty AND no more entries
+// to snapshot), advance to the next phase. When all four phases are done,
+// flip replayPhase back to IDLE and release the snapshot vectors.
+//
+// Returns true if a packet was placed in `out`; false if everything is drained.
+bool PhoneAPI::popReplayPacket(meshtastic_MeshPacket &out)
+{
+    while (replayPhase != REPLAY_PHASE_IDLE) {
+        // Prime the active phase: seed the snapshot vector on first entry,
+        // top up replayQueue from the snapshot up to kReplayPrefetchDepth.
+        switch (replayPhase) {
+        case REPLAY_PHASE_POSITIONS:
+            if (replayPositionOrder.empty() && replayPositionIndex == 0)
+                beginReplayPositions();
+            prefetchReplayPositions();
+            break;
+        case REPLAY_PHASE_TELEMETRY:
+            if (replayTelemetryOrder.empty() && replayTelemetryIndex == 0)
+                beginReplayTelemetry();
+            prefetchReplayTelemetry();
+            break;
+        case REPLAY_PHASE_ENVIRONMENT:
+            if (replayEnvironmentOrder.empty() && replayEnvironmentIndex == 0)
+                beginReplayEnvironment();
+            prefetchReplayEnvironment();
+            break;
+        case REPLAY_PHASE_STATUS:
+            if (replayStatusOrder.empty() && replayStatusIndex == 0)
+                beginReplayStatus();
+            prefetchReplayStatus();
+            break;
+        default:
+            break;
+        }
+
+        {
+            concurrency::LockGuard guard(&nodeInfoMutex);
+            if (!replayQueue.empty()) {
+                out = replayQueue.front();
+                replayQueue.pop_front();
+                return true;
+            }
+        }
+
+        // Queue empty AND no more entries to feed it — phase is exhausted.
+        advanceReplayPhase();
+    }
+    return false;
+}
+
+void PhoneAPI::advanceReplayPhase()
+{
+    switch (replayPhase) {
+    case REPLAY_PHASE_POSITIONS:
+        LOG_DEBUG("Replay drain: positions done (count=%u) millis=%u", (unsigned)replayPositionIndex, millis());
+        replayPhase = REPLAY_PHASE_TELEMETRY;
+        break;
+    case REPLAY_PHASE_TELEMETRY:
+        LOG_DEBUG("Replay drain: telemetry done (count=%u) millis=%u", (unsigned)replayTelemetryIndex, millis());
+        replayPhase = REPLAY_PHASE_ENVIRONMENT;
+        break;
+    case REPLAY_PHASE_ENVIRONMENT:
+        LOG_DEBUG("Replay drain: environment done (count=%u) millis=%u", (unsigned)replayEnvironmentIndex, millis());
+        replayPhase = REPLAY_PHASE_STATUS;
+        break;
+    case REPLAY_PHASE_STATUS:
+        LOG_INFO("Replay drain complete (status count=%u) millis=%u", (unsigned)replayStatusIndex, millis());
+        replayPositionOrder.clear();
+        replayPositionOrder.shrink_to_fit();
+        replayTelemetryOrder.clear();
+        replayTelemetryOrder.shrink_to_fit();
+        replayEnvironmentOrder.clear();
+        replayEnvironmentOrder.shrink_to_fit();
+        replayStatusOrder.clear();
+        replayStatusOrder.shrink_to_fit();
+        replayPositionIndex = 0;
+        replayTelemetryIndex = 0;
+        replayEnvironmentIndex = 0;
+        replayStatusIndex = 0;
+        replayPhase = REPLAY_PHASE_IDLE;
+        break;
+    default:
+        break;
+    }
+}
+
 void PhoneAPI::releaseMqttClientProxyPhonePacket()
 {
     if (mqttClientProxyMessageForPhone) {
@@ -1115,31 +1113,6 @@ bool PhoneAPI::available()
     PREFETCH_NODEINFO:
         prefetchNodeInfos();
         return true;
-    case STATE_REPLAY_POSITIONS: {
-        // Prime the iterator if we haven't yet, then top up the queue.
-        if (replayPositionOrder.empty() && replayPositionIndex == 0)
-            beginReplayPositions();
-        prefetchReplayPositions();
-        return true; // Always advance state machine; arm itself transitions when drained
-    }
-    case STATE_REPLAY_TELEMETRY: {
-        if (replayTelemetryOrder.empty() && replayTelemetryIndex == 0)
-            beginReplayTelemetry();
-        prefetchReplayTelemetry();
-        return true;
-    }
-    case STATE_REPLAY_ENVIRONMENT: {
-        if (replayEnvironmentOrder.empty() && replayEnvironmentIndex == 0)
-            beginReplayEnvironment();
-        prefetchReplayEnvironment();
-        return true;
-    }
-    case STATE_REPLAY_STATUS: {
-        if (replayStatusOrder.empty() && replayStatusIndex == 0)
-            beginReplayStatus();
-        prefetchReplayStatus();
-        return true;
-    }
     case STATE_SEND_PACKETS: {
         if (!queueStatusPacketForPhone)
             queueStatusPacketForPhone = service->getQueueStatusForPhone();
@@ -1171,7 +1144,11 @@ bool PhoneAPI::available()
         if (!packetForPhone)
             packetForPhone = service->getForPhone();
         hasPacket = !!packetForPhone;
-        return hasPacket;
+        if (hasPacket)
+            return true;
+        // Trailing replay drain — feeds cached satellite-DB packets alongside
+        // (lower priority than) live traffic.
+        return replayPending();
     }
     default:
         LOG_ERROR("PhoneAPI::available unexpected state %d", state);

src/mesh/PhoneAPI.h

@@ -26,9 +26,6 @@
 
 #define SPECIAL_NONCE_ONLY_CONFIG 69420
 #define SPECIAL_NONCE_ONLY_NODES 69421 // ( ͡° ͜ʖ ͡°)
-// Gradient sync: phone sends one of these to opt into thin-header + replay.
-#define SPECIAL_NONCE_GRADIENT_SYNC 69422
-#define SPECIAL_NONCE_GRADIENT_ONLY_NODES 69423
 
 /**
  * Provides our protobuf based API which phone/PC clients can use to talk to our device
@@ -52,15 +49,22 @@ class PhoneAPI
         STATE_SEND_CONFIG,          // Replacement for the old Radioconfig
         STATE_SEND_MODULECONFIG,    // Send Module specific config
         STATE_SEND_OTHER_NODEINFOS, // states progress in this order as the device sends to to the client
-        // Drain satellite DBs as synthetic POSITION_APP / TELEMETRY_APP /
-        // NODE_STATUS_APP packets when the phone opted into gradient sync.
-        STATE_REPLAY_POSITIONS,
-        STATE_REPLAY_TELEMETRY,
-        STATE_REPLAY_ENVIRONMENT,
-        STATE_REPLAY_STATUS,
-        STATE_SEND_FILEMANIFEST, // Send file manifest
+        STATE_SEND_FILEMANIFEST,    // Send file manifest
         STATE_SEND_COMPLETE_ID,
-        STATE_SEND_PACKETS // send packets or debug strings
+        STATE_SEND_PACKETS // live mesh packets + any cached satellite-DB replay that trails sync completion
+    };
+
+    // Satellite-DB replay (positions / telemetry / environment / status) used to live
+    // as four top-level states between STATE_SEND_OTHER_NODEINFOS and STATE_SEND_FILEMANIFEST.
+    // It now drains *after* config_complete_id has been emitted: the phone considers the
+    // initial sync done as soon as headers + manifest are delivered, and the cached
+    // position/telemetry/etc. trickle in alongside live mesh traffic inside STATE_SEND_PACKETS.
+    enum ReplayPhase : uint8_t {
+        REPLAY_PHASE_IDLE = 0, // not replaying (legacy clients, no-op DBs, or replay finished)
+        REPLAY_PHASE_POSITIONS,
+        REPLAY_PHASE_TELEMETRY,
+        REPLAY_PHASE_ENVIRONMENT,
+        REPLAY_PHASE_STATUS,
     };
 
     State state = STATE_SEND_NOTHING;
@@ -114,6 +118,7 @@ class PhoneAPI
     size_t replayTelemetryIndex = 0;
     size_t replayEnvironmentIndex = 0;
     size_t replayStatusIndex = 0;
+    ReplayPhase replayPhase = REPLAY_PHASE_IDLE; // armed by sendConfigComplete() for full/default sync
 
     meshtastic_ToRadio toRadioScratch = {
         0}; // this is a static scratch object, any data must be copied elsewhere before returning
@@ -164,10 +169,6 @@ class PhoneAPI
 
     bool isConnected() { return state != STATE_SEND_NOTHING; }
     bool isSendingPackets() { return state == STATE_SEND_PACKETS; }
-    bool clientWantsGradientSync() const
-    {
-        return config_nonce == SPECIAL_NONCE_GRADIENT_SYNC || config_nonce == SPECIAL_NONCE_GRADIENT_ONLY_NODES;
-    }
 
   protected:
     /// Our fromradio packet while it is being assembled
@@ -229,6 +230,12 @@ class PhoneAPI
     meshtastic_MeshPacket makeReplayEnvironmentPacket(uint32_t num, const meshtastic_EnvironmentMetrics &env);
     meshtastic_MeshPacket makeReplayStatusPacket(uint32_t num, const meshtastic_StatusMessage &status);
 
+    // Post-sync replay drain: pop one cached packet from the active phase, advancing
+    // through positions -> telemetry -> environment -> status until everything is drained.
+    bool popReplayPacket(meshtastic_MeshPacket &out);
+    void advanceReplayPhase();
+    bool replayPending() const { return replayPhase != REPLAY_PHASE_IDLE; }
+
     void releaseMqttClientProxyPhonePacket();
 
     void releaseClientNotification();

src/mesh/PositionPrecision.cpp

@@ -0,0 +1,75 @@
+#include "PositionPrecision.h"
+#include "Channels.h"
+#include "mesh-pb-constants.h"
+
+#include <Arduino.h>
+
+uint32_t getPositionPrecisionForChannel(uint8_t channelIndex)
+{
+    const meshtastic_Channel &channel = channels.getByIndex(channelIndex);
+
+    if (channel.settings.has_module_settings) {
+        return channel.settings.module_settings.position_precision;
+    } else if (channel.role == meshtastic_Channel_Role_PRIMARY) {
+        return 32;
+    } else {
+        return 0;
+    }
+}
+
+static int32_t truncateCoordinate(int32_t coordinate, uint32_t precision)
+{
+    uint32_t coordinateBits = static_cast<uint32_t>(coordinate);
+    uint32_t truncated = coordinateBits & (UINT32_MAX << (32 - precision));
+
+    // Use the middle of the possible location, not the low edge of the bucket.
+    truncated += (1UL << (31 - precision));
+
+    return static_cast<int32_t>(truncated);
+}
+
+void applyPositionPrecision(meshtastic_Position &position, uint32_t precision)
+{
+    if (precision == 0) {
+        uint32_t time = position.time;
+        position = meshtastic_Position_init_default;
+        position.time = time;
+        return;
+    }
+
+    uint32_t effectivePrecision = precision > 32 ? 32 : precision;
+    position.precision_bits = effectivePrecision;
+
+    if (effectivePrecision < 32) {
+        position.latitude_i = truncateCoordinate(position.latitude_i, effectivePrecision);
+        position.longitude_i = truncateCoordinate(position.longitude_i, effectivePrecision);
+    }
+}
+
+bool applyPositionPrecision(meshtastic_MeshPacket &packet, uint32_t precision)
+{
+    if (packet.which_payload_variant != meshtastic_MeshPacket_decoded_tag ||
+        packet.decoded.portnum != meshtastic_PortNum_POSITION_APP) {
+        return true;
+    }
+
+    meshtastic_Position position = meshtastic_Position_init_default;
+    if (!pb_decode_from_bytes(packet.decoded.payload.bytes, packet.decoded.payload.size, &meshtastic_Position_msg, &position)) {
+        return false;
+    }
+
+    applyPositionPrecision(position, precision);
+    packet.decoded.payload.size = pb_encode_to_bytes(packet.decoded.payload.bytes, sizeof(packet.decoded.payload.bytes),
+                                                     &meshtastic_Position_msg, &position);
+    return true;
+}
+
+bool applyPositionPrecisionForChannel(meshtastic_MeshPacket &packet, uint8_t channelIndex)
+{
+    if (packet.which_payload_variant != meshtastic_MeshPacket_decoded_tag ||
+        packet.decoded.portnum != meshtastic_PortNum_POSITION_APP) {
+        return true;
+    }
+
+    return applyPositionPrecision(packet, getPositionPrecisionForChannel(channelIndex));
+}

src/mesh/PositionPrecision.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "meshtastic/mesh.pb.h"
+#include <stdint.h>
+
+uint32_t getPositionPrecisionForChannel(uint8_t channelIndex);
+void applyPositionPrecision(meshtastic_Position &position, uint32_t precision);
+bool applyPositionPrecision(meshtastic_MeshPacket &packet, uint32_t precision);
+bool applyPositionPrecisionForChannel(meshtastic_MeshPacket &packet, uint8_t channelIndex);

src/mesh/RadioLibInterface.cpp

@@ -46,16 +46,6 @@ RadioLibInterface::RadioLibInterface(LockingArduinoHal *hal, RADIOLIB_PIN_TYPE c
 #endif
 }
 
-RadioLibInterface::~RadioLibInterface()
-{
-    // If the static `instance` pointer still references us, clear it.
-    // A later successful init() may have replaced `instance` with a newer
-    // interface — don't clobber that case.
-    if (instance == this) {
-        instance = nullptr;
-    }
-}
-
 #ifdef ARCH_ESP32
 // ESP32 doesn't use that flag
 #define YIELD_FROM_ISR(x) portYIELD_FROM_ISR()
@@ -434,6 +424,9 @@ void RadioLibInterface::completeSending()
     // that can take a long time
     auto p = sendingPacket;
     sendingPacket = NULL;
+#ifdef LED_LORA
+    digitalWrite(LED_LORA, LED_STATE_OFF);
+#endif
 
     if (p) {
         // Packet has been sent, count it toward our TX airtime utilization.
@@ -555,6 +548,9 @@ void RadioLibInterface::pollMissedIrqs()
     if (isReceiving) {
         checkRxDoneIrqFlag();
     }
+    if (sendingPacket) {
+        checkTxDoneIrqFlag();
+    }
 }
 
 void RadioLibInterface::resetAGC()
@@ -570,6 +566,14 @@ void RadioLibInterface::checkRxDoneIrqFlag()
     }
 }
 
+void RadioLibInterface::checkTxDoneIrqFlag()
+{
+    if (iface->checkIrq(RADIOLIB_IRQ_TX_DONE)) {
+        LOG_WARN("caught missed TX_DONE");
+        notify(ISR_TX, true);
+    }
+}
+
 void RadioLibInterface::configHardwareForSend()
 {
     powerMon->setState(meshtastic_PowerMon_State_Lora_TXOn);
@@ -611,6 +615,9 @@ bool RadioLibInterface::startSend(meshtastic_MeshPacket *txp)
             enableInterrupt(isrTxLevel0);
             lastTxStart = millis();
             printPacket("Started Tx", txp);
+#ifdef LED_LORA
+            digitalWrite(LED_LORA, LED_STATE_ON);
+#endif
         }
 
         return res == RADIOLIB_ERR_NONE;

src/mesh/RadioLibInterface.h

@@ -104,6 +104,13 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified
      */
     static RadioLibInterface *instance;
 
+    /** Clear instance on destruction so stale pointer checks in loop() are safe */
+    virtual ~RadioLibInterface()
+    {
+        if (instance == this)
+            instance = nullptr;
+    }
+
     /**
      * Glue functions called from ISR land
      */
@@ -136,13 +143,6 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified
     RadioLibInterface(LockingArduinoHal *hal, RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst,
                       RADIOLIB_PIN_TYPE busy, PhysicalLayer *iface = NULL);
 
-    /**
-     * Clear the static `instance` pointer if it still points at us, so callers
-     * that check `RadioLibInterface::instance != nullptr` don't dereference a
-     * freed object after a failed init() + unique_ptr reset.
-     */
-    virtual ~RadioLibInterface();
-
     virtual ErrorCode send(meshtastic_MeshPacket *p) override;
 
     /**
@@ -293,4 +293,5 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified
     bool removePendingTXPacket(NodeNum from, PacketId id, uint32_t hop_limit_lt) override;
 
     void checkRxDoneIrqFlag();
+    void checkTxDoneIrqFlag();
 };

src/mesh/Router.cpp

@@ -4,6 +4,7 @@
 #include "MeshRadio.h"
 #include "MeshService.h"
 #include "NodeDB.h"
+#include "PositionPrecision.h"
 #include "RTC.h"
 
 #include "configuration.h"
@@ -367,6 +368,11 @@ ErrorCode Router::send(meshtastic_MeshPacket *p)
     }
 
     fixPriority(p); // Before encryption, fix the priority if it's unset
+    if (!applyPositionPrecisionForChannel(*p, p->channel)) {
+        LOG_ERROR("Dropping malformed position packet before send");
+        packetPool.release(p);
+        return meshtastic_Routing_Error_BAD_REQUEST;
+    }
 
     // If the packet is not yet encrypted, do so now
     if (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag) {

src/mesh/TypeConversions.cpp

@@ -37,6 +37,7 @@ meshtastic_NodeInfo TypeConversions::ConvertToNodeInfo(const meshtastic_NodeInfo
         info.position.altitude = position->altitude;
         info.position.location_source = position->location_source;
         info.position.time = position->time;
+        info.position.precision_bits = position->precision_bits;
     }
     if (nodeInfoLiteHasUser(lite)) {
         info.has_user = true;
@@ -71,6 +72,7 @@ meshtastic_PositionLite TypeConversions::ConvertToPositionLite(meshtastic_Positi
     lite.altitude = position.altitude;
     lite.location_source = position.location_source;
     lite.time = position.time;
+    lite.precision_bits = position.precision_bits;
 
     return lite;
 }
@@ -89,6 +91,11 @@ meshtastic_Position TypeConversions::ConvertToPosition(meshtastic_PositionLite l
     position.altitude = lite.altitude;
     position.location_source = lite.location_source;
     position.time = lite.time;
+    // Preserve the peer's broadcast precision; falls back to 0 for entries cached
+    // before the precision_bits field existed in PositionLite (pre-migration data).
+    // iOS treats 0 as "unspecified precision" and won't render the pin — so for
+    // unset values, declare full precision so the stored lat/lon renders as a point.
+    position.precision_bits = lite.precision_bits == 0 ? 32 : lite.precision_bits;
 
     return position;
 }

src/mesh/api/ethServerAPI.cpp

@@ -1,7 +1,7 @@
 #include "configuration.h"
 #include <Arduino.h>
 
-#if HAS_ETHERNET && !defined(USE_WS5500)
+#if HAS_ETHERNET && !defined(USE_WS5500) && !defined(USE_CH390D)
 
 #include "ethServerAPI.h"
 

src/mesh/api/ethServerAPI.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "ServerAPI.h"
-#ifndef USE_WS5500
+#if !defined(USE_WS5500) && !defined(USE_CH390D)
 #include <RAK13800_W5100S.h>
 
 /**

src/mesh/eth/ethClient.cpp

@@ -9,7 +9,7 @@
 #include <RAK13800_W5100S.h>
 #include <SPI.h>
 
-#if HAS_NETWORKING
+#if HAS_NETWORKING && !defined(USE_WS5500) && !defined(USE_CH390D)
 
 #ifndef DISABLE_NTP
 #include <NTPClient.h>

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

@@ -15,6 +15,9 @@ PB_BIND(meshtastic_AdminMessage_InputEvent, meshtastic_AdminMessage_InputEvent,
 PB_BIND(meshtastic_AdminMessage_OTAEvent, meshtastic_AdminMessage_OTAEvent, AUTO)
 
 
+PB_BIND(meshtastic_LockdownAuth, meshtastic_LockdownAuth, AUTO)
+
+
 PB_BIND(meshtastic_HamParameters, meshtastic_HamParameters, AUTO)
 
 

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

@@ -130,6 +130,76 @@ typedef struct _meshtastic_AdminMessage_OTAEvent {
     meshtastic_AdminMessage_OTAEvent_ota_hash_t ota_hash;
 } meshtastic_AdminMessage_OTAEvent;
 
+typedef PB_BYTES_ARRAY_T(32) meshtastic_LockdownAuth_passphrase_t;
+/* Lockdown passphrase delivery payload.
+
+ One message handles three operations distinguished by content:
+   - Provision (first-time): passphrase set, lock_now=false. Firmware
+     generates DEK, wraps with passphrase-derived KEK, persists.
+   - Unlock: passphrase set, lock_now=false. Firmware verifies
+     passphrase against stored DEK, unlocks storage, authorizes the
+     connection that delivered this packet.
+   - Lock now: lock_now=true, passphrase ignored. Firmware revokes
+     all client auth and reboots into the locked state.
+
+ Firmware decides between provision and unlock based on its own state
+ (whether a DEK file already exists). Clients do not need to track
+ which case applies. */
+typedef struct _meshtastic_LockdownAuth {
+    /* Passphrase bytes (1-32). Empty when lock_now is true.
+ Capped to 32 to match the proto cap on related security fields. */
+    meshtastic_LockdownAuth_passphrase_t passphrase;
+    /* Optional override of the boot-count token TTL granted on success.
+ 0 = use firmware default (TOKEN_DEFAULT_BOOTS).
+ On reboot the firmware decrements this; when it reaches 0 the
+ device boots fully locked and requires a fresh passphrase. */
+    uint32_t boots_remaining;
+    /* Optional wall-clock expiry for the unlock token, as absolute
+ Unix-epoch seconds. 0 = no time limit (only the boot-count TTL
+ applies). On boot, if the device RTC is set and now > this value,
+ the token is treated as expired. */
+    uint32_t valid_until_epoch;
+    /* If true, ignore passphrase fields, immediately revoke all
+ connection-level admin authorization, and reboot the device into
+ the locked state. Always honoured regardless of current lock state. */
+    bool lock_now;
+    /* Optional per-boot uptime cap on the unlocked session, in seconds.
+ 0 = unlimited (token-only enforcement, suitable for unattended
+ tower / infrastructure nodes).
+
+ When non-zero, the firmware arms an uptime timer at unlock. On
+ each expiry, while there is still boot-count budget, the firmware
+ decrements the on-flash boot count in place, revokes per-
+ connection admin auth (clients must re-authenticate to see
+ content), re-engages the screen lock, and re-arms the timer
+ without rebooting. Mesh routing keeps running across session
+ boundaries; only when the boot-count budget reaches zero does
+ the device hard-lock and reboot.
+
+ Total exposure ceiling = ((resolved boot count) + 1) * max_session_seconds.
+ The +1 accounts for the initial passphrase-unlocked session
+ itself, since boots_remaining is the number of subsequent
+ session rolls (each consuming one boot from the rollback ledger).
+ The resolved boot count is the value the firmware writes into the
+ token at unlock time: the client-supplied boots_remaining when
+ non-zero, otherwise the firmware default (TOKEN_DEFAULT_BOOTS).
+ Note that boots_remaining == 0 in this message means "use firmware
+ default", NOT "zero boots" — a client computing the ceiling for
+ display should mirror that resolution rather than multiplying the
+ raw request value.
+
+ The cap is persisted in the token, so it survives token-based
+ auto-unlock across reboots. Explicit operator Lock Now still
+ deletes the token and forces passphrase re-entry.
+
+ Uses millis() (CPU uptime), not wall-clock time, so the cap is
+ immune to GPS spoofing, RTC backup-battery removal, and Faraday
+ cage isolation — none of those move the uptime counter. The only
+ way to reset the session clock is a reboot, which costs a boot
+ from the on-flash, HMAC-bound counter. */
+    uint32_t max_session_seconds;
+} meshtastic_LockdownAuth;
+
 /* Parameters for setting up Meshtastic for ameteur radio usage */
 typedef struct _meshtastic_HamParameters {
     /* Amateur radio call sign, eg. KD2ABC */
@@ -384,6 +454,15 @@ typedef struct _meshtastic_AdminMessage {
         meshtastic_AdminMessage_OTAEvent ota_request;
         /* Parameters and sensor configuration */
         meshtastic_SensorConfig sensor_config;
+        /* Lockdown passphrase delivery / unlock / lock-now command for hardened
+     firmware builds (see MESHTASTIC_LOCKDOWN). Used to provision the
+     passphrase on first boot, unlock encrypted storage on subsequent
+     reboots, re-verify on already-unlocked devices to authorize a new
+     client connection, or immediately re-lock the device.
+    
+     Replaces the earlier scheme that repurposed SecurityConfig.private_key
+     to carry passphrase bytes; that hack is retired. */
+        meshtastic_LockdownAuth lockdown_auth;
     };
     /* The node generates this key and sends it with any get_x_response packets.
  The client MUST include the same key with any set_x commands. Key expires after 300 seconds.
@@ -429,6 +508,7 @@ extern "C" {
 
 
 
+
 #define meshtastic_KeyVerificationAdmin_message_type_ENUMTYPE meshtastic_KeyVerificationAdmin_MessageType
 
 
@@ -441,6 +521,7 @@ extern "C" {
 #define meshtastic_AdminMessage_init_default     {0, {0}, {0, {0}}}
 #define meshtastic_AdminMessage_InputEvent_init_default {0, 0, 0, 0}
 #define meshtastic_AdminMessage_OTAEvent_init_default {_meshtastic_OTAMode_MIN, {0, {0}}}
+#define meshtastic_LockdownAuth_init_default     {{0, {0}}, 0, 0, 0, 0}
 #define meshtastic_HamParameters_init_default    {"", 0, 0, ""}
 #define meshtastic_NodeRemoteHardwarePinsResponse_init_default {0, {meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default}}
 #define meshtastic_SharedContact_init_default    {0, false, meshtastic_User_init_default, 0, 0}
@@ -453,6 +534,7 @@ extern "C" {
 #define meshtastic_AdminMessage_init_zero        {0, {0}, {0, {0}}}
 #define meshtastic_AdminMessage_InputEvent_init_zero {0, 0, 0, 0}
 #define meshtastic_AdminMessage_OTAEvent_init_zero {_meshtastic_OTAMode_MIN, {0, {0}}}
+#define meshtastic_LockdownAuth_init_zero        {{0, {0}}, 0, 0, 0, 0}
 #define meshtastic_HamParameters_init_zero       {"", 0, 0, ""}
 #define meshtastic_NodeRemoteHardwarePinsResponse_init_zero {0, {meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero}}
 #define meshtastic_SharedContact_init_zero       {0, false, meshtastic_User_init_zero, 0, 0}
@@ -470,6 +552,11 @@ extern "C" {
 #define meshtastic_AdminMessage_InputEvent_touch_y_tag 4
 #define meshtastic_AdminMessage_OTAEvent_reboot_ota_mode_tag 1
 #define meshtastic_AdminMessage_OTAEvent_ota_hash_tag 2
+#define meshtastic_LockdownAuth_passphrase_tag   1
+#define meshtastic_LockdownAuth_boots_remaining_tag 2
+#define meshtastic_LockdownAuth_valid_until_epoch_tag 3
+#define meshtastic_LockdownAuth_lock_now_tag     4
+#define meshtastic_LockdownAuth_max_session_seconds_tag 5
 #define meshtastic_HamParameters_call_sign_tag   1
 #define meshtastic_HamParameters_tx_power_tag    2
 #define meshtastic_HamParameters_frequency_tag   3
@@ -560,6 +647,7 @@ extern "C" {
 #define meshtastic_AdminMessage_nodedb_reset_tag 100
 #define meshtastic_AdminMessage_ota_request_tag  102
 #define meshtastic_AdminMessage_sensor_config_tag 103
+#define meshtastic_AdminMessage_lockdown_auth_tag 104
 #define meshtastic_AdminMessage_session_passkey_tag 101
 
 /* Struct field encoding specification for nanopb */
@@ -621,7 +709,8 @@ X(a, STATIC,   ONEOF,    INT32,    (payload_variant,factory_reset_config,factory
 X(a, STATIC,   ONEOF,    BOOL,     (payload_variant,nodedb_reset,nodedb_reset), 100) \
 X(a, STATIC,   SINGULAR, BYTES,    session_passkey, 101) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,ota_request,ota_request), 102) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,sensor_config,sensor_config), 103)
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,sensor_config,sensor_config), 103) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,lockdown_auth,lockdown_auth), 104)
 #define meshtastic_AdminMessage_CALLBACK NULL
 #define meshtastic_AdminMessage_DEFAULT NULL
 #define meshtastic_AdminMessage_payload_variant_get_channel_response_MSGTYPE meshtastic_Channel
@@ -644,6 +733,7 @@ X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,sensor_config,sensor_config)
 #define meshtastic_AdminMessage_payload_variant_key_verification_MSGTYPE meshtastic_KeyVerificationAdmin
 #define meshtastic_AdminMessage_payload_variant_ota_request_MSGTYPE meshtastic_AdminMessage_OTAEvent
 #define meshtastic_AdminMessage_payload_variant_sensor_config_MSGTYPE meshtastic_SensorConfig
+#define meshtastic_AdminMessage_payload_variant_lockdown_auth_MSGTYPE meshtastic_LockdownAuth
 
 #define meshtastic_AdminMessage_InputEvent_FIELDLIST(X, a) \
 X(a, STATIC,   SINGULAR, UINT32,   event_code,        1) \
@@ -659,6 +749,15 @@ X(a, STATIC,   SINGULAR, BYTES,    ota_hash,          2)
 #define meshtastic_AdminMessage_OTAEvent_CALLBACK NULL
 #define meshtastic_AdminMessage_OTAEvent_DEFAULT NULL
 
+#define meshtastic_LockdownAuth_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, BYTES,    passphrase,        1) \
+X(a, STATIC,   SINGULAR, UINT32,   boots_remaining,   2) \
+X(a, STATIC,   SINGULAR, UINT32,   valid_until_epoch,   3) \
+X(a, STATIC,   SINGULAR, BOOL,     lock_now,          4) \
+X(a, STATIC,   SINGULAR, UINT32,   max_session_seconds,   5)
+#define meshtastic_LockdownAuth_CALLBACK NULL
+#define meshtastic_LockdownAuth_DEFAULT NULL
+
 #define meshtastic_HamParameters_FIELDLIST(X, a) \
 X(a, STATIC,   SINGULAR, STRING,   call_sign,         1) \
 X(a, STATIC,   SINGULAR, INT32,    tx_power,          2) \
@@ -737,6 +836,7 @@ X(a, STATIC,   OPTIONAL, UINT32,   set_accuracy,      1)
 extern const pb_msgdesc_t meshtastic_AdminMessage_msg;
 extern const pb_msgdesc_t meshtastic_AdminMessage_InputEvent_msg;
 extern const pb_msgdesc_t meshtastic_AdminMessage_OTAEvent_msg;
+extern const pb_msgdesc_t meshtastic_LockdownAuth_msg;
 extern const pb_msgdesc_t meshtastic_HamParameters_msg;
 extern const pb_msgdesc_t meshtastic_NodeRemoteHardwarePinsResponse_msg;
 extern const pb_msgdesc_t meshtastic_SharedContact_msg;
@@ -751,6 +851,7 @@ extern const pb_msgdesc_t meshtastic_SHTXX_config_msg;
 #define meshtastic_AdminMessage_fields &meshtastic_AdminMessage_msg
 #define meshtastic_AdminMessage_InputEvent_fields &meshtastic_AdminMessage_InputEvent_msg
 #define meshtastic_AdminMessage_OTAEvent_fields &meshtastic_AdminMessage_OTAEvent_msg
+#define meshtastic_LockdownAuth_fields &meshtastic_LockdownAuth_msg
 #define meshtastic_HamParameters_fields &meshtastic_HamParameters_msg
 #define meshtastic_NodeRemoteHardwarePinsResponse_fields &meshtastic_NodeRemoteHardwarePinsResponse_msg
 #define meshtastic_SharedContact_fields &meshtastic_SharedContact_msg
@@ -768,6 +869,7 @@ extern const pb_msgdesc_t meshtastic_SHTXX_config_msg;
 #define meshtastic_AdminMessage_size             511
 #define meshtastic_HamParameters_size            31
 #define meshtastic_KeyVerificationAdmin_size     25
+#define meshtastic_LockdownAuth_size             54
 #define meshtastic_NodeRemoteHardwarePinsResponse_size 496
 #define meshtastic_SCD30_config_size             27
 #define meshtastic_SCD4X_config_size             29

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

@@ -33,6 +33,8 @@ typedef struct _meshtastic_PositionLite {
     uint32_t time;
     /* TODO: REPLACE */
     meshtastic_Position_LocSource location_source;
+    /* Indicates the bits of precision set by the sending node */
+    uint32_t precision_bits;
 } meshtastic_PositionLite;
 
 typedef PB_BYTES_ARRAY_T(32) meshtastic_UserLite_public_key_t;
@@ -211,7 +213,7 @@ extern "C" {
 #endif
 
 /* Initializer values for message structs */
-#define meshtastic_PositionLite_init_default     {0, 0, 0, 0, _meshtastic_Position_LocSource_MIN}
+#define meshtastic_PositionLite_init_default     {0, 0, 0, 0, _meshtastic_Position_LocSource_MIN, 0}
 #define meshtastic_UserLite_init_default         {{0}, "", "", _meshtastic_HardwareModel_MIN, 0, _meshtastic_Config_DeviceConfig_Role_MIN, {0, {0}}, false, 0}
 #define meshtastic_NodeInfoLite_init_default     {0, 0, 0, 0, false, 0, 0, 0, "", "", _meshtastic_HardwareModel_MIN, _meshtastic_Config_DeviceConfig_Role_MIN, {0, {0}}}
 #define meshtastic_DeviceState_init_default      {false, meshtastic_MyNodeInfo_init_default, false, meshtastic_User_init_default, 0, {meshtastic_MeshPacket_init_default}, false, meshtastic_MeshPacket_init_default, 0, 0, 0, false, meshtastic_MeshPacket_init_default, 0, {meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default}}
@@ -222,7 +224,7 @@ extern "C" {
 #define meshtastic_NodeDatabase_init_default     {0, {0}, {0}, {0}, {0}, {0}}
 #define meshtastic_ChannelFile_init_default      {0, {meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default, meshtastic_Channel_init_default}, 0}
 #define meshtastic_BackupPreferences_init_default {0, 0, false, meshtastic_LocalConfig_init_default, false, meshtastic_LocalModuleConfig_init_default, false, meshtastic_ChannelFile_init_default, false, meshtastic_User_init_default}
-#define meshtastic_PositionLite_init_zero        {0, 0, 0, 0, _meshtastic_Position_LocSource_MIN}
+#define meshtastic_PositionLite_init_zero        {0, 0, 0, 0, _meshtastic_Position_LocSource_MIN, 0}
 #define meshtastic_UserLite_init_zero            {{0}, "", "", _meshtastic_HardwareModel_MIN, 0, _meshtastic_Config_DeviceConfig_Role_MIN, {0, {0}}, false, 0}
 #define meshtastic_NodeInfoLite_init_zero        {0, 0, 0, 0, false, 0, 0, 0, "", "", _meshtastic_HardwareModel_MIN, _meshtastic_Config_DeviceConfig_Role_MIN, {0, {0}}}
 #define meshtastic_DeviceState_init_zero         {false, meshtastic_MyNodeInfo_init_zero, false, meshtastic_User_init_zero, 0, {meshtastic_MeshPacket_init_zero}, false, meshtastic_MeshPacket_init_zero, 0, 0, 0, false, meshtastic_MeshPacket_init_zero, 0, {meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero}}
@@ -240,6 +242,7 @@ extern "C" {
 #define meshtastic_PositionLite_altitude_tag     3
 #define meshtastic_PositionLite_time_tag         4
 #define meshtastic_PositionLite_location_source_tag 5
+#define meshtastic_PositionLite_precision_bits_tag 6
 #define meshtastic_UserLite_macaddr_tag          1
 #define meshtastic_UserLite_long_name_tag        2
 #define meshtastic_UserLite_short_name_tag       3
@@ -298,7 +301,8 @@ X(a, STATIC,   SINGULAR, SFIXED32, latitude_i,        1) \
 X(a, STATIC,   SINGULAR, SFIXED32, longitude_i,       2) \
 X(a, STATIC,   SINGULAR, INT32,    altitude,          3) \
 X(a, STATIC,   SINGULAR, FIXED32,  time,              4) \
-X(a, STATIC,   SINGULAR, UENUM,    location_source,   5)
+X(a, STATIC,   SINGULAR, UENUM,    location_source,   5) \
+X(a, STATIC,   SINGULAR, UINT32,   precision_bits,    6)
 #define meshtastic_PositionLite_CALLBACK NULL
 #define meshtastic_PositionLite_DEFAULT NULL
 
@@ -444,13 +448,13 @@ extern const pb_msgdesc_t meshtastic_BackupPreferences_msg;
 #define MESHTASTIC_MESHTASTIC_DEVICEONLY_PB_H_MAX_SIZE meshtastic_BackupPreferences_size
 #define meshtastic_BackupPreferences_size        2432
 #define meshtastic_ChannelFile_size              718
-#define meshtastic_DeviceState_size              1737
+#define meshtastic_DeviceState_size              1944
 #define meshtastic_NodeEnvironmentEntry_size     170
 #define meshtastic_NodeInfoLite_size             105
-#define meshtastic_NodePositionEntry_size        36
+#define meshtastic_NodePositionEntry_size        42
 #define meshtastic_NodeStatusEntry_size          89
 #define meshtastic_NodeTelemetryEntry_size       35
-#define meshtastic_PositionLite_size             28
+#define meshtastic_PositionLite_size             34
 #define meshtastic_UserLite_size                 98
 
 #ifdef __cplusplus

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

@@ -115,7 +115,7 @@ extern const pb_msgdesc_t meshtastic_NodeDatabase_Legacy_msg;
 /* Maximum encoded size of messages (where known) */
 /* meshtastic_NodeDatabase_Legacy_size depends on runtime parameters */
 #define MESHTASTIC_MESHTASTIC_DEVICEONLY_LEGACY_PB_H_MAX_SIZE meshtastic_NodeInfoLite_Legacy_size
-#define meshtastic_NodeInfoLite_Legacy_size      196
+#define meshtastic_NodeInfoLite_Legacy_size      202
 
 #ifdef __cplusplus
 } /* extern "C" */

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

@@ -57,6 +57,9 @@ PB_BIND(meshtastic_QueueStatus, meshtastic_QueueStatus, AUTO)
 PB_BIND(meshtastic_FromRadio, meshtastic_FromRadio, 2)
 
 
+PB_BIND(meshtastic_LockdownStatus, meshtastic_LockdownStatus, AUTO)
+
+
 PB_BIND(meshtastic_ClientNotification, meshtastic_ClientNotification, 2)
 
 
@@ -134,6 +137,8 @@ PB_BIND(meshtastic_ChunkedPayloadResponse, meshtastic_ChunkedPayloadResponse, AU
 
 
 
+
+
 
 
 

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

@@ -319,6 +319,8 @@ typedef enum _meshtastic_HardwareModel {
     meshtastic_HardwareModel_HELTEC_V4_R8 = 132,
     /* The HELTEC_MESH_NODE_T1 uses an NRF52840 chip, plus an SX1262. */
     meshtastic_HardwareModel_HELTEC_MESH_NODE_T1 = 133,
+    /* B&Q Consulting Station G3: TBD */
+    meshtastic_HardwareModel_STATION_G3 = 134,
     /* ------------------------------------------------------------------------------------------------------------------------------------------
  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.
  ------------------------------------------------------------------------------------------------------------------------------------------ */
@@ -636,6 +638,25 @@ typedef enum _meshtastic_LogRecord_Level {
     meshtastic_LogRecord_Level_TRACE = 5
 } meshtastic_LogRecord_Level;
 
+typedef enum _meshtastic_LockdownStatus_State {
+    /* Default; should not be sent. */
+    meshtastic_LockdownStatus_State_STATE_UNSPECIFIED = 0,
+    /* No passphrase has ever been provisioned on this device.
+ Client should prompt the operator to set one. */
+    meshtastic_LockdownStatus_State_NEEDS_PROVISION = 1,
+    /* Storage is locked or this client has not authenticated yet.
+ lock_reason carries a machine-readable detail string.
+ Client should present (or auto-replay) a passphrase via
+ AdminMessage.lockdown_auth. */
+    meshtastic_LockdownStatus_State_LOCKED = 2,
+    /* Passphrase accepted; client is now authorized for this connection.
+ boots_remaining and valid_until_epoch describe the active session
+ token's TTL. */
+    meshtastic_LockdownStatus_State_UNLOCKED = 3,
+    /* Passphrase rejected. backoff_seconds is non-zero when rate-limited. */
+    meshtastic_LockdownStatus_State_UNLOCK_FAILED = 4
+} meshtastic_LockdownStatus_State;
+
 /* Struct definitions */
 /* A GPS Position */
 typedef struct _meshtastic_Position {
@@ -799,6 +820,7 @@ typedef struct _meshtastic_Routing {
 } meshtastic_Routing;
 
 typedef PB_BYTES_ARRAY_T(233) meshtastic_Data_payload_t;
+typedef PB_BYTES_ARRAY_T(64) meshtastic_Data_xeddsa_signature_t;
 /* (Formerly called SubPacket)
  The payload portion fo a packet, this is the actual bytes that are sent
  inside a radio packet (because from/to are broken out by the comms library) */
@@ -832,6 +854,8 @@ typedef struct _meshtastic_Data {
     /* Bitfield for extra flags. First use is to indicate that user approves the packet being uploaded to MQTT. */
     bool has_bitfield;
     uint8_t bitfield;
+    /* XEdDSA signature for the payload */
+    meshtastic_Data_xeddsa_signature_t xeddsa_signature;
 } meshtastic_Data;
 
 typedef PB_BYTES_ARRAY_T(32) meshtastic_KeyVerification_hash1_t;
@@ -1036,6 +1060,8 @@ typedef struct _meshtastic_MeshPacket {
     uint32_t tx_after;
     /* Indicates which transport mechanism this packet arrived over */
     meshtastic_MeshPacket_TransportMechanism transport_mechanism;
+    /* Indicates whether the packet has a valid signature */
+    bool xeddsa_signed;
 } meshtastic_MeshPacket;
 
 /* The bluetooth to device link:
@@ -1092,6 +1118,10 @@ typedef struct _meshtastic_NodeInfo {
     /* True if node has been muted
  Persistes between NodeDB internal clean ups */
     bool is_muted;
+    /* True if node is signing its packets via XEdDSA
+ Persists between NodeDB internal clean ups
+ LSB 1 of the bitfield */
+    bool has_xeddsa_signed;
 } meshtastic_NodeInfo;
 
 typedef PB_BYTES_ARRAY_T(16) meshtastic_MyNodeInfo_device_id_t;
@@ -1146,6 +1176,38 @@ typedef struct _meshtastic_QueueStatus {
     uint32_t mesh_packet_id;
 } meshtastic_QueueStatus;
 
+/* Lockdown state report from firmware to client (for hardened builds
+ with MESHTASTIC_LOCKDOWN). Sent immediately after config_complete_id
+ to inform a freshly-connected unauthorized client what it must do,
+ and again in response to each LockdownAuth admin command. */
+typedef struct _meshtastic_LockdownStatus {
+    /* Current lockdown state being reported. */
+    meshtastic_LockdownStatus_State state;
+    /* For LOCKED: machine-readable reason. Known values:
+   "needs_auth"        — storage already unlocked, client must auth
+   "token_missing"     — no boot token on flash
+   "token_expired"     — boot token wall-clock TTL elapsed
+   "token_boots_zero"  — boot token boot-count TTL exhausted
+   "token_hmac_fail"   — token tampered or wrong device
+   "token_dek_fail"    — token DEK decrypt failed
+   "token_wrong_size"  — token file corrupted
+   "token_bad_magic"   — token file corrupted
+   "not_provisioned"   — should generally use NEEDS_PROVISION state instead
+ Other values may be added; clients should treat unknown values as
+ "locked, ask for passphrase". */
+    char lock_reason[32];
+    /* For UNLOCKED: remaining boots on the issued session token.
+ Decrements by 1 on each subsequent boot. */
+    uint32_t boots_remaining;
+    /* For UNLOCKED: wall-clock expiry of the issued session token,
+ absolute Unix-epoch seconds. 0 = no time limit. */
+    uint32_t valid_until_epoch;
+    /* For UNLOCK_FAILED: seconds the client must wait before another
+ passphrase attempt will be accepted. 0 = wrong passphrase, no
+ backoff (immediate retry allowed but advisable to prompt user). */
+    uint32_t backoff_seconds;
+} meshtastic_LockdownStatus;
+
 typedef struct _meshtastic_KeyVerificationNumberInform {
     uint64_t nonce;
     char remote_longname[40];
@@ -1319,6 +1381,12 @@ typedef struct _meshtastic_FromRadio {
         meshtastic_ClientNotification clientNotification;
         /* Persistent data for device-ui */
         meshtastic_DeviceUIConfig deviceuiConfig;
+        /* Lockdown state notification for hardened firmware builds.
+     Sent post-config (so unauthorized clients learn they must
+     provision/unlock) and after each LockdownAuth admin command
+     to report success or failure. Replaces the earlier scheme of
+     encoding state as magic-string prefixes inside ClientNotification. */
+        meshtastic_LockdownStatus lockdown_status;
     };
 } meshtastic_FromRadio;
 
@@ -1460,6 +1528,10 @@ extern "C" {
 #define _meshtastic_LogRecord_Level_MAX meshtastic_LogRecord_Level_CRITICAL
 #define _meshtastic_LogRecord_Level_ARRAYSIZE ((meshtastic_LogRecord_Level)(meshtastic_LogRecord_Level_CRITICAL+1))
 
+#define _meshtastic_LockdownStatus_State_MIN meshtastic_LockdownStatus_State_STATE_UNSPECIFIED
+#define _meshtastic_LockdownStatus_State_MAX meshtastic_LockdownStatus_State_UNLOCK_FAILED
+#define _meshtastic_LockdownStatus_State_ARRAYSIZE ((meshtastic_LockdownStatus_State)(meshtastic_LockdownStatus_State_UNLOCK_FAILED+1))
+
 #define meshtastic_Position_location_source_ENUMTYPE meshtastic_Position_LocSource
 #define meshtastic_Position_altitude_source_ENUMTYPE meshtastic_Position_AltSource
 
@@ -1490,6 +1562,8 @@ extern "C" {
 
 
 
+#define meshtastic_LockdownStatus_state_ENUMTYPE meshtastic_LockdownStatus_State
+
 #define meshtastic_ClientNotification_level_ENUMTYPE meshtastic_LogRecord_Level
 
 
@@ -1517,19 +1591,20 @@ extern "C" {
 #define meshtastic_User_init_default             {"", "", "", {0}, _meshtastic_HardwareModel_MIN, 0, _meshtastic_Config_DeviceConfig_Role_MIN, {0, {0}}, false, 0}
 #define meshtastic_RouteDiscovery_init_default   {0, {0, 0, 0, 0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0, 0, 0, 0}}
 #define meshtastic_Routing_init_default          {0, {meshtastic_RouteDiscovery_init_default}}
-#define meshtastic_Data_init_default             {_meshtastic_PortNum_MIN, {0, {0}}, 0, 0, 0, 0, 0, 0, false, 0}
+#define meshtastic_Data_init_default             {_meshtastic_PortNum_MIN, {0, {0}}, 0, 0, 0, 0, 0, 0, false, 0, {0, {0}}}
 #define meshtastic_KeyVerification_init_default  {0, {0, {0}}, {0, {0}}}
 #define meshtastic_StoreForwardPlusPlus_init_default {_meshtastic_StoreForwardPlusPlus_SFPP_message_type_MIN, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, 0, 0, 0, 0, 0}
 #define meshtastic_RemoteShell_init_default      {_meshtastic_RemoteShell_OpCode_MIN, 0, 0, 0, {0, {0}}, 0, 0, 0, 0, 0}
 #define meshtastic_Waypoint_init_default         {0, false, 0, false, 0, 0, 0, "", "", 0}
 #define meshtastic_StatusMessage_init_default    {""}
 #define meshtastic_MqttClientProxyMessage_init_default {"", 0, {{0, {0}}}, 0}
-#define meshtastic_MeshPacket_init_default       {0, 0, 0, 0, {meshtastic_Data_init_default}, 0, 0, 0, 0, 0, _meshtastic_MeshPacket_Priority_MIN, 0, _meshtastic_MeshPacket_Delayed_MIN, 0, 0, {0, {0}}, 0, 0, 0, 0, _meshtastic_MeshPacket_TransportMechanism_MIN}
-#define meshtastic_NodeInfo_init_default         {0, false, meshtastic_User_init_default, false, meshtastic_Position_init_default, 0, 0, false, meshtastic_DeviceMetrics_init_default, 0, 0, false, 0, 0, 0, 0, 0}
+#define meshtastic_MeshPacket_init_default       {0, 0, 0, 0, {meshtastic_Data_init_default}, 0, 0, 0, 0, 0, _meshtastic_MeshPacket_Priority_MIN, 0, _meshtastic_MeshPacket_Delayed_MIN, 0, 0, {0, {0}}, 0, 0, 0, 0, _meshtastic_MeshPacket_TransportMechanism_MIN, 0}
+#define meshtastic_NodeInfo_init_default         {0, false, meshtastic_User_init_default, false, meshtastic_Position_init_default, 0, 0, false, meshtastic_DeviceMetrics_init_default, 0, 0, false, 0, 0, 0, 0, 0, 0}
 #define meshtastic_MyNodeInfo_init_default       {0, 0, 0, {0, {0}}, "", _meshtastic_FirmwareEdition_MIN, 0}
 #define meshtastic_LogRecord_init_default        {"", 0, "", _meshtastic_LogRecord_Level_MIN}
 #define meshtastic_QueueStatus_init_default      {0, 0, 0, 0}
 #define meshtastic_FromRadio_init_default        {0, 0, {meshtastic_MeshPacket_init_default}}
+#define meshtastic_LockdownStatus_init_default   {_meshtastic_LockdownStatus_State_MIN, "", 0, 0, 0}
 #define meshtastic_ClientNotification_init_default {false, 0, 0, _meshtastic_LogRecord_Level_MIN, "", 0, {meshtastic_KeyVerificationNumberInform_init_default}}
 #define meshtastic_KeyVerificationNumberInform_init_default {0, "", 0}
 #define meshtastic_KeyVerificationNumberRequest_init_default {0, ""}
@@ -1551,19 +1626,20 @@ extern "C" {
 #define meshtastic_User_init_zero                {"", "", "", {0}, _meshtastic_HardwareModel_MIN, 0, _meshtastic_Config_DeviceConfig_Role_MIN, {0, {0}}, false, 0}
 #define meshtastic_RouteDiscovery_init_zero      {0, {0, 0, 0, 0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0, 0, 0, 0}}
 #define meshtastic_Routing_init_zero             {0, {meshtastic_RouteDiscovery_init_zero}}
-#define meshtastic_Data_init_zero                {_meshtastic_PortNum_MIN, {0, {0}}, 0, 0, 0, 0, 0, 0, false, 0}
+#define meshtastic_Data_init_zero                {_meshtastic_PortNum_MIN, {0, {0}}, 0, 0, 0, 0, 0, 0, false, 0, {0, {0}}}
 #define meshtastic_KeyVerification_init_zero     {0, {0, {0}}, {0, {0}}}
 #define meshtastic_StoreForwardPlusPlus_init_zero {_meshtastic_StoreForwardPlusPlus_SFPP_message_type_MIN, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, 0, 0, 0, 0, 0}
 #define meshtastic_RemoteShell_init_zero         {_meshtastic_RemoteShell_OpCode_MIN, 0, 0, 0, {0, {0}}, 0, 0, 0, 0, 0}
 #define meshtastic_Waypoint_init_zero            {0, false, 0, false, 0, 0, 0, "", "", 0}
 #define meshtastic_StatusMessage_init_zero       {""}
 #define meshtastic_MqttClientProxyMessage_init_zero {"", 0, {{0, {0}}}, 0}
-#define meshtastic_MeshPacket_init_zero          {0, 0, 0, 0, {meshtastic_Data_init_zero}, 0, 0, 0, 0, 0, _meshtastic_MeshPacket_Priority_MIN, 0, _meshtastic_MeshPacket_Delayed_MIN, 0, 0, {0, {0}}, 0, 0, 0, 0, _meshtastic_MeshPacket_TransportMechanism_MIN}
-#define meshtastic_NodeInfo_init_zero            {0, false, meshtastic_User_init_zero, false, meshtastic_Position_init_zero, 0, 0, false, meshtastic_DeviceMetrics_init_zero, 0, 0, false, 0, 0, 0, 0, 0}
+#define meshtastic_MeshPacket_init_zero          {0, 0, 0, 0, {meshtastic_Data_init_zero}, 0, 0, 0, 0, 0, _meshtastic_MeshPacket_Priority_MIN, 0, _meshtastic_MeshPacket_Delayed_MIN, 0, 0, {0, {0}}, 0, 0, 0, 0, _meshtastic_MeshPacket_TransportMechanism_MIN, 0}
+#define meshtastic_NodeInfo_init_zero            {0, false, meshtastic_User_init_zero, false, meshtastic_Position_init_zero, 0, 0, false, meshtastic_DeviceMetrics_init_zero, 0, 0, false, 0, 0, 0, 0, 0, 0}
 #define meshtastic_MyNodeInfo_init_zero          {0, 0, 0, {0, {0}}, "", _meshtastic_FirmwareEdition_MIN, 0}
 #define meshtastic_LogRecord_init_zero           {"", 0, "", _meshtastic_LogRecord_Level_MIN}
 #define meshtastic_QueueStatus_init_zero         {0, 0, 0, 0}
 #define meshtastic_FromRadio_init_zero           {0, 0, {meshtastic_MeshPacket_init_zero}}
+#define meshtastic_LockdownStatus_init_zero      {_meshtastic_LockdownStatus_State_MIN, "", 0, 0, 0}
 #define meshtastic_ClientNotification_init_zero  {false, 0, 0, _meshtastic_LogRecord_Level_MIN, "", 0, {meshtastic_KeyVerificationNumberInform_init_zero}}
 #define meshtastic_KeyVerificationNumberInform_init_zero {0, "", 0}
 #define meshtastic_KeyVerificationNumberRequest_init_zero {0, ""}
@@ -1631,6 +1707,7 @@ extern "C" {
 #define meshtastic_Data_reply_id_tag             7
 #define meshtastic_Data_emoji_tag                8
 #define meshtastic_Data_bitfield_tag             9
+#define meshtastic_Data_xeddsa_signature_tag     10
 #define meshtastic_KeyVerification_nonce_tag     1
 #define meshtastic_KeyVerification_hash1_tag     2
 #define meshtastic_KeyVerification_hash2_tag     3
@@ -1688,6 +1765,7 @@ extern "C" {
 #define meshtastic_MeshPacket_relay_node_tag     19
 #define meshtastic_MeshPacket_tx_after_tag       20
 #define meshtastic_MeshPacket_transport_mechanism_tag 21
+#define meshtastic_MeshPacket_xeddsa_signed_tag  22
 #define meshtastic_NodeInfo_num_tag              1
 #define meshtastic_NodeInfo_user_tag             2
 #define meshtastic_NodeInfo_position_tag         3
@@ -1701,6 +1779,7 @@ extern "C" {
 #define meshtastic_NodeInfo_is_ignored_tag       11
 #define meshtastic_NodeInfo_is_key_manually_verified_tag 12
 #define meshtastic_NodeInfo_is_muted_tag         13
+#define meshtastic_NodeInfo_has_xeddsa_signed_tag 14
 #define meshtastic_MyNodeInfo_my_node_num_tag    1
 #define meshtastic_MyNodeInfo_reboot_count_tag   8
 #define meshtastic_MyNodeInfo_min_app_version_tag 11
@@ -1716,6 +1795,11 @@ extern "C" {
 #define meshtastic_QueueStatus_free_tag          2
 #define meshtastic_QueueStatus_maxlen_tag        3
 #define meshtastic_QueueStatus_mesh_packet_id_tag 4
+#define meshtastic_LockdownStatus_state_tag      1
+#define meshtastic_LockdownStatus_lock_reason_tag 2
+#define meshtastic_LockdownStatus_boots_remaining_tag 3
+#define meshtastic_LockdownStatus_valid_until_epoch_tag 4
+#define meshtastic_LockdownStatus_backoff_seconds_tag 5
 #define meshtastic_KeyVerificationNumberInform_nonce_tag 1
 #define meshtastic_KeyVerificationNumberInform_remote_longname_tag 2
 #define meshtastic_KeyVerificationNumberInform_security_number_tag 3
@@ -1775,6 +1859,7 @@ extern "C" {
 #define meshtastic_FromRadio_fileInfo_tag        15
 #define meshtastic_FromRadio_clientNotification_tag 16
 #define meshtastic_FromRadio_deviceuiConfig_tag  17
+#define meshtastic_FromRadio_lockdown_status_tag 18
 #define meshtastic_Heartbeat_nonce_tag           1
 #define meshtastic_ToRadio_packet_tag            1
 #define meshtastic_ToRadio_want_config_id_tag    3
@@ -1861,7 +1946,8 @@ X(a, STATIC,   SINGULAR, FIXED32,  source,            5) \
 X(a, STATIC,   SINGULAR, FIXED32,  request_id,        6) \
 X(a, STATIC,   SINGULAR, FIXED32,  reply_id,          7) \
 X(a, STATIC,   SINGULAR, FIXED32,  emoji,             8) \
-X(a, STATIC,   OPTIONAL, UINT32,   bitfield,          9)
+X(a, STATIC,   OPTIONAL, UINT32,   bitfield,          9) \
+X(a, STATIC,   SINGULAR, BYTES,    xeddsa_signature,  10)
 #define meshtastic_Data_CALLBACK NULL
 #define meshtastic_Data_DEFAULT NULL
 
@@ -1946,7 +2032,8 @@ X(a, STATIC,   SINGULAR, BOOL,     pki_encrypted,    17) \
 X(a, STATIC,   SINGULAR, UINT32,   next_hop,         18) \
 X(a, STATIC,   SINGULAR, UINT32,   relay_node,       19) \
 X(a, STATIC,   SINGULAR, UINT32,   tx_after,         20) \
-X(a, STATIC,   SINGULAR, UENUM,    transport_mechanism,  21)
+X(a, STATIC,   SINGULAR, UENUM,    transport_mechanism,  21) \
+X(a, STATIC,   SINGULAR, BOOL,     xeddsa_signed,    22)
 #define meshtastic_MeshPacket_CALLBACK NULL
 #define meshtastic_MeshPacket_DEFAULT NULL
 #define meshtastic_MeshPacket_payload_variant_decoded_MSGTYPE meshtastic_Data
@@ -1964,7 +2051,8 @@ X(a, STATIC,   OPTIONAL, UINT32,   hops_away,         9) \
 X(a, STATIC,   SINGULAR, BOOL,     is_favorite,      10) \
 X(a, STATIC,   SINGULAR, BOOL,     is_ignored,       11) \
 X(a, STATIC,   SINGULAR, BOOL,     is_key_manually_verified,  12) \
-X(a, STATIC,   SINGULAR, BOOL,     is_muted,         13)
+X(a, STATIC,   SINGULAR, BOOL,     is_muted,         13) \
+X(a, STATIC,   SINGULAR, BOOL,     has_xeddsa_signed,  14)
 #define meshtastic_NodeInfo_CALLBACK NULL
 #define meshtastic_NodeInfo_DEFAULT NULL
 #define meshtastic_NodeInfo_user_MSGTYPE meshtastic_User
@@ -2015,7 +2103,8 @@ X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,metadata,metadata),  13) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,mqttClientProxyMessage,mqttClientProxyMessage),  14) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,fileInfo,fileInfo),  15) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,clientNotification,clientNotification),  16) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,deviceuiConfig,deviceuiConfig),  17)
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,deviceuiConfig,deviceuiConfig),  17) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,lockdown_status,lockdown_status),  18)
 #define meshtastic_FromRadio_CALLBACK NULL
 #define meshtastic_FromRadio_DEFAULT NULL
 #define meshtastic_FromRadio_payload_variant_packet_MSGTYPE meshtastic_MeshPacket
@@ -2032,6 +2121,16 @@ X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,deviceuiConfig,deviceuiConfi
 #define meshtastic_FromRadio_payload_variant_fileInfo_MSGTYPE meshtastic_FileInfo
 #define meshtastic_FromRadio_payload_variant_clientNotification_MSGTYPE meshtastic_ClientNotification
 #define meshtastic_FromRadio_payload_variant_deviceuiConfig_MSGTYPE meshtastic_DeviceUIConfig
+#define meshtastic_FromRadio_payload_variant_lockdown_status_MSGTYPE meshtastic_LockdownStatus
+
+#define meshtastic_LockdownStatus_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UENUM,    state,             1) \
+X(a, STATIC,   SINGULAR, STRING,   lock_reason,       2) \
+X(a, STATIC,   SINGULAR, UINT32,   boots_remaining,   3) \
+X(a, STATIC,   SINGULAR, UINT32,   valid_until_epoch,   4) \
+X(a, STATIC,   SINGULAR, UINT32,   backoff_seconds,   5)
+#define meshtastic_LockdownStatus_CALLBACK NULL
+#define meshtastic_LockdownStatus_DEFAULT NULL
 
 #define meshtastic_ClientNotification_FIELDLIST(X, a) \
 X(a, STATIC,   OPTIONAL, UINT32,   reply_id,          1) \
@@ -2192,6 +2291,7 @@ extern const pb_msgdesc_t meshtastic_MyNodeInfo_msg;
 extern const pb_msgdesc_t meshtastic_LogRecord_msg;
 extern const pb_msgdesc_t meshtastic_QueueStatus_msg;
 extern const pb_msgdesc_t meshtastic_FromRadio_msg;
+extern const pb_msgdesc_t meshtastic_LockdownStatus_msg;
 extern const pb_msgdesc_t meshtastic_ClientNotification_msg;
 extern const pb_msgdesc_t meshtastic_KeyVerificationNumberInform_msg;
 extern const pb_msgdesc_t meshtastic_KeyVerificationNumberRequest_msg;
@@ -2228,6 +2328,7 @@ extern const pb_msgdesc_t meshtastic_ChunkedPayloadResponse_msg;
 #define meshtastic_LogRecord_fields &meshtastic_LogRecord_msg
 #define meshtastic_QueueStatus_fields &meshtastic_QueueStatus_msg
 #define meshtastic_FromRadio_fields &meshtastic_FromRadio_msg
+#define meshtastic_LockdownStatus_fields &meshtastic_LockdownStatus_msg
 #define meshtastic_ClientNotification_fields &meshtastic_ClientNotification_msg
 #define meshtastic_KeyVerificationNumberInform_fields &meshtastic_KeyVerificationNumberInform_msg
 #define meshtastic_KeyVerificationNumberRequest_fields &meshtastic_KeyVerificationNumberRequest_msg
@@ -2253,7 +2354,7 @@ extern const pb_msgdesc_t meshtastic_ChunkedPayloadResponse_msg;
 #define meshtastic_ChunkedPayload_size           245
 #define meshtastic_ClientNotification_size       482
 #define meshtastic_Compressed_size               239
-#define meshtastic_Data_size                     269
+#define meshtastic_Data_size                     335
 #define meshtastic_DeviceMetadata_size           54
 #define meshtastic_DuplicatedPublicKey_size      0
 #define meshtastic_FileInfo_size                 236
@@ -2263,14 +2364,15 @@ extern const pb_msgdesc_t meshtastic_ChunkedPayloadResponse_msg;
 #define meshtastic_KeyVerificationNumberInform_size 58
 #define meshtastic_KeyVerificationNumberRequest_size 52
 #define meshtastic_KeyVerification_size          79
+#define meshtastic_LockdownStatus_size           53
 #define meshtastic_LogRecord_size                426
 #define meshtastic_LowEntropyKey_size            0
-#define meshtastic_MeshPacket_size               381
+#define meshtastic_MeshPacket_size               450
 #define meshtastic_MqttClientProxyMessage_size   501
 #define meshtastic_MyNodeInfo_size               83
 #define meshtastic_NeighborInfo_size             258
 #define meshtastic_Neighbor_size                 22
-#define meshtastic_NodeInfo_size                 325
+#define meshtastic_NodeInfo_size                 327
 #define meshtastic_NodeRemoteHardwarePin_size    29
 #define meshtastic_Position_size                 144
 #define meshtastic_QueueStatus_size              23

src/mesh/mesh-pb-constants.h

@@ -80,7 +80,7 @@ static_assert(sizeof(meshtastic_NodeInfoLite) <= 130, "NodeInfoLite size increas
 #if defined(ARCH_STM32WL)
 #define MAX_NUM_NODES 10
 #elif defined(ARCH_NRF52)
-#define MAX_NUM_NODES 80
+#define MAX_NUM_NODES 150
 #elif defined(CONFIG_IDF_TARGET_ESP32S3)
 #include "Esp.h"
 static inline int get_max_num_nodes()

src/mesh/wifi/WiFiAPClient.cpp

@@ -15,6 +15,12 @@
 #define ETH ETH2
 #endif // HAS_ETHERNET
 
+#if HAS_ETHERNET && defined(USE_CH390D)
+#include "ESP32_CH390.h"
+#include "hal/spi_types.h"
+#define ETH CH390
+#endif // HAS_ETHERNET
+
 #include <WiFiUdp.h>
 #ifdef ARCH_ESP32
 #if !MESHTASTIC_EXCLUDE_WEBSERVER
@@ -56,12 +62,43 @@ unsigned long lastrun_ntp = 0;
 
 bool needReconnect = true;   // If we create our reconnector, run it once at the beginning
 bool isReconnecting = false; // If we are currently reconnecting
+#if defined(USE_WS5500) || defined(USE_CH390D)
+static volatile bool ethNetworkConnectedPending = false;
+#endif
 
 WiFiUDP syslogClient;
 meshtastic::Syslog syslog(syslogClient);
 
 Periodic *wifiReconnect;
 
+#if defined(USE_WS5500) || defined(USE_CH390D)
+static void onNetworkConnected();
+static uint32_t lastEthIP = 0;
+static int32_t ethNetworkConnectedPoll()
+{
+    if (ethNetworkConnectedPending) {
+        ethNetworkConnectedPending = false;
+        uint32_t ip = (uint32_t)ETH.localIP();
+        bool ipChanged = APStartupComplete && ip != 0 && ip != lastEthIP;
+        onNetworkConnected();
+        if (ipChanged) {
+            LOG_INFO("Ethernet IP changed (%u.%u.%u.%u), restarting mDNS", ip & 0xff, (ip >> 8) & 0xff, (ip >> 16) & 0xff,
+                     (ip >> 24) & 0xff);
+            MDNS.end();
+            if (MDNS.begin("Meshtastic")) {
+                MDNS.addService("meshtastic", "tcp", SERVER_API_DEFAULT_PORT);
+                MDNS.addServiceTxt("meshtastic", "tcp", "shortname", String(owner.short_name));
+                MDNS.addServiceTxt("meshtastic", "tcp", "id", String(nodeDB->getNodeId().c_str()));
+                MDNS.addServiceTxt("meshtastic", "tcp", "pio_env", optstr(APP_ENV));
+            }
+        }
+        if (ip != 0)
+            lastEthIP = ip;
+    }
+    return 500;
+}
+#endif
+
 #ifdef USE_WS5500
 // Startup Ethernet
 bool initEthernet()
@@ -72,6 +109,38 @@ bool initEthernet()
 #if !MESHTASTIC_EXCLUDE_WEBSERVER
         createSSLCert(); // For WebServer
 #endif
+        new concurrency::Periodic("EthConnect", ethNetworkConnectedPoll);
+        return true;
+    }
+
+    return false;
+}
+#endif
+
+#ifdef USE_CH390D
+// Startup Ethernet
+bool initEthernet()
+{
+    // Configure CH390
+    ch390_config_t ch390_conf = CH390_DEFAULT_CONFIG();
+    ch390_conf.spi_host = SPI3_HOST;
+    ch390_conf.spi_cs_gpio = ETH_CS_PIN;
+    ch390_conf.spi_sck_gpio = ETH_SCLK_PIN;
+    ch390_conf.spi_mosi_gpio = ETH_MOSI_PIN;
+    ch390_conf.spi_miso_gpio = ETH_MISO_PIN;
+    ch390_conf.int_gpio = ETH_INT_PIN;
+#ifdef ETH_RST_PIN
+    ch390_conf.reset_gpio = ETH_RST_PIN;
+#else
+    ch390_conf.reset_gpio = -1;
+#endif
+    ch390_conf.spi_clock_mhz = 20;
+    if ((config.network.eth_enabled) && (ETH.begin(ch390_conf))) {
+        WiFi.onEvent(WiFiEvent);
+#if !MESHTASTIC_EXCLUDE_WEBSERVER
+        createSSLCert(); // For WebServer
+#endif
+        new concurrency::Periodic("EthConnect", ethNetworkConnectedPoll);
         return true;
     }
 
@@ -222,10 +291,8 @@ static int32_t reconnectWiFi()
 #endif
         return 1000; // check once per second
     } else {
-#ifdef ARCH_RP2040
-        onNetworkConnected(); // will only do anything once
-#endif
-        return 300000; // every 5 minutes
+        onNetworkConnected(); // will only do anything once (guarded by APStartupComplete)
+        return 300000;        // every 5 minutes
     }
 }
 
@@ -234,7 +301,7 @@ bool isWifiAvailable()
 
     if (config.network.wifi_enabled && (config.network.wifi_ssid[0])) {
         return true;
-#ifdef USE_WS5500
+#if defined(USE_WS5500) || defined(USE_CH390D)
     } else if (config.network.eth_enabled) {
         return true;
 #endif
@@ -274,9 +341,6 @@ bool initWifi()
         const char *wifiPsw = config.network.wifi_psk;
 
 #ifndef ARCH_RP2040
-#if !MESHTASTIC_EXCLUDE_WEBSERVER
-        createSSLCert(); // For WebServer
-#endif
         WiFi.persistent(false); // Disable flash storage for WiFi credentials
 #endif
         if (!*wifiPsw) // Treat empty password as no password
@@ -301,6 +365,9 @@ bool initWifi()
 #endif
             }
 #ifdef ARCH_ESP32
+            // Register WiFi event handler BEFORE createSSLCert() to prevent race condition:
+            // Without this, WiFi can auto-reconnect during cert generation and fire GOT_IP
+            // before the handler is registered, causing onNetworkConnected() to never run.
             WiFi.onEvent(WiFiEvent);
             WiFi.setAutoReconnect(true);
             WiFi.setSleep(false);
@@ -322,6 +389,12 @@ bool initWifi()
                     wifiDisconnectReason = info.wifi_sta_disconnected.reason;
                 },
                 WiFiEvent_t::ARDUINO_EVENT_WIFI_STA_DISCONNECTED);
+#endif
+
+#ifndef ARCH_RP2040
+#if !MESHTASTIC_EXCLUDE_WEBSERVER
+            createSSLCert(); // For WebServer - called after WiFi.onEvent() to avoid race condition
+#endif
 #endif
             LOG_DEBUG("JOINING WIFI soon: ssid=%s", wifiName);
             wifiReconnect = new Periodic("WifiConnect", reconnectWiFi);
@@ -384,13 +457,13 @@ static void WiFiEvent(WiFiEvent_t event)
 #endif
         }
 #ifdef WIFI_LED
-        digitalWrite(WIFI_LED, HIGH);
+        digitalWrite(WIFI_LED, LOW ^ WIFI_STATE_ON);
 #endif
         break;
     case ARDUINO_EVENT_WIFI_STA_DISCONNECTED:
         LOG_INFO("Disconnected from WiFi access point");
 #ifdef WIFI_LED
-        digitalWrite(WIFI_LED, LOW);
+        digitalWrite(WIFI_LED, HIGH ^ WIFI_STATE_ON);
 #endif
 #if HAS_UDP_MULTICAST
         if (udpHandler) {
@@ -452,13 +525,13 @@ static void WiFiEvent(WiFiEvent_t event)
     case ARDUINO_EVENT_WIFI_AP_START:
         LOG_INFO("WiFi access point started");
 #ifdef WIFI_LED
-        digitalWrite(WIFI_LED, HIGH);
+        digitalWrite(WIFI_LED, LOW ^ WIFI_STATE_ON);
 #endif
         break;
     case ARDUINO_EVENT_WIFI_AP_STOP:
         LOG_INFO("WiFi access point stopped");
 #ifdef WIFI_LED
-        digitalWrite(WIFI_LED, LOW);
+        digitalWrite(WIFI_LED, HIGH ^ WIFI_STATE_ON);
 #endif
         break;
     case ARDUINO_EVENT_WIFI_AP_STACONNECTED:
@@ -494,18 +567,18 @@ static void WiFiEvent(WiFiEvent_t event)
         LOG_INFO("Ethernet disconnected");
         break;
     case ARDUINO_EVENT_ETH_GOT_IP:
-#ifdef USE_WS5500
+#if defined(USE_WS5500) || defined(USE_CH390D)
         LOG_INFO("Obtained IP address: %s, %u Mbps, %s", ETH.localIP().toString().c_str(), ETH.linkSpeed(),
                  ETH.fullDuplex() ? "FULL_DUPLEX" : "HALF_DUPLEX");
-        onNetworkConnected();
+        ethNetworkConnectedPending = true;
 #endif
         break;
     case ARDUINO_EVENT_ETH_GOT_IP6:
-#ifdef USE_WS5500
+#if defined(USE_WS5500) || defined(USE_CH390D)
 #if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3, 0, 0)
         LOG_INFO("Obtained Local IP6 address: %s", ETH.linkLocalIPv6().toString().c_str());
         LOG_INFO("Obtained GlobalIP6 address: %s", ETH.globalIPv6().toString().c_str());
-#else
+#elif defined(USE_WS5500)
         LOG_INFO("Obtained IP6 address: %s", ETH.localIPv6().toString().c_str());
 #endif
 #endif

src/mesh/wifi/WiFiAPClient.h

@@ -26,7 +26,7 @@ bool isWifiAvailable();
 
 uint8_t getWifiDisconnectReason();
 
-#ifdef USE_WS5500
+#if defined(USE_WS5500) || defined(USE_CH390D)
 // Startup Ethernet
 bool initEthernet();
 #endif

src/modules/AdminModule.cpp

@@ -666,7 +666,7 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c, bool fromOthers)
     bool requiresReboot = true;
 
     switch (c.which_payload_variant) {
-    case meshtastic_Config_device_tag:
+    case meshtastic_Config_device_tag: {
         LOG_INFO("Set config: Device");
         config.has_device = true;
 #if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL) && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR &&                            \
@@ -720,6 +720,7 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c, bool fromOthers)
         }
 #endif
         break;
+    } // case meshtastic_Config_device_tag
     case meshtastic_Config_position_tag:
         LOG_INFO("Set config: Position");
         config.has_position = true;
@@ -1318,7 +1319,7 @@ void AdminModule::handleGetDeviceConnectionStatus(const meshtastic_MeshPacket &r
     }
 #endif
 
-#if HAS_ETHERNET && !defined(USE_WS5500)
+#if HAS_ETHERNET && !defined(USE_WS5500) && !defined(USE_CH390D)
     conn.has_ethernet = true;
     conn.ethernet.has_status = true;
     if (Ethernet.linkStatus() == LinkON) {
@@ -1345,6 +1346,10 @@ void AdminModule::handleGetDeviceConnectionStatus(const meshtastic_MeshPacket &r
     if (config.bluetooth.enabled && nrf52Bluetooth) {
         conn.bluetooth.is_connected = nrf52Bluetooth->isConnected();
     }
+#elif defined(ARCH_NRF54L15)
+    if (config.bluetooth.enabled && nrf54l15Bluetooth) {
+        conn.bluetooth.is_connected = nrf54l15Bluetooth->isConnected();
+    }
 #endif
 #endif
     conn.has_serial = true; // No serial-less devices
@@ -1605,6 +1610,9 @@ void disableBluetooth()
 #elif defined(ARCH_NRF52)
     if (nrf52Bluetooth)
         nrf52Bluetooth->shutdown();
+#elif defined(ARCH_NRF54L15)
+    if (nrf54l15Bluetooth)
+        nrf54l15Bluetooth->shutdown();
 #endif
 #endif
 }

src/modules/PositionModule.cpp

@@ -4,6 +4,7 @@
 #include "GPS.h"
 #include "MeshService.h"
 #include "NodeDB.h"
+#include "PositionPrecision.h"
 #include "RTC.h"
 #include "Router.h"
 #include "TransmitHistory.h"
@@ -107,13 +108,7 @@ bool PositionModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, mes
     }
 
     nodeDB->updatePosition(getFrom(&mp), p);
-    if (channels.getByIndex(mp.channel).settings.has_module_settings) {
-        precision = channels.getByIndex(mp.channel).settings.module_settings.position_precision;
-    } else if (channels.getByIndex(mp.channel).role == meshtastic_Channel_Role_PRIMARY) {
-        precision = 32;
-    } else {
-        precision = 0;
-    }
+    precision = getPositionPrecisionForChannel(mp.channel);
 
     return false; // Let others look at this message also if they want
 }
@@ -121,15 +116,12 @@ bool PositionModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, mes
 void PositionModule::alterReceivedProtobuf(meshtastic_MeshPacket &mp, meshtastic_Position *p)
 {
     // Phone position packets need to be truncated to the channel precision
-    if (isFromUs(&mp) && (precision < 32 && precision > 0)) {
-        LOG_DEBUG("Truncate phone position to channel precision %i", precision);
-        p->latitude_i = p->latitude_i & (UINT32_MAX << (32 - precision));
-        p->longitude_i = p->longitude_i & (UINT32_MAX << (32 - precision));
-
-        // We want the imprecise position to be the middle of the possible location, not
-        p->latitude_i += (1 << (31 - precision));
-        p->longitude_i += (1 << (31 - precision));
-
+    if (isFromUs(&mp)) {
+        if (precision == 0)
+            LOG_DEBUG("Strip phone position due to channel precision 0");
+        else if (precision < 32)
+            LOG_DEBUG("Truncate phone position to channel precision %i", precision);
+        applyPositionPrecision(*p, precision);
         mp.decoded.payload.size =
             pb_encode_to_bytes(mp.decoded.payload.bytes, sizeof(mp.decoded.payload.bytes), &meshtastic_Position_msg, p);
     }
@@ -206,20 +198,11 @@ meshtastic_MeshPacket *PositionModule::allocPositionPacket()
 
     // lat/lon are unconditionally included - IF AVAILABLE!
     LOG_DEBUG("Send location with precision %i", precision);
-    if (precision < 32 && precision > 0) {
-        p.latitude_i = localPosition.latitude_i & (UINT32_MAX << (32 - precision));
-        p.longitude_i = localPosition.longitude_i & (UINT32_MAX << (32 - precision));
-
-        // We want the imprecise position to be the middle of the possible location, not
-        p.latitude_i += (1 << (31 - precision));
-        p.longitude_i += (1 << (31 - precision));
-    } else {
-        p.latitude_i = localPosition.latitude_i;
-        p.longitude_i = localPosition.longitude_i;
-    }
-    p.precision_bits = precision;
+    p.latitude_i = localPosition.latitude_i;
+    p.longitude_i = localPosition.longitude_i;
     p.has_latitude_i = true;
     p.has_longitude_i = true;
+    applyPositionPrecision(p, precision);
     // Always use NTP / GPS time if available
     if (getValidTime(RTCQualityNTP) > 0) {
         p.time = getValidTime(RTCQualityNTP);
@@ -350,8 +333,7 @@ void PositionModule::sendOurPosition()
     // If we changed channels, ask everyone else for their latest info
     LOG_INFO("Send pos@%x:6 to mesh (wantReplies=%d)", localPosition.timestamp, requestReplies);
     for (uint8_t channelNum = 0; channelNum < 8; channelNum++) {
-        if (channels.getByIndex(channelNum).settings.has_module_settings &&
-            channels.getByIndex(channelNum).settings.module_settings.position_precision != 0) {
+        if (getPositionPrecisionForChannel(channelNum) != 0) {
             sendOurPosition(NODENUM_BROADCAST, requestReplies, channelNum);
             return;
         }
@@ -369,10 +351,8 @@ void PositionModule::sendOurPosition(NodeNum dest, bool wantReplies, uint8_t cha
     if (prevPacketId) // if we wrap around to zero, we'll simply fail to cancel in that rare case (no big deal)
         service->cancelSending(prevPacketId);
 
-    // Set's the class precision value for this particular packet
-    if (channels.getByIndex(channel).settings.has_module_settings) {
-        precision = channels.getByIndex(channel).settings.module_settings.position_precision;
-    }
+    // Set the class precision value for this particular packet.
+    precision = getPositionPrecisionForChannel(channel);
 
     meshtastic_MeshPacket *p = allocPositionPacket();
     if (p == nullptr) {

src/modules/SystemCommandsModule.cpp

@@ -115,6 +115,17 @@ int SystemCommandsModule::handleInputEvent(const InputEvent *event)
     case INPUT_BROKER_SHUTDOWN:
         shutdownAtMsec = millis();
         return true;
+    // factory reset
+    case INPUT_BROKER_FACTORY_RST:
+        disableBluetooth();
+        LOG_INFO("Initiate full factory reset");
+        nodeDB->factoryReset(true);
+        // reboot(DEFAULT_REBOOT_SECONDS);
+        LOG_INFO("Reboot in %d seconds", DEFAULT_REBOOT_SECONDS);
+        if (screen)
+            screen->showSimpleBanner("Rebooting...", 0); // stays on screen
+        rebootAtMsec = (DEFAULT_REBOOT_SECONDS < 0) ? 0 : (millis() + DEFAULT_REBOOT_SECONDS * 1000);
+        return true;
 
     default:
         // No other input events handled here

src/modules/TextMessageModule.cpp

@@ -21,9 +21,6 @@ ProcessMessage TextMessageModule::handleReceived(const meshtastic_MeshPacket &mp
     textPacketList[textPacketListIndex] = mp.id;
     textPacketListIndex = (textPacketListIndex + 1) % TEXT_PACKET_LIST_SIZE;
 
-    // We only store/display messages destined for us.
-    devicestate.rx_text_message = mp;
-    devicestate.has_rx_text_message = true;
     IF_SCREEN(
         // Guard against running in MeshtasticUI or with no screen
         if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
@@ -59,4 +56,4 @@ bool TextMessageModule::recentlySeen(uint32_t id)
         }
     }
     return false;
-}
+}

src/modules/TextMessageModule.h

@@ -7,8 +7,8 @@
  * Text message handling for Meshtastic.
  *
  * This module is responsible for receiving and storing incoming text messages
- * from the mesh. It updates device state and notifies observers so that other
- * components (such as the MessageRenderer) can later display or process them.
+ * from the mesh. It notifies observers so that other components (such as the
+ * MessageRenderer) can later display or process them.
  *
  * Rendering of messages on screen is no longer done here.
  */
@@ -36,4 +36,4 @@ class TextMessageModule : public SinglePortModule, public Observable<const mesht
     size_t textPacketListIndex = 0;
 };
 
-extern TextMessageModule *textMessageModule;
+extern TextMessageModule *textMessageModule;

src/mqtt/MQTT.cpp

@@ -22,6 +22,9 @@
 #if HAS_ETHERNET && defined(USE_WS5500)
 #include <ETHClass2.h>
 #define ETH ETH2
+#elif HAS_ETHERNET && defined(USE_CH390D)
+#include "ESP32_CH390.h"
+#define ETH CH390
 #endif // HAS_ETHERNET
 #include "Default.h"
 #if !defined(ARCH_NRF52) || NRF52_USE_JSON
@@ -344,6 +347,9 @@ inline bool isConnectedToNetwork()
 #ifdef USE_WS5500
     if (ETH.connected())
         return true;
+#elif defined(USE_CH390D)
+    if (ETH.isConnected())
+        return true;
 #endif
 
 #if HAS_WIFI

src/mqtt/MQTT.h

@@ -15,7 +15,7 @@
 #include <WiFiClientSecure.h>
 #endif
 #endif
-#if HAS_ETHERNET && !defined(USE_WS5500)
+#if HAS_ETHERNET && !defined(USE_WS5500) && !defined(USE_CH390D)
 #include <EthernetClient.h>
 #endif
 

src/nimble/NimbleBluetooth.cpp

@@ -587,51 +587,30 @@ class NimbleBluetoothServerCallback : public NimBLEServerCallbacks
     virtual uint32_t onPassKeyRequest() override
 #endif
     {
-        uint32_t passkey = config.bluetooth.fixed_pin;
+        uint32_t configuredPasskey = config.bluetooth.fixed_pin;
 
         if (config.bluetooth.mode == meshtastic_Config_BluetoothConfig_PairingMode_RANDOM_PIN) {
             LOG_INFO("Use random passkey");
             // This is the passkey to be entered on peer - we pick a number >100,000 to ensure 6 digits
-            passkey = random(100000, 999999);
+            configuredPasskey = random(100000, 999999);
         }
-        LOG_INFO("*** Enter passkey %d on the peer side ***", passkey);
+        LOG_INFO("*** Enter passkey %d on the peer side ***", configuredPasskey);
 
         powerFSM.trigger(EVENT_BLUETOOTH_PAIR);
-        meshtastic::BluetoothStatus newStatus(std::to_string(passkey));
+        std::string passkey = std::to_string(configuredPasskey);
+        meshtastic::BluetoothStatus newStatus(passkey);
         bluetoothStatus->updateStatus(&newStatus);
 
 #if HAS_SCREEN // Todo: migrate this display code back into Screen class, and observe bluetoothStatus
         if (screen) {
-            screen->startAlert([passkey](OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) -> void {
-                char btPIN[16] = "888888";
-                snprintf(btPIN, sizeof(btPIN), "%06u", passkey);
-                int x_offset = display->width() / 2;
-                int y_offset = display->height() <= 80 ? 0 : 12;
-                display->setTextAlignment(TEXT_ALIGN_CENTER);
-                display->setFont(FONT_MEDIUM);
-                display->drawString(x_offset + x, y_offset + y, "Bluetooth");
-#if !defined(M5STACK_UNITC6L)
-                display->setFont(FONT_SMALL);
-                y_offset = display->height() == 64 ? y_offset + FONT_HEIGHT_MEDIUM - 4 : y_offset + FONT_HEIGHT_MEDIUM + 5;
-                display->drawString(x_offset + x, y_offset + y, "Enter this code");
-#endif
-                display->setFont(FONT_LARGE);
-                char pin[8];
-                snprintf(pin, sizeof(pin), "%.3s %.3s", btPIN, btPIN + 3);
-                y_offset = display->height() == 64 ? y_offset + FONT_HEIGHT_SMALL - 5 : y_offset + FONT_HEIGHT_SMALL + 5;
-                display->drawString(x_offset + x, y_offset + y, pin);
 
-                display->setFont(FONT_SMALL);
-                char deviceName[64];
-                snprintf(deviceName, sizeof(deviceName), "Name: %s", getDeviceName());
-                y_offset = display->height() == 64 ? y_offset + FONT_HEIGHT_LARGE - 6 : y_offset + FONT_HEIGHT_LARGE + 5;
-                display->drawString(x_offset + x, y_offset + y, deviceName);
-            });
+            std::string ble_message = "Bluetooth\nPIN\n[M]" + passkey.substr(0, 3) + " " + passkey.substr(3, 6);
+            screen->showSimpleBanner(ble_message.c_str(), 30000);
         }
 #endif
         passkeyShowing = true;
 
-        return passkey;
+        return configuredPasskey;
     }
 
 #ifdef NIMBLE_TWO

src/platform/esp32/architecture.h

@@ -146,6 +146,8 @@
 #define HW_VENDOR meshtastic_HardwareModel_THINKNODE_M2
 #elif defined(ELECROW_ThinkNode_M5)
 #define HW_VENDOR meshtastic_HardwareModel_THINKNODE_M5
+#elif defined(ELECROW_ThinkNode_M7)
+#define HW_VENDOR meshtastic_HardwareModel_THINKNODE_M7
 #elif defined(ESP32_S3_PICO)
 #define HW_VENDOR meshtastic_HardwareModel_ESP32_S3_PICO
 #elif defined(SENSELORA_S3)
@@ -156,6 +158,8 @@
 #define HW_VENDOR meshtastic_HardwareModel_CHATTER_2
 #elif defined(STATION_G2)
 #define HW_VENDOR meshtastic_HardwareModel_STATION_G2
+#elif defined(STATION_G3)
+#define HW_VENDOR meshtastic_HardwareModel_STATION_G3
 #elif defined(UNPHONE)
 #define HW_VENDOR meshtastic_HardwareModel_UNPHONE
 #elif defined(WIPHONE)

src/platform/esp32/main-esp32.cpp

@@ -32,7 +32,7 @@ void variant_shutdown() {}
 #if !defined(CONFIG_IDF_TARGET_ESP32S2) && !MESHTASTIC_EXCLUDE_BLUETOOTH
 void setBluetoothEnable(bool enable)
 {
-#ifdef USE_WS5500
+#if defined(USE_WS5500) || defined(USE_CH390D)
     if ((config.bluetooth.enabled == true) && (config.network.wifi_enabled == false))
 #elif HAS_WIFI
     if (!isWifiAvailable() && config.bluetooth.enabled == true)

src/platform/nrf52/NRF52Bluetooth.cpp

@@ -386,34 +386,12 @@ bool NRF52Bluetooth::onPairingPasskey(uint16_t conn_handle, uint8_t const passke
     meshtastic::BluetoothStatus newStatus(textkey);
     bluetoothStatus->updateStatus(&newStatus);
 
-#if HAS_SCREEN &&                                                                                                                \
-    !defined(MESHTASTIC_EXCLUDE_SCREEN) // Todo: migrate this display code back into Screen class, and observe bluetoothStatus
+#if HAS_SCREEN && !defined(MESHTASTIC_EXCLUDE_SCREEN)
     if (screen) {
-        screen->startAlert([](OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) -> void {
-            char btPIN[16] = "888888";
-            snprintf(btPIN, sizeof(btPIN), "%06u", configuredPasskey);
-            int x_offset = display->width() / 2;
-            int y_offset = display->height() <= 80 ? 0 : 12;
-            display->setTextAlignment(TEXT_ALIGN_CENTER);
-            display->setFont(FONT_MEDIUM);
-            display->drawString(x_offset + x, y_offset + y, "Bluetooth");
-
-            display->setFont(FONT_SMALL);
-            y_offset = display->height() == 64 ? y_offset + FONT_HEIGHT_MEDIUM - 4 : y_offset + FONT_HEIGHT_MEDIUM + 5;
-            display->drawString(x_offset + x, y_offset + y, "Enter this code");
-
-            display->setFont(FONT_LARGE);
-            String displayPin(btPIN);
-            String pin = displayPin.substring(0, 3) + " " + displayPin.substring(3, 6);
-            y_offset = display->height() == 64 ? y_offset + FONT_HEIGHT_SMALL - 5 : y_offset + FONT_HEIGHT_SMALL + 5;
-            display->drawString(x_offset + x, y_offset + y, pin);
-
-            display->setFont(FONT_SMALL);
-            String deviceName = "Name: ";
-            deviceName.concat(getDeviceName());
-            y_offset = display->height() == 64 ? y_offset + FONT_HEIGHT_LARGE - 6 : y_offset + FONT_HEIGHT_LARGE + 5;
-            display->drawString(x_offset + x, y_offset + y, deviceName);
-        });
+        std::string configuredPasskeyText = std::to_string(configuredPasskey);
+        std::string ble_message =
+            "Bluetooth\nPIN\n[M]" + configuredPasskeyText.substr(0, 3) + " " + configuredPasskeyText.substr(3, 6);
+        screen->showSimpleBanner(ble_message.c_str(), 30000);
     }
 #endif
     passkeyShowing = true;

src/platform/nrf54l15/Arduino.h

@@ -0,0 +1,824 @@
+/**
+ * Arduino.h — Zephyr compatibility shim for nRF54L15
+ *
+ * Provides the Arduino API surface expected by Meshtastic, backed by
+ * Zephyr primitives.  Only the subset actually used by Meshtastic is
+ * implemented; the rest compiles as no-ops / stubs for now.
+ *
+ * Phase 2: compile only.  Real GPIO / SPI / Wire implementations follow
+ * in Phase 3 once the build is clean.
+ */
+
+#pragma once
+#ifndef Arduino_h
+#define Arduino_h
+
+// ── C standard headers ───────────────────────────────────────────────────────
+#include <math.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h> /* strcasecmp, strncasecmp */
+
+// ── Zephyr kernel ────────────────────────────────────────────────────────────
+#include <zephyr/kernel.h>
+#include <zephyr/sys/reboot.h>
+
+// ── Basic Arduino types ──────────────────────────────────────────────────────
+typedef bool boolean;
+typedef uint8_t byte;
+typedef uint16_t word;
+
+// ── Pin / digital constants ──────────────────────────────────────────────────
+#define INPUT 0u
+#define OUTPUT 1u
+#define INPUT_PULLUP 2u
+#define INPUT_PULLDOWN 3u
+#define OUTPUT_OPENDRAIN 4u
+
+#define HIGH 1u
+#define LOW 0u
+
+#define CHANGE 1
+#define FALLING 2
+#define RISING 3
+
+#ifndef LED_BUILTIN
+#define LED_BUILTIN -1
+#endif
+
+// ── Math / trig constants ────────────────────────────────────────────────────
+#ifndef PI
+#define PI 3.14159265358979323846
+#endif
+#define HALF_PI 1.57079632679489661923
+#define TWO_PI 6.28318530717958647693
+#define DEG_TO_RAD 0.01745329251994329576
+#define RAD_TO_DEG 57.2957795130823208767
+#define EULER 2.71828182845904523536
+
+// ── Bit utilities ────────────────────────────────────────────────────────────
+#define bitRead(v, b) (((v) >> (b)) & 1)
+#define bitSet(v, b) ((v) |= (1UL << (b)))
+#define bitClear(v, b) ((v) &= ~(1UL << (b)))
+#define bitToggle(v, b) ((v) ^= (1UL << (b)))
+#define bitWrite(v, b, x) ((x) ? bitSet(v, b) : bitClear(v, b))
+#define bit(b) (1UL << (b))
+#define lowByte(w) ((uint8_t)((w)&0xff))
+#define highByte(w) ((uint8_t)((w) >> 8))
+// word(h,l) — only define if not already defined (conflicts with typedef above)
+#undef word
+#define word(h, l) ((uint16_t)(((h) << 8) | (l)))
+
+// ── UART config constants ─────────────────────────────────────────────────────
+#define SERIAL_8N1 0x800001cu
+#define SERIAL_8N2 0x8000001eu
+#define SERIAL_8E1 0x8000001eu
+#define SERIAL_7E1 0x8000001cu
+
+// ── Integer order ────────────────────────────────────────────────────────────
+// Adafruit BusIO's SPIDevice.h has `typedef BitOrder BusIOBitOrder;` which
+// requires BitOrder to be a *type*, not a macro. Mirror the ArduinoCore-API
+// enum definition rather than #defines.
+enum BitOrder : uint8_t {
+    LSBFIRST = 0,
+    MSBFIRST = 1,
+};
+
+// ── pgmspace compatibility (no-ops on Cortex-M) ──────────────────────────────
+#define PROGMEM
+#define PSTR(s) (s)
+#define F(s) (s)
+#define pgm_read_byte(addr) (*((const uint8_t *)(addr)))
+#define pgm_read_word(addr) (*((const uint16_t *)(addr)))
+#define pgm_read_dword(addr) (*((const uint32_t *)(addr)))
+#define pgm_read_float(addr) (*((const float *)(addr)))
+#define pgm_read_ptr(addr) (*((const void **)(addr)))
+#define strlen_P(s) strlen(s)
+#define strcpy_P(d, s) strcpy(d, s)
+#define strncpy_P(d, s, n) strncpy(d, s, n)
+#define strcmp_P(a, b) strcmp(a, b)
+#define memcpy_P(d, s, n) memcpy(d, s, n)
+#define sprintf_P sprintf
+typedef const char *PGM_P;
+typedef const char *PGM_VOID_P;
+
+// ── Arduino numeric base constants (used by Print, RadioLib, etc.) ───────────
+#define DEC 10
+#define HEX 16
+#define OCT 8
+#define BIN 2
+
+// ── ulong / uint typedef (used by RadioLibInterface, etc.) ───────────────────
+typedef unsigned long ulong;
+typedef unsigned int uint;
+
+// ── Interrupt stubs ──────────────────────────────────────────────────────────
+static inline void interrupts() {}
+static inline void noInterrupts() {}
+#define digitalPinToInterrupt(p) (p)
+
+// ── portMAX_DELAY — freertosinc.h also defines this; let it win ──────────────
+// We intentionally do NOT define portMAX_DELAY here.  freertosinc.h defines
+// it for the FreeRTOS / Meshtastic threading layer and must not be overridden.
+
+// ── Timing & system functions — declared with C linkage ──────────────────────
+// buzz.cpp and others forward-declare delay() as extern "C"; keep linkage
+// consistent by wrapping in extern "C" here.
+#ifdef __cplusplus
+extern "C" {
+#endif
+void NVIC_SystemReset(void);
+uint32_t millis(void);
+uint32_t micros(void);
+void delay(uint32_t ms);
+void delayMicroseconds(uint32_t us);
+void yield(void);
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef __cplusplus
+
+#include <cctype>
+#include <cstdarg>
+
+// ── C++ STL — include BEFORE defining any min/max helpers ───────────────────
+// Include algorithm first so its min/max templates are in scope.
+// We must NOT define min/max as function-like macros: the C++ STL uses
+// 3-argument versions (min(a,b,comp)) that the preprocessor would treat as
+// calling a 2-arg macro with 3 args.
+#include <algorithm>
+// Bring 2-arg std::min / std::max into the global namespace as unqualified
+// names so that Arduino code calling min(a,b) continues to compile.
+// (Arduino convention; kept minimal to avoid surprises.)
+#undef min
+#undef max
+using std::max;
+using std::min;
+
+// ── Arduino math helpers (macros safe for mixed-type / C calls) ──────────────
+#ifndef abs
+#define abs(x) ((x) >= 0 ? (x) : -(x))
+#endif
+#define constrain(x, l, h) ((x) < (l) ? (l) : ((x) > (h) ? (h) : (x)))
+#define round(x) ((x) >= 0 ? (long)((x) + 0.5) : (long)((x)-0.5))
+#define radians(d) ((d)*DEG_TO_RAD)
+#define degrees(r) ((r)*RAD_TO_DEG)
+#define sq(x) ((x) * (x))
+
+// ── Random ───────────────────────────────────────────────────────────────────
+static inline void randomSeed(unsigned long seed)
+{
+    srand((unsigned int)seed);
+}
+static inline long random(void)
+{
+    return (long)rand();
+}
+static inline long random(long bound)
+{
+    return bound > 0 ? (rand() % bound) : 0;
+}
+static inline long random(long lo, long hi)
+{
+    return hi > lo ? lo + rand() % (hi - lo) : lo;
+}
+
+// ── GPIO — real Zephyr implementation (Phase 3) ──────────────────────────────
+// Implemented in nrf54l15_arduino.cpp using Zephyr GPIO/SPI APIs.
+// Pin numbering: P0.n = n, P1.n = 16+n, P2.n = 32+n
+void pinMode(uint32_t pin, uint32_t mode);
+void digitalWrite(uint32_t pin, uint32_t value);
+int digitalRead(uint32_t pin);
+static inline void digitalToggle(uint32_t pin)
+{
+    digitalWrite(pin, !digitalRead(pin));
+}
+static inline uint32_t analogRead(uint32_t)
+{
+    return 0;
+}
+static inline void analogWrite(uint32_t, uint32_t) {}
+static inline void analogReadResolution(int) {}
+static inline void analogWriteResolution(int) {}
+
+// ── __WFI — provided by CMSIS core_cm33.h; do NOT redefine here ─────────────
+
+// ── __FlashStringHelper — Arduino PROGMEM string class (no-op on Cortex-M) ──
+class __FlashStringHelper;
+
+// ── attachInterrupt / detachInterrupt — real Zephyr GPIO interrupt impl ──────
+typedef void (*voidFuncPtr)(void);
+void attachInterrupt(uint32_t pin, voidFuncPtr cb, int mode);
+void detachInterrupt(uint32_t pin);
+
+// ── Forward declaration of String (needed by Print / Stream) ─────────────────
+class String;
+
+// ── Print base class ─────────────────────────────────────────────────────────
+class Print
+{
+  public:
+    virtual size_t write(uint8_t c) = 0;
+    virtual size_t write(const uint8_t *buf, size_t n)
+    {
+        size_t written = 0;
+        while (n--)
+            written += write(*buf++);
+        return written;
+    }
+    size_t write(const char *s) { return s ? write((const uint8_t *)s, strlen(s)) : 0; }
+    size_t write(const char *s, size_t n) { return write((const uint8_t *)s, n); }
+
+    size_t print(const char *s) { return s ? write((const uint8_t *)s, strlen(s)) : 0; }
+    int printf(const char *fmt, ...) __attribute__((format(printf, 2, 3)));
+
+    size_t print(char c) { return write((uint8_t)c); }
+    size_t print(const String &s);
+    size_t print(unsigned char n, int base = 10);
+    size_t print(int n, int base = 10);
+    size_t print(long n, int base = 10);
+    size_t print(unsigned int n, int base = 10);
+    size_t print(unsigned long n, int base = 10);
+    size_t print(float n, int digits = 2);
+    size_t print(double n, int digits = 2);
+    size_t print(bool b) { return print(b ? "true" : "false"); }
+
+    size_t println() { return write((uint8_t)'\n'); }
+    size_t println(const char *s)
+    {
+        size_t r = print(s);
+        return r + println();
+    }
+    size_t println(char c)
+    {
+        size_t r = print(c);
+        return r + println();
+    }
+    size_t println(const String &s);
+    size_t println(int n, int base = 10)
+    {
+        size_t r = print(n, base);
+        return r + println();
+    }
+    size_t println(long n, int base = 10)
+    {
+        size_t r = print(n, base);
+        return r + println();
+    }
+    size_t println(unsigned long n, int base = 10)
+    {
+        size_t r = print(n, base);
+        return r + println();
+    }
+    size_t println(unsigned int n, int base = 10)
+    {
+        size_t r = print(n, base);
+        return r + println();
+    }
+    size_t println(float n, int d = 2)
+    {
+        size_t r = print(n, d);
+        return r + println();
+    }
+    size_t println(double n, int d = 2)
+    {
+        size_t r = print(n, d);
+        return r + println();
+    }
+    size_t println(bool b)
+    {
+        size_t r = print(b);
+        return r + println();
+    }
+
+    virtual void flush() {}
+};
+
+// ── Stream base class ────────────────────────────────────────────────────────
+class Stream : public Print
+{
+  public:
+    virtual int available() = 0;
+    virtual int read() = 0;
+    virtual int peek() = 0;
+    virtual void setTimeout(unsigned long) {}
+    virtual bool find(const char *) { return false; }
+    String readString();
+    String readStringUntil(char terminator);
+};
+
+// ── Minimal Arduino String class (backed by a char buffer) ───────────────────
+class String
+{
+  public:
+    String() : _buf(nullptr), _len(0), _cap(0) {}
+    // Implicit conversion is part of the Arduino String contract, used pervasively across the codebase.
+    // cppcheck-suppress noExplicitConstructor
+    String(const char *cstr) : _buf(nullptr), _len(0), _cap(0)
+    {
+        if (cstr)
+            assign(cstr, strlen(cstr));
+    }
+    // cppcheck-suppress noExplicitConstructor
+    String(const String &s) : _buf(nullptr), _len(0), _cap(0) { assign(s._buf ? s._buf : "", s._len); }
+    // cppcheck-suppress noExplicitConstructor
+    String(char c) : _buf(nullptr), _len(0), _cap(0)
+    {
+        const char tmp[2] = {c, 0};
+        assign(tmp, 1);
+    }
+    // cppcheck-suppress noExplicitConstructor
+    String(int n) : _buf(nullptr), _len(0), _cap(0)
+    {
+        char tmp[16];
+        snprintf(tmp, 16, "%d", n);
+        assign(tmp, strlen(tmp));
+    }
+    // cppcheck-suppress noExplicitConstructor
+    String(unsigned int n) : _buf(nullptr), _len(0), _cap(0)
+    {
+        char tmp[16];
+        snprintf(tmp, 16, "%u", n);
+        assign(tmp, strlen(tmp));
+    }
+    // cppcheck-suppress noExplicitConstructor
+    String(long n) : _buf(nullptr), _len(0), _cap(0)
+    {
+        char tmp[24];
+        snprintf(tmp, 24, "%ld", n);
+        assign(tmp, strlen(tmp));
+    }
+    // cppcheck-suppress noExplicitConstructor
+    String(unsigned long n) : _buf(nullptr), _len(0), _cap(0)
+    {
+        char tmp[24];
+        snprintf(tmp, 24, "%lu", n);
+        assign(tmp, strlen(tmp));
+    }
+    // cppcheck-suppress noExplicitConstructor
+    String(float n, int d = 2) : _buf(nullptr), _len(0), _cap(0)
+    {
+        char tmp[32];
+        snprintf(tmp, 32, "%.*f", d, n);
+        assign(tmp, strlen(tmp));
+    }
+    // cppcheck-suppress noExplicitConstructor
+    String(double n, int d = 2) : _buf(nullptr), _len(0), _cap(0)
+    {
+        char tmp[32];
+        snprintf(tmp, 32, "%.*f", d, (double)n);
+        assign(tmp, strlen(tmp));
+    }
+    ~String() { free(_buf); }
+
+    String &operator=(const String &s)
+    {
+        assign(s._buf ? s._buf : "", s._len);
+        return *this;
+    }
+    String &operator=(const char *s)
+    {
+        assign(s ? s : "", s ? strlen(s) : 0);
+        return *this;
+    }
+    String &operator=(char c)
+    {
+        const char tmp[2] = {c, 0};
+        assign(tmp, 1);
+        return *this;
+    }
+
+    String &operator+=(const String &s)
+    {
+        concat(s._buf ? s._buf : "", s._len);
+        return *this;
+    }
+    String &operator+=(const char *s)
+    {
+        if (s)
+            concat(s, strlen(s));
+        return *this;
+    }
+    String &operator+=(char c)
+    {
+        concat(&c, 1);
+        return *this;
+    }
+    String &operator+=(int n) { return *this += String(n); }
+    String &operator+=(unsigned long n) { return *this += String(n); }
+
+    String operator+(const String &rhs) const
+    {
+        String r(*this);
+        r += rhs;
+        return r;
+    }
+    String operator+(const char *rhs) const
+    {
+        String r(*this);
+        r += rhs;
+        return r;
+    }
+    String operator+(char rhs) const
+    {
+        String r(*this);
+        r += rhs;
+        return r;
+    }
+
+    bool operator==(const String &s) const { return _len == s._len && (_len == 0 || strcmp(_buf, s._buf) == 0); }
+    bool operator==(const char *s) const { return s && strcmp(c_str(), s) == 0; }
+    bool operator!=(const String &s) const { return !(*this == s); }
+    bool operator!=(const char *s) const { return !(*this == s); }
+    bool operator<(const String &s) const { return strcmp(c_str(), s.c_str()) < 0; }
+    bool operator>(const String &s) const { return strcmp(c_str(), s.c_str()) > 0; }
+
+    char operator[](unsigned int i) const { return (_buf && i < _len) ? _buf[i] : 0; }
+    char &operator[](unsigned int i)
+    {
+        static char dummy = 0;
+        return (_buf && i < _len) ? _buf[i] : dummy;
+    }
+
+    const char *c_str() const { return _buf ? _buf : ""; }
+    unsigned int length() const { return _len; }
+    bool isEmpty() const { return _len == 0; }
+    bool equals(const String &s) const { return *this == s; }
+    bool equals(const char *s) const { return *this == s; }
+    bool equalsIgnoreCase(const String &s) const
+    {
+        if (_len != s._len)
+            return false;
+        for (unsigned i = 0; i < _len; i++)
+            if (std::tolower(_buf[i]) != std::tolower(s._buf[i]))
+                return false;
+        return true;
+    }
+    bool startsWith(const String &pfx) const
+    {
+        if (pfx._len > _len)
+            return false;
+        return strncmp(c_str(), pfx.c_str(), pfx._len) == 0;
+    }
+    bool startsWith(const char *pfx) const
+    {
+        if (!pfx)
+            return false;
+        size_t pl = strlen(pfx);
+        return pl <= _len && strncmp(c_str(), pfx, pl) == 0;
+    }
+    bool endsWith(const String &sfx) const
+    {
+        if (sfx._len > _len)
+            return false;
+        return strcmp(c_str() + _len - sfx._len, sfx.c_str()) == 0;
+    }
+    int indexOf(char c, unsigned from = 0) const
+    {
+        if (!_buf)
+            return -1;
+        const char *p = strchr(_buf + from, c);
+        return p ? (int)(p - _buf) : -1;
+    }
+    int indexOf(const String &s, unsigned from = 0) const
+    {
+        if (!_buf)
+            return -1;
+        const char *p = strstr(_buf + from, s.c_str());
+        return p ? (int)(p - _buf) : -1;
+    }
+    int lastIndexOf(char c) const
+    {
+        if (!_buf)
+            return -1;
+        const char *p = strrchr(_buf, c);
+        return p ? (int)(p - _buf) : -1;
+    }
+    String substring(unsigned beginIndex) const
+    {
+        if (!_buf || beginIndex >= _len)
+            return String();
+        return String(_buf + beginIndex);
+    }
+    String substring(unsigned beginIndex, unsigned endIndex) const
+    {
+        if (!_buf || beginIndex >= _len)
+            return String();
+        if (endIndex > _len)
+            endIndex = _len;
+        if (endIndex <= beginIndex)
+            return String();
+        String r;
+        r.assign(_buf + beginIndex, endIndex - beginIndex);
+        return r;
+    }
+    void toUpperCase()
+    {
+        if (_buf)
+            for (unsigned i = 0; i < _len; i++)
+                _buf[i] = (char)std::toupper(_buf[i]);
+    }
+    void toLowerCase()
+    {
+        if (_buf)
+            for (unsigned i = 0; i < _len; i++)
+                _buf[i] = (char)std::tolower(_buf[i]);
+    }
+    void trim()
+    {
+        if (!_buf || _len == 0)
+            return;
+        unsigned s = 0;
+        while (s < _len && std::isspace(_buf[s]))
+            s++;
+        unsigned e = _len;
+        while (e > s && std::isspace(_buf[e - 1]))
+            e--;
+        if (s > 0 || e < _len) {
+            memmove(_buf, _buf + s, e - s);
+            _len = e - s;
+            _buf[_len] = 0;
+        }
+    }
+    void replace(char from, char to)
+    {
+        if (_buf)
+            for (unsigned i = 0; i < _len; i++)
+                if (_buf[i] == from)
+                    _buf[i] = to;
+    }
+    void replace(const String &from, const String &to);
+    bool remove(unsigned index, unsigned count = 1)
+    {
+        if (!_buf || index >= _len)
+            return false;
+        if (index + count > _len)
+            count = _len - index;
+        memmove(_buf + index, _buf + index + count, _len - index - count + 1);
+        _len -= count;
+        return true;
+    }
+    void clear()
+    {
+        _len = 0;
+        if (_buf)
+            _buf[0] = 0;
+    }
+    char charAt(unsigned i) const { return (*this)[i]; }
+    void setCharAt(unsigned i, char c)
+    {
+        if (_buf && i < _len)
+            _buf[i] = c;
+    }
+    void toCharArray(char *buf, unsigned int bufsize, unsigned int index = 0) const
+    {
+        if (!buf || bufsize == 0)
+            return;
+        unsigned int avail = (_buf && _len > index) ? (_len - index) : 0;
+        unsigned int copy = avail < bufsize - 1 ? avail : bufsize - 1;
+        if (copy > 0)
+            memcpy(buf, _buf + index, copy);
+        buf[copy] = '\0';
+    }
+    void concat(const String &s) { *this += s; }
+    void concat(const char *s) { *this += s; }
+    long toInt() const { return _buf ? atol(_buf) : 0; }
+    float toFloat() const { return _buf ? (float)atof(_buf) : 0.0f; }
+    double toDouble() const { return _buf ? atof(_buf) : 0.0; }
+
+  private:
+    char *_buf;
+    unsigned int _len;
+    unsigned int _cap;
+
+    void assign(const char *s, unsigned int n)
+    {
+        if (n >= _cap)
+            reserve(n + 1);
+        if (_buf) {
+            memcpy(_buf, s, n);
+            _buf[n] = 0;
+            _len = n;
+        }
+    }
+    void concat(const char *s, unsigned int n)
+    {
+        if (!s || n == 0)
+            return;
+        unsigned newlen = _len + n;
+        if (newlen >= _cap)
+            reserve(newlen + 1);
+        if (_buf) {
+            memcpy(_buf + _len, s, n);
+            _len = newlen;
+            _buf[_len] = 0;
+        }
+    }
+    void reserve(unsigned int n)
+    {
+        char *b = (char *)realloc(_buf, n);
+        if (b) {
+            _buf = b;
+            _cap = n;
+        }
+    }
+};
+
+inline String operator+(const char *lhs, const String &rhs)
+{
+    return String(lhs) + rhs;
+}
+inline String operator+(char lhs, const String &rhs)
+{
+    return String(lhs) + rhs;
+}
+
+// ── Print inline definitions that need String ────────────────────────────────
+inline size_t Print::print(const String &s)
+{
+    return write((const uint8_t *)s.c_str(), s.length());
+}
+inline size_t Print::println(const String &s)
+{
+    size_t r = print(s);
+    return r + println();
+}
+
+// ── Stream inline definitions that need String ───────────────────────────────
+inline String Stream::readString()
+{
+    return String();
+}
+inline String Stream::readStringUntil(char)
+{
+    return String();
+}
+
+// ── HardwareSerial ───────────────────────────────────────────────────────────
+class HardwareSerial : public Stream
+{
+  public:
+    void begin(unsigned long) {}
+    void begin(unsigned long, uint16_t) {}
+    void end() {}
+    void setPins(int rx, int tx) {}
+    void setPinout(int tx, int rx) {}
+    void setFIFOSize(size_t) {}
+    void setRxBufferSize(size_t) {}
+    void begin(unsigned long baud, uint32_t config, int8_t rx = -1, int8_t tx = -1, bool invert = false) {}
+    int available() override { return 0; }
+    int read() override { return -1; }
+    int peek() override { return -1; }
+    size_t write(uint8_t c) override;
+    size_t write(const uint8_t *buf, size_t n) override;
+    using Print::write; // un-hide base class write(const char*)
+    size_t readBytes(uint8_t *buf, size_t len) { return 0; }
+    size_t readBytes(char *buf, size_t len) { return 0; }
+    operator bool() const { return true; }
+    void flush() override {}
+    String readString() { return String(); }
+    String readStringUntil(char) { return String(); }
+};
+
+// Uart — nRF52 BSP alias for HardwareSerial (used by GPS.h when ARCH_NRF52)
+typedef HardwareSerial Uart;
+
+extern HardwareSerial Serial;
+extern HardwareSerial Serial1;
+extern HardwareSerial Serial2;
+
+// ── map() utility ────────────────────────────────────────────────────────────
+static inline long map(long x, long in_min, long in_max, long out_min, long out_max)
+{
+    return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
+}
+
+// ── shiftIn / shiftOut stubs ─────────────────────────────────────────────────
+static inline uint8_t shiftIn(uint8_t, uint8_t, uint8_t)
+{
+    return 0;
+}
+static inline void shiftOut(uint8_t, uint8_t, uint8_t, uint8_t) {}
+
+// ── tone / noTone stubs ──────────────────────────────────────────────────────
+static inline void tone(uint8_t, unsigned int, unsigned long = 0) {}
+static inline void noTone(uint8_t) {}
+
+// ── pulseIn stub ─────────────────────────────────────────────────────────────
+static inline unsigned long pulseIn(uint8_t, uint8_t, unsigned long = 1000000UL)
+{
+    return 0;
+}
+
+// ── strdup / stpcpy — POSIX extensions not in Zephyr newlib ─────────────────
+#ifndef strdup
+static inline char *strdup(const char *s)
+{
+    size_t n = strlen(s) + 1;
+    char *d = (char *)malloc(n);
+    if (d)
+        memcpy(d, s, n);
+    return d;
+}
+#endif
+#ifndef stpcpy
+static inline char *stpcpy(char *dst, const char *src)
+{
+    while ((*dst++ = *src++) != '\0') {
+    }
+    return dst - 1;
+}
+#endif
+
+// ── strnstr — BSD extension not in Zephyr libc; defined in meshUtils.cpp ─────
+// Declare here so callers (GPS.cpp etc.) don't need ARCH_PORTDUINO.
+#ifndef STRNSTR
+#define STRNSTR
+char *strnstr(const char *s, const char *find, size_t slen);
+#endif
+
+// ── strlcpy — BSD extension; implementation in nrf54l15_arduino.cpp ──────────
+#ifndef HAVE_STRLCPY
+#define HAVE_STRLCPY
+#ifdef __cplusplus
+extern "C" {
+#endif
+size_t strlcpy(char *dst, const char *src, size_t size);
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+// ── setenv / getenv / tzset — Zephyr stubs for timezone support ──────────────
+#include <stdlib.h>
+static inline int setenv(const char *, const char *, int)
+{
+    return 0;
+}
+static inline void tzset(void) {}
+
+// ── dbgHeapFree / dbgHeapTotal — nRF52 BSP heap diagnostics ─────────────────
+// Used by memGet.cpp when ARCH_NRF52 is defined.  Return 0 for Phase 2.
+static inline uint32_t dbgHeapFree(void)
+{
+    return 0;
+}
+static inline uint32_t dbgHeapTotal(void)
+{
+    return 0;
+}
+
+// ── WCharacter helpers ───────────────────────────────────────────────────────
+static inline bool isAlpha(char c)
+{
+    return std::isalpha((unsigned char)c) != 0;
+}
+static inline bool isAlphaNumeric(char c)
+{
+    return std::isalnum((unsigned char)c) != 0;
+}
+static inline bool isDigit(char c)
+{
+    return std::isdigit((unsigned char)c) != 0;
+}
+static inline bool isSpace(char c)
+{
+    return std::isspace((unsigned char)c) != 0;
+}
+static inline bool isUpperCase(char c)
+{
+    return std::isupper((unsigned char)c) != 0;
+}
+static inline bool isLowerCase(char c)
+{
+    return std::islower((unsigned char)c) != 0;
+}
+static inline char toUpperCase(char c)
+{
+    return (char)std::toupper((unsigned char)c);
+}
+static inline char toLowerCase(char c)
+{
+    return (char)std::tolower((unsigned char)c);
+}
+
+#else /* C only */
+#ifndef min
+#define min(a, b) ((a) < (b) ? (a) : (b))
+#endif
+#ifndef max
+#define max(a, b) ((a) > (b) ? (a) : (b))
+#endif
+#ifndef abs
+#define abs(x) ((x) >= 0 ? (x) : -(x))
+#endif
+#define constrain(x, l, h) ((x) < (l) ? (l) : ((x) > (h) ? (h) : (x)))
+#define round(x) ((x) >= 0 ? (long)((x) + 0.5) : (long)((x)-0.5))
+#endif /* __cplusplus */
+
+#endif /* Arduino_h */

src/platform/nrf54l15/IPAddress.h

@@ -0,0 +1,34 @@
+// IPAddress.h — stub for nRF54L15/Zephyr
+// MQTT.cpp includes this for IPv4 address representation.
+// Phase 2: compile-only stub.
+#pragma once
+#include <stdint.h>
+
+class IPAddress
+{
+  public:
+    IPAddress() : _addr(0) {}
+    explicit IPAddress(uint32_t addr) : _addr(addr) {}
+    IPAddress(uint8_t a, uint8_t b, uint8_t c, uint8_t d)
+        : _addr(((uint32_t)a) | ((uint32_t)b << 8) | ((uint32_t)c << 16) | ((uint32_t)d << 24))
+    {
+    }
+
+    uint8_t operator[](int i) const { return reinterpret_cast<const uint8_t *>(&_addr)[i]; }
+    operator uint32_t() const { return _addr; }
+    bool operator==(const IPAddress &o) const { return _addr == o._addr; }
+    bool operator!=(const IPAddress &o) const { return _addr != o._addr; }
+
+    bool fromString(const char *addr)
+    {
+        unsigned a, b, c, d;
+        if (sscanf(addr, "%u.%u.%u.%u", &a, &b, &c, &d) == 4 && a <= 255 && b <= 255 && c <= 255 && d <= 255) {
+            _addr = a | (b << 8) | (c << 16) | (d << 24);
+            return true;
+        }
+        return false;
+    }
+
+  private:
+    uint32_t _addr;
+};

src/platform/nrf54l15/InternalFileSystem.cpp

@@ -0,0 +1,274 @@
+// InternalFileSystem.cpp — Zephyr LittleFS backend for nRF54L15
+//
+// Implements Adafruit_LittleFS_Namespace used by FSCommon.h/cpp.
+// Storage: 36 KB storage_partition in nRF54L15 internal RRAM (defined in
+// zephyr/dts/nordic/nrf54l15_partition.dtsi, included by the board DTS).
+
+#include "InternalFileSystem.h"
+#include "configuration.h"
+
+#include <zephyr/fs/fs.h>
+#include <zephyr/fs/littlefs.h>
+#include <zephyr/storage/flash_map.h>
+
+using namespace Adafruit_LittleFS_Namespace;
+
+// ── LittleFS mount ────────────────────────────────────────────────────────
+
+FS_LITTLEFS_DECLARE_DEFAULT_CONFIG(nrf54l15_lfs_data);
+
+static struct fs_mount_t _lfs_mnt = {
+    .type = FS_LITTLEFS,
+    .mnt_point = NRF54L15_FS_MOUNT,
+    .fs_data = &nrf54l15_lfs_data,
+    .storage_dev = (void *)(uintptr_t)FIXED_PARTITION_ID(storage_partition),
+    .flags = 0,
+};
+
+// ── Global singleton ──────────────────────────────────────────────────────
+
+Adafruit_LittleFS_Namespace::InternalFileSystem InternalFS;
+
+// ── Path helpers ──────────────────────────────────────────────────────────
+
+void InternalFileSystem::toabs(const char *rel, char *abs, size_t abssz)
+{
+    // Root "/" maps to the mount point itself (no trailing slash)
+    if (rel[0] == '/' && rel[1] == '\0') {
+        strncpy(abs, NRF54L15_FS_MOUNT, abssz - 1);
+        abs[abssz - 1] = '\0';
+    } else if (rel[0] == '/') {
+        snprintf(abs, abssz, "%s%s", NRF54L15_FS_MOUNT, rel);
+    } else {
+        snprintf(abs, abssz, "%s/%s", NRF54L15_FS_MOUNT, rel);
+    }
+}
+
+// Strip mount-point prefix to get the FS-root-relative path ("/prefs/...").
+static void torel(const char *abs, char *rel, size_t relsz)
+{
+    const char *mp = NRF54L15_FS_MOUNT;
+    size_t mplen = strlen(mp);
+    if (strncmp(abs, mp, mplen) == 0) {
+        const char *suffix = abs + mplen;
+        if (suffix[0] == '\0') {
+            strncpy(rel, "/", relsz);
+        } else {
+            strncpy(rel, suffix, relsz - 1);
+            rel[relsz - 1] = '\0';
+        }
+    } else {
+        strncpy(rel, abs, relsz - 1);
+        rel[relsz - 1] = '\0';
+    }
+}
+
+// ── InternalFileSystem methods ────────────────────────────────────────────
+
+bool InternalFileSystem::begin()
+{
+    if (_mounted)
+        return true;
+
+    int rc = fs_mount(&_lfs_mnt);
+    if (rc == 0) {
+        _mounted = true;
+        return true;
+    }
+
+    // Mount failed: attempt to format (creates a fresh LittleFS)
+    LOG_WARN("LittleFS mount failed (%d), formatting storage partition...", rc);
+    int fmt_rc = fs_mkfs(FS_LITTLEFS, (uintptr_t)FIXED_PARTITION_ID(storage_partition), NULL, 0);
+    if (fmt_rc != 0) {
+        LOG_ERROR("LittleFS format failed (%d)", fmt_rc);
+        return false;
+    }
+
+    rc = fs_mount(&_lfs_mnt);
+    if (rc == 0) {
+        _mounted = true;
+        return true;
+    }
+
+    LOG_ERROR("LittleFS mount failed after format (%d)", rc);
+    return false;
+}
+
+File InternalFileSystem::open(const char *path, const char *mode)
+{
+    if (!_mounted)
+        return File();
+
+    char abs[NRF54L15_FS_PATHLEN];
+    toabs(path, abs, sizeof(abs));
+
+    auto s = std::make_shared<NRF54L15FileState>();
+    if (!s)
+        return File();
+
+    strncpy(s->fullpath, abs, sizeof(s->fullpath) - 1);
+    torel(abs, s->relpath, sizeof(s->relpath));
+
+    // Check whether the path is a directory
+    struct fs_dirent entry;
+    int stat_rc = fs_stat(abs, &entry);
+    if (stat_rc == 0 && entry.type == FS_DIR_ENTRY_DIR) {
+        s->is_dir = true;
+        if (fs_opendir(&s->dir, abs) == 0) {
+            s->valid = true;
+            return File(s);
+        }
+        return File();
+    }
+
+    // Open as a regular file
+    fs_mode_t flags;
+    if (strcmp(mode, FILE_O_WRITE) == 0) {
+        // Truncate on write — unlink first to ensure a clean start
+        fs_unlink(abs);
+        flags = FS_O_WRITE | FS_O_CREATE;
+    } else {
+        flags = FS_O_READ;
+    }
+
+    if (fs_open(&s->file, abs, flags) == 0) {
+        s->is_dir = false;
+        s->valid = true;
+        return File(s);
+    }
+
+    return File();
+}
+
+bool InternalFileSystem::exists(const char *path)
+{
+    if (!_mounted)
+        return false;
+    char abs[NRF54L15_FS_PATHLEN];
+    toabs(path, abs, sizeof(abs));
+    struct fs_dirent entry;
+    return fs_stat(abs, &entry) == 0;
+}
+
+bool InternalFileSystem::remove(const char *path)
+{
+    if (!_mounted)
+        return false;
+    char abs[NRF54L15_FS_PATHLEN];
+    toabs(path, abs, sizeof(abs));
+    return fs_unlink(abs) == 0;
+}
+
+bool InternalFileSystem::rename(const char *from, const char *to)
+{
+    if (!_mounted)
+        return false;
+    char absfrom[NRF54L15_FS_PATHLEN], absto[NRF54L15_FS_PATHLEN];
+    toabs(from, absfrom, sizeof(absfrom));
+    toabs(to, absto, sizeof(absto));
+    return fs_rename(absfrom, absto) == 0;
+}
+
+bool InternalFileSystem::mkdir(const char *path)
+{
+    if (!_mounted)
+        return false;
+    char abs[NRF54L15_FS_PATHLEN];
+    toabs(path, abs, sizeof(abs));
+    int rc = fs_mkdir(abs);
+    return rc == 0 || rc == -EEXIST;
+}
+
+bool InternalFileSystem::rmdir(const char *path)
+{
+    if (!_mounted)
+        return false;
+    char abs[NRF54L15_FS_PATHLEN];
+    toabs(path, abs, sizeof(abs));
+    return fs_unlink(abs) == 0;
+}
+
+bool InternalFileSystem::rmdir_r(const char *path)
+{
+    if (!_mounted)
+        return false;
+    char abs[NRF54L15_FS_PATHLEN];
+    toabs(path, abs, sizeof(abs));
+
+    struct fs_dir_t dir;
+    fs_dir_t_init(&dir);
+    if (fs_opendir(&dir, abs) != 0) {
+        // Not a directory — try to delete as file
+        return fs_unlink(abs) == 0;
+    }
+
+    struct fs_dirent entry;
+    char child[NRF54L15_FS_PATHLEN];
+    while (fs_readdir(&dir, &entry) == 0 && entry.name[0] != '\0') {
+        snprintf(child, sizeof(child), "%s/%s", abs, entry.name);
+        if (entry.type == FS_DIR_ENTRY_DIR) {
+            // Recurse: pass the absolute path stripped of mount prefix
+            char childrel[NRF54L15_FS_PATHLEN];
+            torel(child, childrel, sizeof(childrel));
+            rmdir_r(childrel);
+        } else {
+            fs_unlink(child);
+        }
+    }
+    fs_closedir(&dir);
+    return fs_unlink(abs) == 0;
+}
+
+bool InternalFileSystem::format()
+{
+    if (_mounted) {
+        fs_unmount(&_lfs_mnt);
+        _mounted = false;
+    }
+    int rc = fs_mkfs(FS_LITTLEFS, (uintptr_t)FIXED_PARTITION_ID(storage_partition), NULL, 0);
+    if (rc != 0) {
+        LOG_ERROR("LittleFS format failed (%d)", rc);
+        return false;
+    }
+    return begin();
+}
+
+// ── File::openNextFile ────────────────────────────────────────────────────
+// Defined here because it accesses Zephyr fs_readdir/fs_open APIs.
+
+File File::openNextFile()
+{
+    if (!_s || !_s->valid || !_s->is_dir)
+        return File();
+
+    struct fs_dirent entry;
+    if (fs_readdir(&_s->dir, &entry) != 0)
+        return File();
+    if (entry.name[0] == '\0')
+        return File(); // end of directory
+
+    char childabs[NRF54L15_FS_PATHLEN];
+    snprintf(childabs, sizeof(childabs), "%s/%s", _s->fullpath, entry.name);
+
+    auto s = std::make_shared<NRF54L15FileState>();
+    if (!s)
+        return File();
+
+    strncpy(s->fullpath, childabs, sizeof(s->fullpath) - 1);
+    torel(childabs, s->relpath, sizeof(s->relpath));
+
+    if (entry.type == FS_DIR_ENTRY_DIR) {
+        s->is_dir = true;
+        if (fs_opendir(&s->dir, childabs) == 0) {
+            s->valid = true;
+            return File(s);
+        }
+    } else {
+        s->is_dir = false;
+        if (fs_open(&s->file, childabs, FS_O_READ) == 0) {
+            s->valid = true;
+            return File(s);
+        }
+    }
+    return File();
+}

src/platform/nrf54l15/InternalFileSystem.h

@@ -0,0 +1,212 @@
+// InternalFileSystem.h — Zephyr LittleFS backend for nRF54L15
+//
+// Implements the Adafruit InternalFileSystem API subset used by Meshtastic,
+// backed by Zephyr's fs/littlefs on the storage_partition of the nRF54L15's
+// internal RRAM. Partition size is taken from the DTS at compile time via
+// FIXED_PARTITION_SIZE(storage_partition) — the DK overlay currently maps
+// ~700 KB into slot1 (see zephyr/boards/nrf54l15dk_nrf54l15_cpuapp.overlay).
+//
+// Mount point: /lfs
+// All paths passed to open/exists/mkdir etc. are relative to the FS root
+// (e.g. "/prefs/config.proto") and are prepended with "/lfs" internally.
+//
+// File objects are copyable via std::shared_ptr<NRF54L15FileState>.
+// The underlying Zephyr handle is closed when the last copy is destroyed.
+
+#pragma once
+
+#include <memory>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include <zephyr/fs/fs.h>
+#include <zephyr/storage/flash_map.h>
+
+#ifndef FILE_O_READ
+#define FILE_O_READ "r"
+#define FILE_O_WRITE "w"
+#endif
+
+#define NRF54L15_FS_MOUNT "/lfs"
+#define NRF54L15_FS_PATHLEN 256
+
+namespace Adafruit_LittleFS_Namespace
+{
+
+class InternalFileSystem; // forward
+
+// ── Internal file/dir state ───────────────────────────────────────────────
+
+struct NRF54L15FileState {
+    bool valid = false;
+    bool is_dir = false;
+
+    // Absolute Zephyr path, e.g. "/lfs/prefs/config.proto"
+    char fullpath[NRF54L15_FS_PATHLEN] = {0};
+    // Path from FS root, e.g. "/prefs/config.proto"  (returned by name())
+    char relpath[NRF54L15_FS_PATHLEN] = {0};
+
+    struct fs_file_t file;
+    struct fs_dir_t dir;
+
+    NRF54L15FileState()
+    {
+        fs_file_t_init(&file);
+        fs_dir_t_init(&dir);
+    }
+
+    ~NRF54L15FileState()
+    {
+        if (valid) {
+            if (is_dir)
+                fs_closedir(&dir);
+            else
+                fs_close(&file);
+            valid = false;
+        }
+    }
+};
+
+// ── File ─────────────────────────────────────────────────────────────────
+
+class File
+{
+  public:
+    File() = default;
+    explicit File(InternalFileSystem &) {} // nRF52 compat constructor
+
+    explicit operator bool() const { return _s && _s->valid; }
+
+    int read(void *buf, uint16_t nbyte)
+    {
+        if (!_s || !_s->valid || _s->is_dir)
+            return -1;
+        ssize_t n = fs_read(&_s->file, buf, nbyte);
+        return n < 0 ? -1 : (int)n;
+    }
+
+    int read()
+    {
+        uint8_t b;
+        return read(&b, 1) == 1 ? (int)b : -1;
+    }
+
+    size_t write(const uint8_t *buf, size_t len)
+    {
+        if (!_s || !_s->valid || _s->is_dir)
+            return 0;
+        ssize_t n = fs_write(&_s->file, buf, len);
+        return n < 0 ? 0 : (size_t)n;
+    }
+
+    size_t write(uint8_t b) { return write(&b, 1); }
+
+    void flush()
+    {
+        if (_s && _s->valid && !_s->is_dir)
+            fs_sync(&_s->file);
+    }
+
+    void close() { _s.reset(); }
+
+    size_t size()
+    {
+        if (!_s || !_s->valid || _s->is_dir)
+            return 0;
+        struct fs_dirent entry;
+        if (fs_stat(_s->fullpath, &entry) == 0)
+            return (size_t)entry.size;
+        return 0;
+    }
+
+    bool isDirectory() { return _s && _s->valid && _s->is_dir; }
+
+    // Returns path from FS root, e.g. "/prefs/config.proto"
+    const char *name() { return _s ? _s->relpath : ""; }
+
+    // Returns the next entry in a directory.  Modifies the dir stream in _s.
+    File openNextFile();
+
+    void rewindDirectory()
+    {
+        if (!_s || !_s->valid || !_s->is_dir)
+            return;
+        // Zephyr has no rewinddir(); close + reopen the same handle. Skipping
+        // the close would leak the LittleFS dir state and the next openNextFile
+        // could return stale entries on some Zephyr versions.
+        fs_closedir(&_s->dir);
+        fs_dir_t_init(&_s->dir);
+        if (fs_opendir(&_s->dir, _s->fullpath) != 0) {
+            _s->valid = false;
+        }
+    }
+
+    bool seek(uint32_t pos)
+    {
+        if (!_s || !_s->valid || _s->is_dir)
+            return false;
+        return fs_seek(&_s->file, (off_t)pos, FS_SEEK_SET) == 0;
+    }
+
+    int available()
+    {
+        if (!_s || !_s->valid || _s->is_dir)
+            return 0;
+        off_t pos = fs_tell(&_s->file);
+        if (pos < 0)
+            return 0;
+        struct fs_dirent entry;
+        if (fs_stat(_s->fullpath, &entry) != 0)
+            return 0;
+        long rem = (long)entry.size - (long)pos;
+        return rem > 0 ? (int)rem : 0;
+    }
+
+    int peek() { return -1; }
+
+    // Internal: constructed by InternalFileSystem and openNextFile()
+    explicit File(std::shared_ptr<NRF54L15FileState> s) : _s(std::move(s)) {}
+
+  private:
+    std::shared_ptr<NRF54L15FileState> _s;
+};
+
+// ── InternalFileSystem ────────────────────────────────────────────────────
+
+class InternalFileSystem
+{
+  public:
+    bool begin();
+    File open(const char *path, const char *mode);
+    bool exists(const char *path);
+    bool remove(const char *path);
+    bool rename(const char *from, const char *to);
+    bool mkdir(const char *path);
+    bool rmdir(const char *path);
+    bool rmdir_r(const char *path); // recursive delete (used by FSCommon rmDir)
+    uint32_t usedBytes()
+    {
+        struct fs_statvfs st = {};
+        if (fs_statvfs(NRF54L15_FS_MOUNT, &st) != 0)
+            return 0;
+        // Zephyr returns block counts; convert to bytes. f_frsize is the
+        // fundamental fragment size (LittleFS reports it equal to the block
+        // size). used = (total - free) * frag_size.
+        if (st.f_blocks <= st.f_bfree)
+            return 0;
+        return (uint32_t)((st.f_blocks - st.f_bfree) * st.f_frsize);
+    }
+    uint32_t totalBytes() { return (uint32_t)FIXED_PARTITION_SIZE(storage_partition); }
+    bool format();
+
+    // Convert a FS-root-relative path to an absolute Zephyr path.
+    static void toabs(const char *rel, char *abs, size_t abssz);
+
+  private:
+    bool _mounted = false;
+};
+
+} // namespace Adafruit_LittleFS_Namespace
+
+extern Adafruit_LittleFS_Namespace::InternalFileSystem InternalFS;

src/platform/nrf54l15/NRF52Bluetooth.h

@@ -0,0 +1,18 @@
+// NRF52Bluetooth.h — stub for nRF54L15/Zephyr
+// main.h includes this when ARCH_NRF52 is defined.
+// Bluetooth is excluded (MESHTASTIC_EXCLUDE_BLUETOOTH=1); this satisfies the
+// include chain without pulling in the nRF52 Bluefruit SDK.
+#pragma once
+
+class NRF52Bluetooth
+{
+  public:
+    void setup() {}
+    void shutdown() {}
+    void startDisabled() {}
+    void resumeAdvertising() {}
+    void clearBonds() {}
+    bool isConnected() { return false; }
+    int getRssi() { return 0; }
+    void sendLog(const uint8_t *, size_t) {}
+};

src/platform/nrf54l15/NRF54L15Bluetooth.cpp

@@ -0,0 +1,805 @@
+// NRF54L15Bluetooth.cpp — Zephyr BLE GATT peripheral for Meshtastic nRF54L15
+//
+// GATT profile (identical UUIDs to the nRF52 / NimBLE implementations):
+//   Service:   6ba1b218-15a8-461f-9fa8-5dcae273eafd
+//   fromNum:   ed9da18c-a800-4f66-a670-aa7547e34453  READ | NOTIFY
+//   fromRadio: 2c55e69e-4993-11ed-b878-0242ac120002  READ
+//   toRadio:   f75c76d2-129e-4dad-a1dd-7866124401e7  WRITE
+//   logRadio:  5a3d6e49-06e6-4423-9944-e9de8cdf9547  READ | NOTIFY | INDICATE
+//
+// Threading model:
+//   - BT RX thread: connected_cb / disconnected_cb / GATT read_/write_
+//   callbacks
+//   - Meshtastic OSThread scheduler (cooperative, main thread):
+//   BleDeferredThread
+//     polls pendingToRadio and runs the zombie-connection watchdog every 100 ms
+//   - PhoneAPI::onNowHasData: sends fromNum notify synchronously from whichever
+//     thread pushed the packet (bt_gatt_notify is thread-safe in Zephyr)
+//   - active_conn protected by ble_mutex where needed
+
+#include "NRF54L15Bluetooth.h"
+#include "BluetoothCommon.h"
+#include "BluetoothStatus.h"
+#include "PowerFSM.h"
+#include "concurrency/OSThread.h"
+#include "configuration.h"
+#include "main.h"
+#include "mesh/PhoneAPI.h"
+#include "mesh/mesh-pb-constants.h"
+
+#include <zephyr/bluetooth/bluetooth.h>
+#include <zephyr/bluetooth/conn.h>
+#include <zephyr/bluetooth/gatt.h>
+#include <zephyr/bluetooth/hci.h>
+#include <zephyr/bluetooth/uuid.h>
+#include <zephyr/kernel.h>
+#include <zephyr/settings/settings.h>
+#include <zephyr/sys/reboot.h>
+
+// ── UUID definitions (little-endian per Bluetooth spec)
+// ─────────────────────── Syntax: replace hyphens with commas, prefix 0x —
+// matches BT_UUID_128_ENCODE doc.
+
+#define MESH_SVC_UUID_VAL BT_UUID_128_ENCODE(0x6ba1b218, 0x15a8, 0x461f, 0x9fa8, 0x5dcae273eafd)
+#define FROMNUM_UUID_VAL BT_UUID_128_ENCODE(0xed9da18c, 0xa800, 0x4f66, 0xa670, 0xaa7547e34453)
+#define FROMRADIO_UUID_VAL BT_UUID_128_ENCODE(0x2c55e69e, 0x4993, 0x11ed, 0xb878, 0x0242ac120002)
+#define TORADIO_UUID_VAL BT_UUID_128_ENCODE(0xf75c76d2, 0x129e, 0x4dad, 0xa1dd, 0x7866124401e7)
+#define LOGRADIO_UUID_VAL BT_UUID_128_ENCODE(0x5a3d6e49, 0x06e6, 0x4423, 0x9944, 0xe9de8cdf9547)
+
+static const struct bt_uuid_128 mesh_svc_uuid = BT_UUID_INIT_128(MESH_SVC_UUID_VAL);
+static const struct bt_uuid_128 fromnum_uuid = BT_UUID_INIT_128(FROMNUM_UUID_VAL);
+static const struct bt_uuid_128 fromradio_uuid = BT_UUID_INIT_128(FROMRADIO_UUID_VAL);
+static const struct bt_uuid_128 toradio_uuid = BT_UUID_INIT_128(TORADIO_UUID_VAL);
+static const struct bt_uuid_128 logradio_uuid = BT_UUID_INIT_128(LOGRADIO_UUID_VAL);
+
+// ── Module state ─────────────────────────────────────────────────────────────
+
+static struct bt_conn *active_conn = nullptr;
+static K_MUTEX_DEFINE(ble_mutex);
+
+// Take a reference to active_conn under ble_mutex. Returns nullptr if there is
+// no active connection. Caller MUST bt_conn_unref() when done.
+//
+// Reading `active_conn` outside this lock races with disconnected_cb which can
+// unref + null it on the BT RX thread — touching the freed pointer (even just
+// to bt_conn_ref it) is a use-after-free.
+static struct bt_conn *acquire_active_conn()
+{
+    struct bt_conn *conn = nullptr;
+    k_mutex_lock(&ble_mutex, K_FOREVER);
+    if (active_conn) {
+        conn = bt_conn_ref(active_conn);
+    }
+    k_mutex_unlock(&ble_mutex);
+    return conn;
+}
+
+static bool bt_initialized = false; // bt_enable() called at most once
+static bool ble_enabled = false;    // set by setup(), cleared by shutdown()
+
+// Forward declarations — BT_GATT_SERVICE_DEFINE(mesh_svc, ...) is below, but
+// read_fromradio() (defined earlier) needs to reference the service to notify
+// on fromNum after each non-empty read.
+#define FROMNUM_ATTR_IDX 2
+#define LOGRADIO_ATTR_IDX 9
+extern const struct bt_gatt_service_static mesh_svc;
+
+static void start_advertising(); // forward declaration (defined in advertising
+                                 // section below)
+
+// Work item for advertising restart after disconnect.
+//
+// disconnected_cb runs on the BT RX thread (the same thread that processes
+// HCI Command Complete events).  Calling bt_le_adv_start() →
+// bt_hci_cmd_send_sync() directly from that thread deadlocks: the thread blocks
+// on k_sem_take waiting for Command Complete, but it is the very thread that
+// would process it. After 10 s the host panics with "Controller unresponsive,
+// opcode 0x2006 timeout".
+//
+// Fix: submit a k_work item.  The system workqueue runs bt_adv_restart_work_fn
+// on its own thread → no deadlock.
+static struct k_work adv_restart_work;
+
+static void adv_restart_work_fn(struct k_work *work)
+{
+    if (ble_enabled) {
+        start_advertising();
+    }
+}
+
+// CCC state: 0=off, BT_GATT_CCC_NOTIFY=notify, BT_GATT_CCC_INDICATE=indicate
+static uint16_t fromnum_ccc_val = 0;
+static uint16_t logradio_ccc_val = 0;
+
+// Scratch buffers — only one BLE operation at a time
+static uint8_t fromRadioBytes[meshtastic_FromRadio_size];
+static size_t fromRadioLen = 0;
+static uint8_t toRadioBytes[meshtastic_ToRadio_size];
+static uint8_t lastToRadio[MAX_TO_FROM_RADIO_SIZE];
+static uint32_t fromNumValue = 0;
+
+// Deferred ToRadio processing
+//
+// write_toradio() runs on the BT RX workqueue thread (6 KB stack).  Calling
+// phoneAPI->handleToRadio() directly triggers handleStartConfig →
+// getFiles("/", 10) → nanopb encode, which overflows the stack on the exact
+// "Client wants config" write.  Instead we copy the payload into a pending
+// buffer under a mutex and let BleDeferredThread (running on the Meshtastic
+// OSThread scheduler, 24 KB stack) do the actual call outside the lock.
+//
+// The mutex makes the producer/consumer handoff race-free — producer may
+// overwrite a pending buffer the consumer hasn't read yet (dropped packet),
+// but partial reads / torn writes are impossible.
+K_MUTEX_DEFINE(pendingToRadioMutex);
+static uint8_t pendingToRadioBuf[MAX_TO_FROM_RADIO_SIZE];
+static size_t pendingToRadioLen = 0;
+static bool pendingToRadio = false;
+
+// Zombie-connection watchdog state.
+//
+// The nRF54L15 Zephyr 4.2.1 SW-LL occasionally fails to forward an
+// LE Disconnection Complete event to the host: when iOS tears down the link
+// (either explicitly by the user or via supervision timeout), the LL layer
+// drops the connection but disconnected_cb never fires, active_conn stays
+// non-null and advertising never restarts — the device vanishes from scans
+// until power cycle.  Track the connected timestamp and the last time we
+// observed ATT traffic; a long ATT idle on an "active" connection means we
+// are zombied.  A cold reboot is the only path that reliably recovers (any
+// bt_hci_cmd_send_sync after this state, e.g. bt_le_adv_start or
+// bt_conn_disconnect, hangs in k_sem_take and later panics with "Controller
+// unresponsive, opcode 0x2006 timeout").
+static uint32_t connect_time_ms = 0;
+static uint32_t last_att_time_ms = 0;
+
+// ── BluetoothPhoneAPI
+// ─────────────────────────────────────────────────────────
+
+class BluetoothPhoneAPI : public PhoneAPI
+{
+    virtual void onNowHasData(uint32_t fromRadioNum) override;
+    virtual bool checkIsConnected() override;
+
+  public:
+    BluetoothPhoneAPI() { api_type = TYPE_BLE; }
+};
+
+static BluetoothPhoneAPI *phoneAPI = nullptr;
+
+// ── CCC change callbacks
+// ──────────────────────────────────────────────────────
+
+static void fromnum_ccc_changed(const struct bt_gatt_attr *attr, uint16_t value)
+{
+    fromnum_ccc_val = value;
+    LOG_INFO("BLE fromNum CCC: %u", value);
+}
+
+static void logradio_ccc_changed(const struct bt_gatt_attr *attr, uint16_t value)
+{
+    logradio_ccc_val = value;
+    LOG_INFO("BLE logRadio CCC: %u", value);
+}
+
+// ── GATT attribute callbacks
+// ──────────────────────────────────────────────────
+
+static ssize_t read_fromnum(struct bt_conn *conn, const struct bt_gatt_attr *attr, void *buf, uint16_t len, uint16_t offset)
+{
+    LOG_INFO("GATT read_fromnum: fromNum=%u offset=%u", fromNumValue, offset);
+    return bt_gatt_attr_read(conn, attr, buf, len, offset, &fromNumValue, sizeof(fromNumValue));
+}
+
+static ssize_t read_fromradio(struct bt_conn *conn, const struct bt_gatt_attr *attr, void *buf, uint16_t len, uint16_t offset)
+{
+    if (offset == 0) {
+        // First chunk: pull the next packet from the queue.
+        // Subsequent chunks (offset > 0) are ATT_READ_BLOB continuations of the
+        // same value and must reuse fromRadioBytes untouched.
+        fromRadioLen = phoneAPI ? phoneAPI->getFromRadio(fromRadioBytes) : 0;
+        LOG_DEBUG("GATT read_fromradio len=%u", (unsigned)fromRadioLen);
+    }
+    last_att_time_ms = k_uptime_get_32();
+    return bt_gatt_attr_read(conn, attr, buf, len, offset, fromRadioBytes, fromRadioLen);
+}
+
+static ssize_t read_logradio(struct bt_conn *conn, const struct bt_gatt_attr *attr, void *buf, uint16_t len, uint16_t offset)
+{
+    // logRadio is write-only from the device side (notify/indicate).
+    // Return an empty read so GATT discovery doesn't fail with NOT_PERMITTED.
+    return bt_gatt_attr_read(conn, attr, buf, len, offset, NULL, 0);
+}
+
+static ssize_t write_toradio(struct bt_conn *conn, const struct bt_gatt_attr *attr, const void *buf, uint16_t len,
+                             uint16_t offset, uint8_t flags)
+{
+    // Writes >MTU-3 arrive here with offset=0 and
+    // flags=BT_GATT_WRITE_FLAG_EXECUTE after Zephyr reassembles the ATT Prepare
+    // Write fragments (CONFIG_BT_ATT_PREPARE_COUNT>0).  Single writes arrive with
+    // flags=0.
+    LOG_DEBUG("GATT write_toradio len=%u flags=0x%x", len, flags);
+    if (offset != 0) {
+        return BT_GATT_ERR(BT_ATT_ERR_INVALID_OFFSET);
+    }
+    // Reject any write that won't fit in the dedup buffer (lastToRadio) or the
+    // pending handoff buffer (pendingToRadioBuf), both sized
+    // MAX_TO_FROM_RADIO_SIZE. Returning success while silently dropping a
+    // payload would let the phone believe a config write was applied.
+    if (len > sizeof(toRadioBytes) || len > MAX_TO_FROM_RADIO_SIZE) {
+        return BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
+    }
+
+    // Deduplicate — drop packet if identical to the last one we processed
+    if (memcmp(lastToRadio, buf, len) != 0) {
+        memcpy(lastToRadio, buf, len);
+        if (len < MAX_TO_FROM_RADIO_SIZE) {
+            memset(lastToRadio + len, 0, MAX_TO_FROM_RADIO_SIZE - len);
+        }
+        // Defer handleToRadio() to BleDeferredThread (24 KB stack).
+        // Running it here on bt_workq (6 KB) overflows during handleStartConfig.
+        // Always overwrite pending — we already dedup'd above via lastToRadio,
+        // so any new write here is genuinely new data that must be delivered.
+        k_mutex_lock(&pendingToRadioMutex, K_FOREVER);
+        memcpy(pendingToRadioBuf, buf, len);
+        pendingToRadioLen = len;
+        pendingToRadio = true;
+        k_mutex_unlock(&pendingToRadioMutex);
+    }
+    last_att_time_ms = k_uptime_get_32();
+    return (ssize_t)len;
+}
+
+// ── GATT service definition (static, linked at compile time)
+// ──────────────────
+//
+// Attribute indices (0-based):
+//   [0]  Primary Service declaration
+//   [1]  fromNum characteristic declaration
+//   [2]  fromNum value            ← notify target (FROMNUM_ATTR_IDX)
+//   [3]  fromNum CCC descriptor
+//   [4]  fromRadio characteristic declaration
+//   [5]  fromRadio value
+//   [6]  toRadio characteristic declaration
+//   [7]  toRadio value
+//   [8]  logRadio characteristic declaration
+//   [9]  logRadio value           ← notify target (LOGRADIO_ATTR_IDX)
+//   [10] logRadio CCC descriptor
+
+// All user characteristics require authenticated encryption (MITM passkey)
+// before the client can read/write. This mirrors the nrf52
+// SECMODE_ENC_WITH_MITM service permission. The stack returns "Insufficient
+// Authentication" on the first access attempt, prompting the client to pair
+// with the configured PIN.
+#define MESH_PERM_READ (BT_GATT_PERM_READ | BT_GATT_PERM_READ_AUTHEN)
+#define MESH_PERM_WRITE (BT_GATT_PERM_WRITE | BT_GATT_PERM_WRITE_AUTHEN)
+
+BT_GATT_SERVICE_DEFINE(mesh_svc, BT_GATT_PRIMARY_SERVICE(&mesh_svc_uuid.uuid),
+
+                       // fromNum: READ | NOTIFY — packet-counter triggers phone to read fromRadio
+                       BT_GATT_CHARACTERISTIC(&fromnum_uuid.uuid, BT_GATT_CHRC_READ | BT_GATT_CHRC_NOTIFY, MESH_PERM_READ,
+                                              read_fromnum, NULL, &fromNumValue),
+                       BT_GATT_CCC(fromnum_ccc_changed, MESH_PERM_READ | MESH_PERM_WRITE),
+
+                       // fromRadio: READ — phone polls this after receiving a fromNum notification
+                       BT_GATT_CHARACTERISTIC(&fromradio_uuid.uuid, BT_GATT_CHRC_READ, MESH_PERM_READ, read_fromradio, NULL,
+                                              NULL),
+
+                       // toRadio: WRITE — phone sends protobuf packets to the device
+                       BT_GATT_CHARACTERISTIC(&toradio_uuid.uuid, BT_GATT_CHRC_WRITE, MESH_PERM_WRITE, NULL, write_toradio, NULL),
+
+                       // logRadio: READ | NOTIFY | INDICATE — log stream to phone when connected
+                       BT_GATT_CHARACTERISTIC(&logradio_uuid.uuid,
+                                              BT_GATT_CHRC_READ | BT_GATT_CHRC_NOTIFY | BT_GATT_CHRC_INDICATE, MESH_PERM_READ,
+                                              read_logradio, NULL, NULL),
+                       BT_GATT_CCC(logradio_ccc_changed, MESH_PERM_READ | MESH_PERM_WRITE), );
+
+// ── Advertising
+// ───────────────────────────────────────────────────────────────
+//
+// Use legacy advertising (bt_le_adv_start / HCI 0x2006 path).
+//
+// History: we previously used bt_le_ext_adv_create (true extended advertising)
+// because bt_le_adv_start() with CONFIG_BT_EXT_ADV=y was translated internally
+// to the extended HCI path with LEGACY-bit (0x2036), which produced
+// non-connectable PDUs on the nRF54L15 SW-LL.  The true extended path
+// (0x203x, AUX_ADV_IND) was connectable but caused two problems:
+//   1. iOS CoreBluetooth does not reliably complete GATT after connecting via
+//      extended advertising (zero ATT PDUs observed in all test sessions).
+//   2. After each connection the controller auto-stops the advertising set, and
+//      the subsequent bt_le_ext_adv_delete() sends LE Remove Advertising Set
+//      (0x203c) which times out → kernel oops at hci_core.c:506.
+//
+// With CONFIG_BT_EXT_ADV=n the host uses pure legacy HCI commands — the same
+// path Nordic NCS uses in all nRF54L15 examples (peripheral_uart,
+// peripheral_lbs) and which is universally iOS-compatible.  The legacy data
+// payload is 31 bytes:
+//   FLAGS (3B) + UUID128 (18B) = 21B in adv; NAME in scan-response (17B).
+
+static void start_advertising()
+{
+    // IMPORTANT: BT_DATA_BYTES() uses C99 compound literals that GCC C++ treats
+    // as temporaries; with -Os the compiler may elide writes, leaving stack
+    // uninitialized.  Use static const arrays for stable data (flags, UUID)
+    // and a runtime pointer for the dynamic device name.
+    static const uint8_t adv_flags_val[] = {BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR};
+    static const uint8_t adv_uuid128_val[] = {MESH_SVC_UUID_VAL};
+
+    const char *name = bt_get_name();
+    size_t full_name_len = strlen(name);
+
+    // Legacy scan-response payload is 31 bytes total. Each AD entry costs 2
+    // bytes (length + type), leaving 29 bytes for the name. With
+    // CONFIG_BT_DEVICE_NAME_MAX=32 the name can exceed that — truncate and
+    // mark as SHORTENED so bt_le_adv_start() doesn't reject the payload.
+    constexpr size_t LEGACY_SCAN_RSP_NAME_MAX = 31 - 2;
+    bool name_shortened = full_name_len > LEGACY_SCAN_RSP_NAME_MAX;
+    uint8_t name_len = (uint8_t)(name_shortened ? LEGACY_SCAN_RSP_NAME_MAX : full_name_len);
+
+    // Primary advertising data: FLAGS + Meshtastic service UUID128 (21 bytes
+    // total)
+    struct bt_data ad[] = {
+        {BT_DATA_FLAGS, sizeof(adv_flags_val), adv_flags_val},
+        {BT_DATA_UUID128_ALL, sizeof(adv_uuid128_val), adv_uuid128_val},
+    };
+    // Scan response: device name (discovered after scan request)
+    struct bt_data sd[] = {
+        {(uint8_t)(name_shortened ? BT_DATA_NAME_SHORTENED : BT_DATA_NAME_COMPLETE), name_len, (const uint8_t *)name},
+    };
+
+    // BT_LE_ADV_OPT_CONN         = connectable legacy ADV_IND + stops after first
+    //                              connection (replaces deprecated
+    //                              CONNECTABLE|ONE_TIME in Zephyr 4.2.1;
+    //                              BT_LE_ADV_OPT_CONN = BIT(0)|BIT(1))
+    // BT_LE_ADV_OPT_USE_IDENTITY = use static random identity address (stable
+    // across reboots) Advertising restart after disconnect is via
+    // adv_restart_work (system workqueue) so calling bt_le_adv_start() from the
+    // BT RX thread context is avoided.
+    int err = bt_le_adv_start(BT_LE_ADV_PARAM(BT_LE_ADV_OPT_CONN | BT_LE_ADV_OPT_USE_IDENTITY, BT_GAP_ADV_FAST_INT_MIN_2,
+                                              BT_GAP_ADV_FAST_INT_MAX_2, NULL),
+                              ad, ARRAY_SIZE(ad), sd, ARRAY_SIZE(sd));
+
+    if (err == -EALREADY) {
+        return;
+    }
+    if (err) {
+        LOG_WARN("BLE adv start failed: %d", err);
+    } else {
+        LOG_INFO("BLE advertising as '%s'", bt_get_name());
+    }
+}
+
+static void stop_advertising()
+{
+    bt_le_adv_stop();
+}
+
+// ── Connection callbacks
+// ──────────────────────────────────────────────────────
+
+static void connected_cb(struct bt_conn *conn, uint8_t err)
+{
+    if (err) {
+        LOG_WARN("BLE connection failed, err=0x%02x", err);
+        return;
+    }
+
+    k_mutex_lock(&ble_mutex, K_FOREVER);
+    active_conn = bt_conn_ref(conn);
+    k_mutex_unlock(&ble_mutex);
+
+    memset(lastToRadio, 0, sizeof(lastToRadio));
+    connect_time_ms = k_uptime_get_32();
+    last_att_time_ms = connect_time_ms;
+
+    char addr[BT_ADDR_LE_STR_LEN];
+    bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
+    LOG_INFO("BLE connected: %s", addr);
+
+    meshtastic::BluetoothStatus newStatus(meshtastic::BluetoothStatus::ConnectionState::CONNECTED);
+    bluetoothStatus->updateStatus(&newStatus);
+
+    // nRF54L15-DK has no screen — cannot display a PIN to the user.
+    // Requesting BT_SECURITY_L2 causes the OS to show a pairing dialog that
+    // the user dismisses, triggering disconnect + advertising restart failure.
+    // Skip security negotiation; the Meshtastic app works over plain GATT.
+    // (Security can be re-enabled once a display or NFC OOB path is available.)
+}
+
+static void disconnected_cb(struct bt_conn *conn, uint8_t reason)
+{
+    LOG_INFO("BLE disconnected, reason=0x%02x", reason);
+
+    k_mutex_lock(&ble_mutex, K_FOREVER);
+    if (active_conn) {
+        bt_conn_unref(active_conn);
+        active_conn = nullptr;
+    }
+    k_mutex_unlock(&ble_mutex);
+
+    fromnum_ccc_val = 0;
+    logradio_ccc_val = 0;
+    connect_time_ms = 0;
+    last_att_time_ms = 0;
+
+    if (phoneAPI) {
+        phoneAPI->close();
+    }
+    memset(lastToRadio, 0, sizeof(lastToRadio));
+
+    meshtastic::BluetoothStatus newStatus(meshtastic::BluetoothStatus::ConnectionState::DISCONNECTED);
+    bluetoothStatus->updateStatus(&newStatus);
+
+    // Schedule advertising restart via work queue — NOT from this callback
+    // directly. disconnected_cb runs on the BT RX thread; calling
+    // bt_le_adv_start() here would deadlock (see adv_restart_work comment above).
+    if (ble_enabled) {
+        k_work_submit(&adv_restart_work);
+    }
+}
+
+#if defined(CONFIG_BT_SMP)
+static void security_changed_cb(struct bt_conn *conn, bt_security_t level, enum bt_security_err err)
+{
+    if (err == BT_SECURITY_ERR_PIN_OR_KEY_MISSING) {
+        // Phone has a stale bond (device was wiped/reflashed).  Unpair the stale
+        // entry so the phone re-pairs cleanly on the next connection attempt.
+        LOG_WARN("BLE stale bond detected (key missing) — unpairing");
+        bt_unpair(BT_ID_DEFAULT, bt_conn_get_dst(conn));
+        bt_conn_disconnect(conn, BT_HCI_ERR_AUTH_FAIL);
+    } else if (err) {
+        LOG_WARN("BLE security change failed: level=%d err=%d", (int)level, (int)err);
+    } else {
+        LOG_INFO("BLE security level %d established", (int)level);
+    }
+}
+#endif /* CONFIG_BT_SMP */
+
+BT_CONN_CB_DEFINE(conn_callbacks) = {
+    .connected = connected_cb,
+    .disconnected = disconnected_cb,
+#if defined(CONFIG_BT_SMP)
+    .security_changed = security_changed_cb,
+#endif
+};
+
+// ── Pairing / auth callbacks
+// ──────────────────────────────────────────────────
+
+#if defined(CONFIG_BT_SMP)
+static uint32_t configuredPasskey;
+
+static void auth_passkey_display(struct bt_conn *conn, unsigned int passkey)
+{
+    char passkey_str[7];
+    snprintf(passkey_str, sizeof(passkey_str), "%06u", passkey);
+    configuredPasskey = passkey;
+    LOG_INFO("BLE pairing PIN: %s", passkey_str);
+    powerFSM.trigger(EVENT_BLUETOOTH_PAIR);
+
+    std::string textkey(passkey_str);
+    meshtastic::BluetoothStatus pairingStatus(textkey);
+    bluetoothStatus->updateStatus(&pairingStatus);
+}
+
+static void auth_cancel(struct bt_conn *conn)
+{
+    LOG_WARN("BLE pairing cancelled");
+}
+
+static struct bt_conn_auth_cb auth_cb = {
+    .passkey_display = auth_passkey_display,
+    .passkey_entry = NULL,
+    .cancel = auth_cancel,
+};
+
+static void pairing_complete_cb(struct bt_conn *conn, bool bonded)
+{
+    LOG_INFO("BLE pairing complete, bonded=%d", (int)bonded);
+    meshtastic::BluetoothStatus newStatus(meshtastic::BluetoothStatus::ConnectionState::CONNECTED);
+    bluetoothStatus->updateStatus(&newStatus);
+}
+
+static void pairing_failed_cb(struct bt_conn *conn, enum bt_security_err reason)
+{
+    LOG_WARN("BLE pairing failed, reason=%d", (int)reason);
+    meshtastic::BluetoothStatus newStatus(meshtastic::BluetoothStatus::ConnectionState::DISCONNECTED);
+    bluetoothStatus->updateStatus(&newStatus);
+}
+
+static struct bt_conn_auth_info_cb auth_info_cb = {
+    .pairing_complete = pairing_complete_cb,
+    .pairing_failed = pairing_failed_cb,
+};
+#endif /* CONFIG_BT_SMP */
+
+// ── BluetoothPhoneAPI methods
+// ─────────────────────────────────────────────────
+
+void BluetoothPhoneAPI::onNowHasData(uint32_t fromRadioNum)
+{
+    PhoneAPI::onNowHasData(fromRadioNum);
+    fromNumValue = fromRadioNum;
+
+    if (!(fromnum_ccc_val & BT_GATT_CCC_NOTIFY))
+        return;
+
+    // active_conn may be torn down on another thread while we're dispatching
+    // this notify — acquire under ble_mutex so disconnected_cb can't free the
+    // conn between the null check and bt_conn_ref.
+    struct bt_conn *conn = acquire_active_conn();
+    if (!conn)
+        return;
+    bt_gatt_notify(conn, &mesh_svc.attrs[FROMNUM_ATTR_IDX], &fromNumValue, sizeof(fromNumValue));
+    bt_conn_unref(conn);
+}
+
+bool BluetoothPhoneAPI::checkIsConnected()
+{
+    return active_conn != nullptr;
+}
+
+// ── Deferred ToRadio processor + zombie-connection watchdog ──────────────────
+//
+// write_toradio() runs on the BT RX workqueue thread (CONFIG_BT_RX_STACK_SIZE)
+// and cannot execute phoneAPI->handleToRadio() directly: handleStartConfig
+// recurses through nanopb encode + state machine init and overflows the RX
+// stack.  This thread runs on the Meshtastic OSThread scheduler (24 KB stack),
+// picks up the pending ToRadio buffer flagged by write_toradio(), and calls
+// handleToRadio() with plenty of headroom.
+//
+// Real-time fromNum notifications are sent synchronously from
+// BluetoothPhoneAPI::onNowHasData() (called by PhoneAPI when new data is
+// queued).
+//
+// Zombie-connection detection has two tiers:
+//
+//   (1) Liveness probe.  After IDLE_BEFORE_PROBE_MS without ATT traffic, send
+//       a bt_gatt_notify to fromNum every PROBE_INTERVAL_MS.  If the
+//       controller replies -ENOTCONN the LL link is definitely dead but the
+//       host didn't forward LE Disconnection Complete → reboot.  We avoid
+//       probing during normal activity so iOS isn't woken up unnecessarily
+//       (each probe wakes iOS → triggers a zero-byte FromRadio drain).
+//
+//   (2) Hard watchdog.  Absolute HARD_WATCHDOG_MS ceiling on ATT idle as a
+//       fallback if probes somehow don't detect the zombie.
+class BleDeferredThread : public concurrency::OSThread
+{
+    static constexpr uint32_t IDLE_BEFORE_PROBE_MS = 30000; //  30 s: start probing
+    static constexpr uint32_t PROBE_INTERVAL_MS = 5000;     //   5 s: between probes
+    static constexpr uint32_t HARD_WATCHDOG_MS = 60000;     //   1 min: last resort
+
+    uint32_t last_probe_ms = 0;
+
+  public:
+    BleDeferredThread() : concurrency::OSThread("BleDeferred") {}
+
+  protected:
+    int32_t runOnce() override
+    {
+        // Snapshot the pending ToRadio buffer under the mutex, then release
+        // the lock before calling into handleToRadio (which can be slow and
+        // must not block the BT RX thread producer).
+        uint8_t buf[MAX_TO_FROM_RADIO_SIZE];
+        size_t n = 0;
+        bool have_pending = false;
+        k_mutex_lock(&pendingToRadioMutex, K_FOREVER);
+        if (pendingToRadio) {
+            memcpy(buf, pendingToRadioBuf, pendingToRadioLen);
+            n = pendingToRadioLen;
+            pendingToRadio = false;
+            have_pending = true;
+        }
+        k_mutex_unlock(&pendingToRadioMutex);
+        if (have_pending && phoneAPI) {
+            phoneAPI->handleToRadio(buf, n);
+        }
+
+        // Take a reference to active_conn so it can't be freed underneath us
+        // if disconnected_cb fires on another thread while we're dispatching.
+        struct bt_conn *conn = acquire_active_conn();
+        if (!conn || connect_time_ms == 0) {
+            if (conn)
+                bt_conn_unref(conn);
+            last_probe_ms = 0;
+            return 100;
+        }
+
+        uint32_t now = k_uptime_get_32();
+        uint32_t att_idle = now - last_att_time_ms;
+
+        // Liveness probe — only when ATT has been quiet for a while.
+        if (att_idle > IDLE_BEFORE_PROBE_MS && (now - last_probe_ms) >= PROBE_INTERVAL_MS &&
+            (fromnum_ccc_val & BT_GATT_CCC_NOTIFY)) {
+            last_probe_ms = now;
+            int err = bt_gatt_notify(conn, &mesh_svc.attrs[FROMNUM_ATTR_IDX], &fromNumValue, sizeof(fromNumValue));
+            if (err == -ENOTCONN) {
+                LOG_WARN("BLE zombie (probe ENOTCONN); rebooting");
+                bt_conn_unref(conn);
+                k_sleep(K_MSEC(50)); // flush log
+                sys_reboot(SYS_REBOOT_COLD);
+            }
+        }
+        bt_conn_unref(conn);
+
+        // Hard ceiling — last-resort reboot if probes miss the zombie.
+        if (att_idle > HARD_WATCHDOG_MS && (now - connect_time_ms) > HARD_WATCHDOG_MS) {
+            LOG_WARN("BLE zombie (hard watchdog %us); rebooting", HARD_WATCHDOG_MS / 1000);
+            k_sleep(K_MSEC(50));
+            sys_reboot(SYS_REBOOT_COLD);
+        }
+        return 100;
+    }
+};
+
+static BleDeferredThread *bleDeferredThread = nullptr;
+
+// ── BT stack pre-initializer (call from main thread before OSThreads start) ──
+//
+// bt_enable() requires substantially more stack than a Meshtastic OSThread
+// (PowerFSMThread) provides — calling it there causes a stack overflow.
+// Call this from nrf54l15Setup() (main Zephyr thread, CONFIG_MAIN_STACK_SIZE)
+// so that by the time NRF54L15Bluetooth::setup() runs from PowerFSMThread,
+// bt_initialized is already true and bt_enable() is skipped.
+
+void nrf54l15_bt_preinit()
+{
+    if (!bt_initialized) {
+        int err = bt_enable(NULL);
+        if (err) {
+            LOG_ERROR("BLE pre-init failed: %d", err);
+            return;
+        }
+        bt_initialized = true;
+        LOG_INFO("BLE stack pre-initialized on main thread");
+
+        // Phase 7: load bonding keys from LittleFS (/lfs/bt_settings).
+        // LittleFS is already mounted by fsInit() before nrf54l15Setup() runs.
+        // On first boot the file doesn't exist — settings_load() returns 0 (OK).
+        // On subsequent boots, previously bonded peers are restored so the
+        // phone can reconnect without re-pairing.
+        err = settings_load();
+        if (err) {
+            LOG_WARN("settings_load failed: %d (OK on first boot)", err);
+        } else {
+            LOG_INFO("BT settings loaded from /lfs/bt_settings");
+        }
+    }
+}
+
+// ── NRF54L15Bluetooth public methods ─────────────────────────────────────────
+
+// Shared init: idempotent setup of work item, OSThread, auth callbacks,
+// bt_enable, and device name. Leaves advertising control to the caller.
+static bool nrf54l15_bt_init_common()
+{
+    k_work_init(&adv_restart_work, adv_restart_work_fn);
+
+    if (!bleDeferredThread) {
+        bleDeferredThread = new BleDeferredThread();
+    }
+
+    if (!phoneAPI) {
+        phoneAPI = new BluetoothPhoneAPI();
+    }
+
+#if defined(CONFIG_BT_SMP)
+    // NO_PIN is unsupported on this platform: the mesh GATT permissions are
+    // declared with BT_GATT_PERM_*_AUTHEN, prj.conf sets
+    // CONFIG_BT_SMP_ENFORCE_MITM=y, and the build pulls in the SMP/passkey path.
+    // If a user requested NO_PIN we'd register no auth callbacks → no display
+    // path for the passkey → every GATT access returns BT_ATT_ERR_AUTHENTICATION
+    // and the link is unusable. Fall back to RANDOM_PIN behavior with a warning
+    // instead of leaving BLE silently broken.
+    if (config.bluetooth.mode == meshtastic_Config_BluetoothConfig_PairingMode_NO_PIN) {
+        LOG_WARN("BLE: NO_PIN not supported on nRF54L15-DK (MITM-only build); "
+                 "treating as RANDOM_PIN");
+    }
+
+    bt_conn_auth_cb_register(&auth_cb);
+    bt_conn_auth_info_cb_register(&auth_info_cb);
+
+    // FIXED_PIN — register the configured passkey so the mobile app prompts
+    // the user for that specific number instead of a random display-only PIN.
+    // RANDOM_PIN (and clamped NO_PIN) keeps the default behavior: Zephyr
+    // generates a fresh passkey on each pairing attempt and fires
+    // auth_passkey_display with it.
+    if (config.bluetooth.mode == meshtastic_Config_BluetoothConfig_PairingMode_FIXED_PIN) {
+        configuredPasskey = config.bluetooth.fixed_pin;
+        int rc = bt_passkey_set(configuredPasskey);
+        if (rc) {
+            LOG_WARN("bt_passkey_set(%u) failed: %d", configuredPasskey, rc);
+        } else {
+            LOG_INFO("BLE fixed PIN: %06u", configuredPasskey);
+        }
+    } else {
+        bt_passkey_set(BT_PASSKEY_INVALID); // random per-pair
+    }
+#endif /* CONFIG_BT_SMP */
+
+    if (!bt_initialized) {
+        int err = bt_enable(NULL);
+        if (err) {
+            LOG_ERROR("BLE enable failed: %d", err);
+            return false;
+        }
+        bt_initialized = true;
+        LOG_INFO("BLE stack enabled");
+    }
+
+    bt_set_name(getDeviceName());
+    return true;
+}
+
+void NRF54L15Bluetooth::setup()
+{
+    LOG_INFO("NRF54L15Bluetooth::setup()");
+    if (!nrf54l15_bt_init_common()) {
+        return;
+    }
+    ble_enabled = true;
+    start_advertising();
+}
+
+void NRF54L15Bluetooth::shutdown()
+{
+    LOG_INFO("NRF54L15Bluetooth::shutdown()");
+    ble_enabled = false;
+    stop_advertising();
+
+    struct bt_conn *conn = acquire_active_conn();
+    if (conn) {
+        bt_conn_disconnect(conn, BT_HCI_ERR_REMOTE_USER_TERM_CONN);
+        bt_conn_unref(conn);
+    }
+}
+
+void NRF54L15Bluetooth::startDisabled()
+{
+    // Initialize BT stack but leave advertising off until resumeAdvertising().
+    if (!nrf54l15_bt_init_common()) {
+        return;
+    }
+    ble_enabled = false;
+    LOG_INFO("BLE initialized, advertising stopped (startDisabled)");
+}
+
+void NRF54L15Bluetooth::resumeAdvertising()
+{
+    ble_enabled = true;
+    start_advertising();
+}
+
+void NRF54L15Bluetooth::clearBonds()
+{
+    LOG_INFO("BLE clear bonds");
+    bt_unpair(BT_ID_DEFAULT, BT_ADDR_LE_ANY);
+}
+
+bool NRF54L15Bluetooth::isConnected()
+{
+    return active_conn != nullptr;
+}
+
+int NRF54L15Bluetooth::getRssi()
+{
+    return 0; // TODO: Zephyr has no direct bt_conn_get_rssi; use HCI RSSI read
+              // command
+}
+
+void NRF54L15Bluetooth::sendLog(const uint8_t *logMessage, size_t length)
+{
+    if (length > 512 || logradio_ccc_val == 0) {
+        return;
+    }
+    // Acquire a reference under ble_mutex so disconnected_cb can't free the
+    // connection between the null check and bt_gatt_notify.
+    struct bt_conn *conn = acquire_active_conn();
+    if (!conn) {
+        return;
+    }
+    // Send as notify regardless of whether client subscribed to NOTIFY or
+    // INDICATE — bt_gatt_indicate() requires a params struct with a callback;
+    // notify is simpler and the app accepts both. Change to indicate if
+    // compatibility issues arise.
+    bt_gatt_notify(conn, &mesh_svc.attrs[LOGRADIO_ATTR_IDX], logMessage, (uint16_t)length);
+    bt_conn_unref(conn);
+}

src/platform/nrf54l15/NRF54L15Bluetooth.h

@@ -0,0 +1,29 @@
+// NRF54L15Bluetooth.h — Zephyr BLE backend for nRF54L15
+//
+// Implements the same interface as NRF52Bluetooth (same method names and
+// signatures) so main.cpp and AdminModule can use nrf52Bluetooth pointer
+// without knowing the underlying implementation.
+//
+// GATT profile is identical to the nRF52 implementation:
+//   Service:   MESH_SERVICE_UUID
+//   toRadio:   TORADIO_UUID   (WRITE)
+//   fromRadio: FROMRADIO_UUID (READ)
+//   fromNum:   FROMNUM_UUID   (READ | NOTIFY)
+//   logRadio:  LOGRADIO_UUID  (READ | NOTIFY | INDICATE)
+
+#pragma once
+
+#include "BluetoothCommon.h"
+
+class NRF54L15Bluetooth : public BluetoothApi
+{
+  public:
+    void setup();
+    void shutdown();
+    void startDisabled();
+    void resumeAdvertising();
+    void clearBonds();
+    bool isConnected();
+    int getRssi();
+    void sendLog(const uint8_t *logMessage, size_t length);
+};

src/platform/nrf54l15/Nrf52SaadcLock.h

@@ -0,0 +1,17 @@
+// Nrf52SaadcLock.h — stub for nRF54L15/Zephyr
+// Power.cpp includes this when ARCH_NRF52 is defined.
+// Phase 2: compile-only stub.
+#pragma once
+
+#ifdef ARCH_NRF52
+
+#include "concurrency/Lock.h"
+
+namespace concurrency
+{
+/** Shared mutex for SAADC configuration and reads (VDD + battery analog path).
+ *  On nRF54L15 ADC is handled differently; this is a compile-only stub. */
+extern Lock *nrf52SaadcLock;
+} // namespace concurrency
+
+#endif

src/platform/nrf54l15/Print.h

@@ -0,0 +1,4 @@
+// Print.h — shim for nRF54L15/Zephyr
+// Meshtastic includes <Print.h> separately; redirect to our Arduino.h shim.
+#pragma once
+#include "Arduino.h"

src/platform/nrf54l15/SPI.h

@@ -0,0 +1,62 @@
+/**
+ * SPI.h — Arduino SPI shim for Zephyr/nRF54L15
+ *
+ * Provides the Arduino SPIClass interface backed by Zephyr's SPI API. The
+ * backing controller is SPIM00 (HP domain, 3.0 V); the implementation in
+ * nrf54l15_arduino.cpp binds to DEVICE_DT_GET(DT_NODELABEL(spi00)) and the
+ * bus is configured in zephyr/boards/nrf54l15dk_nrf54l15_cpuapp.overlay.
+ * RadioLib uses ArduinoHal which calls transfer() byte-by-byte.
+ *
+ * CS pin is handled by RadioLib via digitalWrite() — hardware CS is not used.
+ */
+
+#pragma once
+
+#include "Arduino.h"
+#include <stdint.h>
+
+#define SPI_MODE0 0
+#define SPI_MODE1 1
+#define SPI_MODE2 2
+#define SPI_MODE3 3
+
+struct SPISettings {
+    uint32_t clock;
+    uint8_t bitOrder;
+    uint8_t dataMode;
+
+    // Arduino API allows `SPI.beginTransaction(SPISettings(8000000, MSBFIRST, SPI_MODE0))` — implicit form is intentional.
+    // cppcheck-suppress noExplicitConstructor
+    SPISettings(uint32_t clock = 4000000, uint8_t bitOrder = MSBFIRST, uint8_t dataMode = SPI_MODE0)
+        : clock(clock), bitOrder(bitOrder), dataMode(dataMode)
+    {
+    }
+};
+
+class SPIClass
+{
+  public:
+    void begin() {}
+    void begin(uint8_t sck, uint8_t miso, uint8_t mosi, uint8_t ss = 0xFF) {}
+    void end() {}
+    void beginTransaction(SPISettings) {}
+    void endTransaction() {}
+    void setBitOrder(uint8_t order) {}
+    void setDataMode(uint8_t mode) {}
+    void setClockDivider(uint8_t div) {}
+    void setFrequency(uint32_t freq) {}
+
+    // Real Zephyr SPI implementation — defined in nrf54l15_arduino.cpp
+    uint8_t transfer(uint8_t data);
+    uint16_t transfer16(uint16_t data);
+    void transfer(void *buf, size_t count);
+    void transferBytes(const uint8_t *tx, uint8_t *rx, uint32_t count);
+    uint8_t transfer(uint8_t tx, uint8_t *rx, uint32_t count)
+    {
+        transferBytes(&tx, rx, count);
+        return rx ? rx[0] : 0;
+    }
+};
+
+extern SPIClass SPI;
+extern SPIClass SPI1;

src/platform/nrf54l15/Stream.h

@@ -0,0 +1,5 @@
+// Stream.h — shim for nRF54L15/Zephyr
+// StreamAPI.h and other Meshtastic headers include <Stream.h>.
+// Redirect to our Arduino.h shim which defines the Stream base class.
+#pragma once
+#include "Arduino.h"

src/platform/nrf54l15/Tone.h

@@ -0,0 +1,4 @@
+// Tone.h — shim for nRF54L15/Zephyr
+// Tone functions are stubbed in Arduino.h; this header satisfies direct includes.
+#pragma once
+#include "Arduino.h"

src/platform/nrf54l15/WProgram.h

@@ -0,0 +1,5 @@
+// WProgram.h — shim for nRF54L15/Zephyr
+// ArduinoThread (and other legacy Arduino libs) include <WProgram.h>.
+// Redirect to our Arduino.h shim.
+#pragma once
+#include "Arduino.h"

src/platform/nrf54l15/Wire.cpp

@@ -0,0 +1,219 @@
+// Wire.cpp — Arduino TwoWire backed by Zephyr i2c30 (TWIM30 hardware).
+//
+// The pinctrl + clock-frequency are configured in
+// zephyr/boards/nrf54l15dk_nrf54l15_cpuapp.overlay. Runtime begin()/setClock()
+// are best-effort: setClock() goes through i2c_configure() to actually change
+// the bus speed; begin() just verifies the device is ready.
+
+#include "Wire.h"
+#include "configuration.h"
+
+#include <errno.h>
+#include <zephyr/device.h>
+#include <zephyr/drivers/i2c.h>
+#include <zephyr/kernel.h>
+
+// Resolve the i2c30 node at compile time. If the overlay has not enabled
+// i2c30, this evaluates to a NULL device pointer and every call short-circuits
+// to a NACK return code — matching the prior compile-only stub behavior.
+#define I2C_NODE DT_NODELABEL(i2c30)
+
+static const struct device *getI2CDevice()
+{
+#if DT_NODE_HAS_STATUS(I2C_NODE, okay)
+    static const struct device *const dev = DEVICE_DT_GET(I2C_NODE);
+    return dev;
+#else
+    return nullptr;
+#endif
+}
+
+// Wire/Wire1 instances are defined in nrf54l15_arduino.cpp alongside the
+// other Arduino singletons (Serial, SPI, …).
+
+TwoWire::TwoWire() : txAddr(0), txLen(0), txBuf{}, rxLen(0), rxPos(0), rxBuf{} {}
+
+void TwoWire::begin()
+{
+    const struct device *dev = getI2CDevice();
+    if (dev == nullptr) {
+        LOG_WARN("Wire.begin(): i2c30 not enabled in DT overlay");
+        return;
+    }
+    if (!device_is_ready(dev)) {
+        LOG_WARN("Wire.begin(): i2c30 device not ready");
+        return;
+    }
+    LOG_INFO("Wire.begin(): i2c30 ready");
+}
+
+void TwoWire::begin(uint8_t /*sda*/, uint8_t /*scl*/)
+{
+    // SDA/SCL fixed by overlay pinctrl — pin args ignored.
+    begin();
+}
+
+void TwoWire::begin(int /*sda*/, int /*scl*/, uint32_t freq)
+{
+    begin();
+    if (freq) {
+        setClock(freq);
+    }
+}
+
+void TwoWire::end()
+{
+    // No-op: Zephyr i2c devices stay initialized for the lifetime of the
+    // application. Runtime PM (zephyr,pm-device-runtime-auto in the DT)
+    // handles low-power transitions when idle.
+}
+
+void TwoWire::setClock(uint32_t freq)
+{
+    const struct device *dev = getI2CDevice();
+    if (dev == nullptr) {
+        return;
+    }
+    uint32_t speed;
+    if (freq >= 1000000U) {
+        speed = I2C_SPEED_FAST_PLUS; // 1 MHz
+    } else if (freq >= 400000U) {
+        speed = I2C_SPEED_FAST; // 400 kHz
+    } else {
+        speed = I2C_SPEED_STANDARD; // 100 kHz
+    }
+    uint32_t cfg = I2C_MODE_CONTROLLER | I2C_SPEED_SET(speed);
+    int rc = i2c_configure(dev, cfg);
+    if (rc) {
+        LOG_WARN("Wire.setClock(%u) failed: %d", (unsigned)freq, rc);
+    }
+}
+
+void TwoWire::beginTransmission(uint8_t addr)
+{
+    txAddr = addr;
+    txLen = 0;
+}
+
+size_t TwoWire::write(uint8_t data)
+{
+    if (txLen >= WIRE_BUFFER_LENGTH) {
+        return 0; // overflow — endTransmission() will return 1
+    }
+    txBuf[txLen++] = data;
+    return 1;
+}
+
+size_t TwoWire::write(const uint8_t *data, size_t n)
+{
+    size_t written = 0;
+    for (size_t i = 0; i < n; i++) {
+        if (write(data[i]) == 0) {
+            break;
+        }
+        written++;
+    }
+    return written;
+}
+
+uint8_t TwoWire::endTransmission(bool /*stop*/)
+{
+    // Arduino return codes:
+    //   0 = success
+    //   1 = data-too-long (overflow caught in write())
+    //   2 = NACK on address
+    //   3 = NACK on data
+    //   4 = other error
+    //   5 = timeout
+    if (txLen > WIRE_BUFFER_LENGTH) {
+        return 1;
+    }
+    const struct device *dev = getI2CDevice();
+    if (dev == nullptr || !device_is_ready(dev)) {
+        return 4;
+    }
+    int rc = i2c_write(dev, txBuf, txLen, txAddr);
+    txLen = 0;
+    if (rc == 0) {
+        return 0;
+    }
+    if (rc == -EIO) {
+        return 2; // address NACK is the most common -EIO source on nrf-twim
+    }
+    if (rc == -ETIMEDOUT) {
+        return 5;
+    }
+    return 4;
+}
+
+uint8_t TwoWire::requestFrom(uint8_t addr, uint8_t quantity, bool /*stop*/)
+{
+    rxLen = 0;
+    rxPos = 0;
+    if (quantity == 0) {
+        return 0;
+    }
+    if (quantity > WIRE_BUFFER_LENGTH) {
+        quantity = WIRE_BUFFER_LENGTH;
+    }
+    const struct device *dev = getI2CDevice();
+    if (dev == nullptr || !device_is_ready(dev)) {
+        return 0;
+    }
+
+    // If there is a pending TX (driver wrote register address via write()
+    // without an explicit endTransmission()), use i2c_write_read so the
+    // repeated-start path matches the typical "set register pointer then
+    // read N bytes" sensor protocol.
+    int rc;
+    if (txLen > 0) {
+        rc = i2c_write_read(dev, addr, txBuf, txLen, rxBuf, quantity);
+        txLen = 0;
+    } else {
+        rc = i2c_read(dev, rxBuf, quantity, addr);
+    }
+    if (rc) {
+        return 0;
+    }
+    rxLen = quantity;
+    return quantity;
+}
+
+int TwoWire::available()
+{
+    return rxLen - rxPos;
+}
+
+int TwoWire::read()
+{
+    if (rxPos >= rxLen) {
+        return -1;
+    }
+    return rxBuf[rxPos++];
+}
+
+int TwoWire::peek()
+{
+    if (rxPos >= rxLen) {
+        return -1;
+    }
+    return rxBuf[rxPos];
+}
+
+size_t TwoWire::readBytes(uint8_t *buf, size_t len)
+{
+    size_t n = 0;
+    while (n < len) {
+        int b = read();
+        if (b < 0) {
+            break;
+        }
+        buf[n++] = (uint8_t)b;
+    }
+    return n;
+}
+
+TwoWire::operator bool() const
+{
+    return getI2CDevice() != nullptr;
+}

src/platform/nrf54l15/Wire.h

@@ -0,0 +1,83 @@
+/**
+ * Wire.h — Arduino TwoWire (I2C) shim for Zephyr / nRF54L15.
+ *
+ * Bus binding: the Zephyr device tree alias `i2c30` (TWIM30 hardware
+ * peripheral, HP domain, 3.0 V) is resolved at compile time via
+ * DEVICE_DT_GET in Wire.cpp. SDA/SCL pins are configured in the board
+ * overlay via pinctrl — `begin(sda, scl)` overloads are accepted for
+ * Arduino API compatibility but the pin arguments are ignored.
+ *
+ * Buffer sizes are sized for the worst-case I2C consumer we plan to use
+ * (NXP SE050 secure element, ~256-byte T=1 frames). BMP280 / INA228 /
+ * SHT40 / INA3221 read in single-digit bytes and fit trivially.
+ */
+
+#pragma once
+
+#include "Arduino.h"
+#include <stddef.h>
+#include <stdint.h>
+
+#ifndef WIRE_BUFFER_LENGTH
+#define WIRE_BUFFER_LENGTH 256
+#endif
+
+class TwoWire
+{
+  public:
+    TwoWire();
+
+    // ── Bus lifecycle ─────────────────────────────────────────────────
+    // begin() variants — pin arguments are accepted for API compatibility
+    // but ignored: SDA/SCL are fixed by the Zephyr overlay pinctrl. freq
+    // is also fixed by overlay clock-frequency (use setClock() at runtime).
+    void begin();
+    void begin(uint8_t sda, uint8_t scl);
+    void begin(int sda, int scl, uint32_t freq);
+    void end();
+
+    void setClock(uint32_t freq);
+    void setClockStretchLimit(uint32_t) {} // no-op on TWIM hardware
+
+    // ── Master write ─────────────────────────────────────────────────
+    void beginTransmission(uint8_t addr);
+    void beginTransmission(int addr) { beginTransmission((uint8_t)addr); }
+    // Return codes (Arduino convention):
+    //   0 = success, 1 = data-too-long, 2 = NACK on addr, 3 = NACK on data,
+    //   4 = other error, 5 = timeout.
+    uint8_t endTransmission(bool stop = true);
+    uint8_t endTransmission(uint8_t stop) { return endTransmission(stop != 0); }
+
+    size_t write(uint8_t data);
+    size_t write(const uint8_t *data, size_t n);
+
+    // ── Master read ──────────────────────────────────────────────────
+    uint8_t requestFrom(uint8_t addr, uint8_t quantity, bool stop = true);
+    uint8_t requestFrom(uint8_t addr, uint8_t quantity, uint8_t stop) { return requestFrom(addr, quantity, stop != 0); }
+    uint8_t requestFrom(int addr, int quantity, int stop = 1) { return requestFrom((uint8_t)addr, (uint8_t)quantity, stop != 0); }
+
+    int available();
+    int read();
+    int peek();
+    size_t readBytes(uint8_t *buf, size_t len);
+    size_t readBytes(char *buf, size_t len) { return readBytes((uint8_t *)buf, len); }
+    void flush() {}
+
+    // Slave callbacks unsupported — peripheral-only stub.
+    void onReceive(void (*)(int)) {}
+    void onRequest(void (*)(void)) {}
+
+    operator bool() const;
+
+  private:
+    uint8_t txAddr;
+    uint16_t txLen;
+    uint8_t txBuf[WIRE_BUFFER_LENGTH];
+
+    uint16_t rxLen;
+    uint16_t rxPos;
+    uint8_t rxBuf[WIRE_BUFFER_LENGTH];
+};
+
+extern TwoWire Wire;
+extern TwoWire Wire1; // alias to Wire — only one I2C bus on this board

src/platform/nrf54l15/architecture.h

@@ -0,0 +1,79 @@
+#pragma once
+
+#define ARCH_NRF54L15
+
+//
+// Feature flags for nRF54L15.
+//
+// The HAS_* macros below are Meshtastic's compile-time feature gate: every
+// optional subsystem (BLE, screen, I2C, GPS, buttons, telemetry, sensors,
+// radio, CPU shutdown, ...) is wrapped in `#if HAS_FOO` so a given board
+// only pays for the features it actually ships. On memory-tight MCUs this
+// is not cosmetic — it's the difference between a binary that fits in
+// flash and one that doesn't, and between a build that links and one that
+// drags in drivers for hardware the board doesn't have. Defaulting to 0
+// here (rather than inheriting nRF52 defaults) is deliberate: the
+// nRF54L15-DK is a bare dev kit with no screen, no I2C sensors, no GPS,
+// no user buttons — so every HAS_* flag starts off and gets flipped on
+// explicitly by variants that add that hardware.
+//
+// Feature flags are also the cleanest way to absorb platform divergence
+// without sprinkling `#ifdef ARCH_NRF54L15` across shared code. Anywhere
+// a subsystem can be conditionally compiled via HAS_*, prefer that over
+// per-arch guards: it keeps the core code arch-agnostic, makes it trivial
+// to bring up the next board (flip the flags, don't patch call sites),
+// and keeps the "does this platform support X?" question answerable by
+// reading one file instead of grepping the tree. BLE in particular is
+// deferred to Phase 2 on this port — the nRF54L15 uses MPSL/Zephyr BLE
+// APIs rather than the Adafruit SoftDevice stack used by nRF52840 — so
+// while HAS_BLUETOOTH defaults to 1, the actual implementation lives in
+// NRF54L15Bluetooth.cpp behind its own Zephyr Kconfig gates.
+//
+
+#ifndef HAS_BLUETOOTH
+#define HAS_BLUETOOTH 1
+#endif
+#ifndef HAS_SCREEN
+#define HAS_SCREEN 0
+#endif
+#ifndef HAS_WIRE
+#define HAS_WIRE 0
+#endif
+#ifndef HAS_GPS
+#define HAS_GPS 0
+#endif
+#ifndef HAS_BUTTON
+#define HAS_BUTTON 0
+#endif
+#ifndef HAS_TELEMETRY
+#define HAS_TELEMETRY 0
+#endif
+#ifndef HAS_SENSOR
+#define HAS_SENSOR 0
+#endif
+#ifndef HAS_RADIO
+#define HAS_RADIO 1
+#endif
+#ifndef HAS_CPU_SHUTDOWN
+#define HAS_CPU_SHUTDOWN 0
+#endif
+
+// ADC reference — nRF54L15 SAADC uses VDD/4 internal ref by default
+#ifndef AREF_VOLTAGE
+#define AREF_VOLTAGE 3.6
+#endif
+#ifndef BATTERY_SENSE_RESOLUTION_BITS
+#define BATTERY_SENSE_RESOLUTION_BITS 12
+#endif
+
+//
+// HW_VENDOR — maps build-time define to HardwareModel enum.
+// PRIVATE_HW (255): the protobuf HardwareModel enum reserves DK / DIY boards
+// without an SKU under this value; the nRF54L15-DK doesn't get a dedicated
+// enum number. Variant manifest matches via custom_meshtastic_hw_model = 255.
+//
+#ifdef NRF54L15_DK
+#define HW_VENDOR meshtastic_HardwareModel_PRIVATE_HW
+#else
+#define HW_VENDOR meshtastic_HardwareModel_UNSET
+#endif