latest test changes

Co-authored-by: jp-bennett <5630967+jp-bennett@users.noreply.github.com>

.claude/settings.json

@@ -1,16 +0,0 @@
-{
-  "hooks": {
-    "PostToolUse": [
-      {
-        "matcher": "Write|Edit",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "python3 -c \"import json,sys,subprocess,shutil,os; f=json.load(sys.stdin).get('tool_input',{}).get('file_path',''); t=shutil.which('trunk') or os.path.expanduser('~/.cache/trunk/launcher/trunk'); f and os.path.exists(t) and subprocess.run([t,'fmt','--force',f],stderr=subprocess.DEVNULL)\" 2>/dev/null || true",
-            "statusMessage": "Formatting..."
-          }
-        ]
-      }
-    ]
-  }
-}

.clusterfuzzlite/Dockerfile

@@ -18,7 +18,7 @@ ENV PIP_ROOT_USER_ACTION=ignore
 # trunk-ignore(hadolint/DL3008): apt packages are not pinned.
 # trunk-ignore(terrascan/AC_DOCKER_0002): apt packages are not pinned.
 RUN apt-get update && apt-get install --no-install-recommends -y \
-        cmake git zip libgpiod-dev libjsoncpp-dev libbluetooth-dev libi2c-dev \
+        cmake git zip libgpiod-dev libbluetooth-dev libi2c-dev \
         libunistring-dev libmicrohttpd-dev libgnutls28-dev libgcrypt20-dev \
         libusb-1.0-0-dev libssl-dev pkg-config libsqlite3-dev libsdl2-dev && \
     apt-get clean && rm -rf /var/lib/apt/lists/* && \

.clusterfuzzlite/build.sh

@@ -31,7 +31,7 @@ cmake --install "$WORK/ulfius/$SANITIZER" --prefix /usr
 cd "$SRC/firmware"
 
 PLATFORMIO_EXTRA_SCRIPTS=$(echo -e "pre:.clusterfuzzlite/platformio-clusterfuzzlite-pre.py\npost:.clusterfuzzlite/platformio-clusterfuzzlite-post.py")
-STATIC_LIBS=$(pkg-config --libs --static libulfius openssl libgpiod yaml-cpp jsoncpp bluez --silence-errors)
+STATIC_LIBS=$(pkg-config --libs --static libulfius openssl libgpiod yaml-cpp bluez --silence-errors)
 export PLATFORMIO_EXTRA_SCRIPTS
 export STATIC_LIBS
 export PLATFORMIO_WORKSPACE_DIR="$WORK/pio/$SANITIZER"

.devcontainer/Dockerfile

@@ -16,7 +16,6 @@ RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
     libssl-dev \
     libulfius-dev \
     libyaml-cpp-dev \
-    libjsoncpp-dev \
     pipx \
     pkg-config \
     python3 \

.github/actions/setup-base/action.yml

@@ -13,7 +13,7 @@ runs:
       shell: bash
       run: |
         sudo apt-get -y update --fix-missing
-        sudo apt-get install -y cppcheck libbluetooth-dev libgpiod-dev libyaml-cpp-dev libjsoncpp-dev lsb-release
+        sudo apt-get install -y cppcheck libbluetooth-dev libgpiod-dev libyaml-cpp-dev lsb-release
 
     - name: Setup Python
       uses: actions/setup-python@v6

.github/actions/setup-native/action.yml

@@ -11,4 +11,4 @@ runs:
     - name: Install libs needed for native build
       shell: bash
       run: |
-        sudo apt-get install -y libbluetooth-dev libgpiod-dev libyaml-cpp-dev libjsoncpp-dev openssl libssl-dev libulfius-dev liborcania-dev libusb-1.0-0-dev libi2c-dev libuv1-dev
+        sudo apt-get install -y libbluetooth-dev libgpiod-dev libyaml-cpp-dev openssl libssl-dev libulfius-dev liborcania-dev libusb-1.0-0-dev libi2c-dev libuv1-dev

.github/copilot-instructions.md

@@ -609,35 +609,20 @@ Most workflows can be triggered manually via `workflow_dispatch` for testing.
 
 ### Native unit tests (C++)
 
-Unit tests in `test/` directory with 17 test suites:
+Unit tests in `test/` directory with 12 test suites:
 
-- `test_admin_radio/` - LoRa region/config validation and AdminModule dispatch
-- `test_atak/` - ATAK integration
 - `test_crypto/` - Cryptography
-- `test_default/` - Default configuration
-- `test_http_content_handler/` - HTTP handling
-- `test_mac_from_string/` - MAC address parsing
+- `test_mqtt/` - MQTT integration
+- `test_radio/` - Radio interface
 - `test_mesh_module/` - Module framework
 - `test_meshpacket_serializer/` - Packet serialization
-- `test_mqtt/` - MQTT integration
-- `test_packet_history/` - Packet history tracking
-- `test_position_precision/` - Position precision helpers
-- `test_radio/` - Radio interface
-- `test_serial/` - Serial communication
-- `test_traffic_management/` - Traffic management
 - `test_transmit_history/` - Retransmission tracking
-- `test_type_conversions/` - NodeDB v25 type conversion (bitfield round-trips, NodeInfoLite)
-- `test_utf8/` - UTF-8 utilities
+- `test_atak/` - ATAK integration
+- `test_default/` - Default configuration
+- `test_http_content_handler/` - HTTP handling
+- `test_serial/` - Serial communication
 
-Run command (preferred — avoids pipe-buffering and the Ubuntu externally-managed-environment error):
-
-```bash
-~/.platformio/penv/bin/python -m platformio test -e native -f test_your_suite > /tmp/test_out.txt 2>&1
-grep -E 'error:|PASS|FAIL|succeeded|failed' /tmp/test_out.txt
-tail -15 /tmp/test_out.txt
-```
-
-Do **not** use `pio test … | tail -N` — it discards build errors and shows stale cached results. Do **not** use `pio test … | grep` — line-buffering makes the terminal appear hung until the process exits. Redirect to a file first, then grep.
+Run with: `pio test -e native`
 
 Simulation testing: `bin/test-simulator.sh`
 

.github/workflows/firmware-size-comment.yml

@@ -1,62 +0,0 @@
-name: Post Firmware Size Comment
-
-on:
-  workflow_run:
-    workflows: [CI]
-    types: [completed]
-
-permissions:
-  pull-requests: write
-  actions: read
-
-jobs:
-  post-size-comment:
-    if: >
-      github.event.workflow_run.event == 'pull_request' &&
-      github.event.workflow_run.conclusion != 'cancelled' &&
-      github.repository == 'meshtastic/firmware'
-    continue-on-error: true
-    runs-on: ubuntu-latest
-    steps:
-      - name: Download size report
-        id: download
-        uses: actions/download-artifact@v8
-        continue-on-error: true
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          run-id: ${{ github.event.workflow_run.id }}
-          name: size-report
-          path: ./
-
-      - name: Post or update PR comment
-        if: steps.download.outcome == 'success'
-        uses: actions/github-script@v8
-        with:
-          script: |
-            const fs = require('fs');
-            const marker = '<!-- firmware-size-report -->';
-            const body = fs.readFileSync('./size-report.md', 'utf8');
-            const prNumber = parseInt(fs.readFileSync('./pr-number.txt', 'utf8').trim(), 10);
-
-            const { data: comments } = await github.rest.issues.listComments({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: prNumber,
-            });
-
-            const existing = comments.find(c => c.body.includes(marker));
-            if (existing) {
-              await github.rest.issues.updateComment({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                comment_id: existing.id,
-                body,
-              });
-            } else {
-              await github.rest.issues.createComment({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                issue_number: prNumber,
-                body,
-              });
-            }

.github/workflows/flasher-link-comment.yml

@@ -1,183 +0,0 @@
-name: Post Web Flasher Link Comment
-
-on:
-  workflow_run:
-    workflows: [CI]
-    types: [completed]
-
-permissions:
-  pull-requests: write
-  actions: read
-
-jobs:
-  post-flasher-link:
-    if: >
-      github.event.workflow_run.event == 'pull_request' &&
-      github.event.workflow_run.conclusion != 'cancelled' &&
-      github.repository == 'meshtastic/firmware'
-    continue-on-error: true
-    runs-on: ubuntu-latest
-    steps:
-      # Per-board manifests carry the firmware's own metadata (activelySupported,
-      # displayName, ...) generated from each target's custom_meshtastic_* config.
-      - name: Download board manifests
-        uses: actions/download-artifact@v8
-        continue-on-error: true
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          run-id: ${{ github.event.workflow_run.id }}
-          pattern: manifest-*
-          path: ./manifests
-          merge-multiple: true
-
-      - name: Post or update web flasher link comment
-        uses: actions/github-script@v8
-        with:
-          script: |
-            const marker = '<!-- web-flasher-link -->';
-            const run = context.payload.workflow_run;
-            const { owner, repo } = context.repo;
-
-            // Resolve the PR by matching the run's head SHA against the repo's open
-            // PRs. workflow_run.pull_requests is empty for fork PRs, and
-            // listPullRequestsAssociatedWithCommit won't return an open fork PR by
-            // its head commit — but pulls.list includes fork PRs. Matching on head
-            // SHA also enforces that the run is for the PR's current commit, so stale
-            // re-runs of an outdated commit won't match.
-            const openPrs = await github.paginate(github.rest.pulls.list, {
-              owner, repo, state: 'open', per_page: 100,
-            });
-            const pr = openPrs.find((p) => p.head.sha === run.head_sha);
-            if (!pr) {
-              core.info(`No open pull request matches commit ${run.head_sha}; skipping.`);
-              return;
-            }
-            const prNumber = pr.number;
-
-            // Only comment on PRs authored by members of the organization.
-            // author_association MEMBER is computed by GitHub and reflects org
-            // membership (including concealed members); OWNER covers a repo owner.
-            const allowedAssociations = ['OWNER', 'MEMBER'];
-            if (!allowedAssociations.includes(pr.author_association)) {
-              core.info(`Author association ${pr.author_association} is not an org member; skipping.`);
-              return;
-            }
-
-            // Require at least one per-arch firmware artifact from gather-artifacts
-            const artifacts = await github.paginate(github.rest.actions.listWorkflowRunArtifacts, {
-              owner, repo, run_id: run.id, per_page: 100,
-            });
-            const archRe = /^firmware-(esp32|esp32s3|esp32c3|esp32c6|nrf52840|rp2040|rp2350|stm32)-(\d+\.\d+\.\d+\.[0-9a-f]+)$/;
-            const archArtifacts = artifacts.filter((a) => archRe.test(a.name) && !a.expired);
-            if (archArtifacts.length === 0) {
-              core.info('No per-arch firmware artifacts found; skipping.');
-              return;
-            }
-
-            const version = archRe.exec(archArtifacts[0].name)[2];
-            const expiresAt = archArtifacts[0].expires_at
-              ? new Date(archArtifacts[0].expires_at).toISOString().slice(0, 10)
-              : null;
-
-            // Read each built board's manifest (.mt.json). activelySupported,
-            // displayName and architecture come straight from the board's
-            // custom_meshtastic_* platformio config, so the list is in sync with
-            // the firmware itself — no external device database needed.
-            const fs = require('fs');
-            let boards = [];
-            try {
-              boards = fs.readdirSync('./manifests')
-                .filter((f) => f.endsWith('.mt.json'))
-                .map((f) => {
-                  try { return JSON.parse(fs.readFileSync(`./manifests/${f}`, 'utf8')); }
-                  catch { return null; }
-                })
-                .filter((m) => m && m.activelySupported === true && m.platformioTarget)
-                .map((m) => ({
-                  board: m.platformioTarget,
-                  platform: m.architecture || '',
-                  // displayName is maintainer-authored text; escape table-breaking pipes
-                  displayName: String(m.displayName || m.platformioTarget).replace(/\|/g, '\\|'),
-                  image: Array.isArray(m.images) && m.images[0] ? String(m.images[0]) : '',
-                }))
-                .sort((a, b) => a.board.localeCompare(b.board));
-            } catch (e) {
-              core.warning(`Could not read board manifests: ${e.message}`);
-            }
-
-            const flasherUrl = `https://flasher.meshtastic.org/?pr=${prNumber}`;
-            // Device illustrations are served by the flasher from the same image
-            // names the manifest declares (custom_meshtastic_images). The flasher
-            // serves its SPA shell (HTML, 200) for unknown paths, so confirm each
-            // image really resolves to an image before linking it.
-            const imageBase = 'https://flasher.meshtastic.org/img/devices/';
-            await Promise.all(boards.map(async (b) => {
-              if (!b.image) return;
-              try {
-                const res = await fetch(`${imageBase}${encodeURIComponent(b.image)}`);
-                const type = res.headers.get('content-type') || '';
-                if (!res.ok || !type.startsWith('image/')) b.image = '';
-              } catch { b.image = ''; }
-            }));
-
-            const boardLines = boards
-              .map((b) => {
-                const img = b.image ? `<img src="${imageBase}${encodeURIComponent(b.image)}" alt="" height="34">` : '';
-                return `| ${img} | ${b.displayName} | [\`${b.board}\`](${flasherUrl}&device=${encodeURIComponent(b.board)}) | ${b.platform} |`;
-              })
-              .join('\n');
-
-            // Shields.io badges. Only non-user-controlled, charset-constrained values
-            // (version, commit sha, counts, dates) go into badge URLs — never board
-            // names or the PR title — so the rendered comment cannot be spoofed.
-            const shieldText = (s) =>
-              encodeURIComponent(String(s).replace(/-/g, '--').replace(/_/g, '__').replace(/ /g, '_'));
-            const shield = (label, message, color) =>
-              `https://img.shields.io/badge/${shieldText(label)}-${shieldText(message)}-${color}`;
-            const buttonUrl =
-              `https://img.shields.io/badge/${shieldText('Flash this PR in the Web Flasher')}-2C2D3C?style=for-the-badge`;
-            const badges = [
-              `![firmware](${shield('firmware', version, '67EA94')})`,
-              `![commit](${shield('commit', run.head_sha.slice(0, 7), '2C2D3C')})`,
-              `![boards](${shield('boards', boards.length, '5C6BC0')})`,
-            ];
-            if (expiresAt) badges.push(`![expires](${shield('expires', expiresAt, '9A4E00')})`);
-
-            // Only render the board table when there are supported boards to list
-            const boardTable = boards.length > 0 ? [
-              `<details><summary>Supported boards built by this PR (${boards.length})</summary>`,
-              '',
-              '| | Device | Board | Platform |',
-              '| --- | --- | --- | --- |',
-              boardLines,
-              '',
-              '</details>',
-              '',
-            ] : [];
-
-            const body = [
-              marker,
-              '## ⚡ Try this PR in the Web Flasher',
-              '',
-              `[![Flash this PR in the Web Flasher](${buttonUrl})](${flasherUrl})`,
-              '',
-              badges.join(' '),
-              '',
-              '> [!WARNING]',
-              '> This is an automated, unreviewed CI test build. Back up your device configuration',
-              '> before flashing, and only flash devices you are able to recover.',
-              '',
-              ...boardTable,
-              `*Build artifacts expire${expiresAt ? ` on ${expiresAt}` : ' after 30 days'}. Updated for \`${run.head_sha.slice(0, 7)}\`.*`,
-            ].join('\n');
-
-            // Sticky comment: update in place when the marker is found
-            const comments = await github.paginate(github.rest.issues.listComments, {
-              owner, repo, issue_number: prNumber, per_page: 100,
-            });
-            const existing = comments.find((c) => c.body?.includes(marker));
-            if (existing) {
-              await github.rest.issues.updateComment({ owner, repo, comment_id: existing.id, body });
-            } else {
-              await github.rest.issues.createComment({ owner, repo, issue_number: prNumber, body });
-            }

.github/workflows/flasher-link-placeholder.yml

@@ -1,60 +0,0 @@
-name: Post Web Flasher Build Placeholder
-
-# Drops an immediate "build in progress" comment when a PR opens, so the web
-# flasher entry shows up right away. The real CI-driven workflow
-# (flasher-link-comment.yml) later replaces it in place via the shared marker.
-#
-# SECURITY: this uses pull_request_target (write token, runs for fork PRs) but is
-# safe because it never checks out or runs PR code and posts a fully static body
-# — no PR title, branch name, or other untrusted input is used anywhere.
-
-on:
-  pull_request_target:
-    types: [opened, reopened]
-
-permissions:
-  pull-requests: write
-
-jobs:
-  post-placeholder:
-    if: github.repository == 'meshtastic/firmware'
-    continue-on-error: true
-    runs-on: ubuntu-latest
-    steps:
-      - name: Post web flasher build-in-progress placeholder
-        uses: actions/github-script@v8
-        with:
-          script: |
-            const marker = '<!-- web-flasher-link -->';
-            const { owner, repo } = context.repo;
-            const pr = context.payload.pull_request;
-
-            // Only org members get the flasher comment (matches the real workflow)
-            const allowedAssociations = ['OWNER', 'MEMBER'];
-            if (!allowedAssociations.includes(pr.author_association)) {
-              core.info(`Author association ${pr.author_association} is not an org member; skipping.`);
-              return;
-            }
-
-            // Only seed a placeholder when no flasher comment exists yet — never
-            // overwrite a real (or existing placeholder) comment.
-            const comments = await github.paginate(github.rest.issues.listComments, {
-              owner, repo, issue_number: pr.number, per_page: 100,
-            });
-            if (comments.some((c) => c.body?.includes(marker))) {
-              core.info('Flasher comment already exists; nothing to do.');
-              return;
-            }
-
-            const body = [
-              marker,
-              '## ⚡ Try this PR in the Web Flasher',
-              '',
-              '> [!NOTE]',
-              '> Building this pull request… the flash button, badges and supported-board',
-              '> list will appear here automatically once CI finishes.',
-            ].join('\n');
-
-            await github.rest.issues.createComment({
-              owner, repo, issue_number: pr.number, body,
-            });

.github/workflows/main_matrix.yml

@@ -245,126 +245,47 @@ jobs:
           path: ./*.elf
           retention-days: 30
 
-  firmware-size-report:
+  shame:
     if: github.repository == 'meshtastic/firmware'
     continue-on-error: true
-    permissions:
-      contents: read
-      actions: read
     runs-on: ubuntu-latest
     needs: [build]
     steps:
       - uses: actions/checkout@v6
-
-      - name: Download current manifests
+        if: github.event_name == 'pull_request'
+        with:
+          filter: blob:none # means we download all the git history but none of the commit (except ones with checkout like the head)
+          fetch-depth: 0
+      - name: Download the current manifests
         uses: actions/download-artifact@v8
         with:
-          path: ./manifests/
+          path: ./manifests-new/
           pattern: manifest-*
           merge-multiple: true
-
-      - name: Collect current firmware sizes
-        run: python3 bin/collect_sizes.py ./manifests/ ./current-sizes.json
-
-      - name: Upload size report artifact
+      - name: Upload combined manifests for later commit and global stats crunching.
         uses: actions/upload-artifact@v7
+        id: upload-manifest
         with:
-          name: firmware-sizes-${{ github.sha }}
+          name: manifests-${{ github.sha }}
           overwrite: true
-          path: ./current-sizes.json
-          retention-days: 90
-
-      - name: Download baseline sizes from develop
+          path: manifests-new/*.mt.json
+      - name: Find the merge base
         if: github.event_name == 'pull_request'
-        continue-on-error: true
-        id: baseline-develop
+        run: echo "MERGE_BASE=$(git merge-base "origin/$base" "$head")" >> $GITHUB_ENV
         env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          RUN_ID=$(gh run list -R "${{ github.repository }}" \
-            --workflow CI --branch develop --status success \
-            --limit 1 --json databaseId --jq '.[0].databaseId // empty')
-          if [ -n "$RUN_ID" ]; then
-            ARTIFACT_NAME=$(gh api "repos/${{ github.repository }}/actions/runs/${RUN_ID}/artifacts" \
-              --jq '.artifacts[] | select(.name | startswith("firmware-sizes-")) | select(.expired == false) | .name' | head -1)
-            if [ -n "$ARTIFACT_NAME" ]; then
-              gh run download "$RUN_ID" -R "${{ github.repository }}" \
-                --name "$ARTIFACT_NAME" --dir ./baseline-develop/
-              cp "./baseline-develop/current-sizes.json" ./develop-sizes.json
-              echo "found=true" >> "$GITHUB_OUTPUT"
-            else
-              echo "found=false" >> "$GITHUB_OUTPUT"
-            fi
-          else
-            echo "found=false" >> "$GITHUB_OUTPUT"
-          fi
-
-      - name: Download baseline sizes from master
-        if: github.event_name == 'pull_request'
-        continue-on-error: true
-        id: baseline-master
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          RUN_ID=$(gh run list -R "${{ github.repository }}" \
-            --workflow CI --branch master --status success \
-            --limit 1 --json databaseId --jq '.[0].databaseId // empty')
-          if [ -n "$RUN_ID" ]; then
-            ARTIFACT_NAME=$(gh api "repos/${{ github.repository }}/actions/runs/${RUN_ID}/artifacts" \
-              --jq '.artifacts[] | select(.name | startswith("firmware-sizes-")) | select(.expired == false) | .name' | head -1)
-            if [ -n "$ARTIFACT_NAME" ]; then
-              gh run download "$RUN_ID" -R "${{ github.repository }}" \
-                --name "$ARTIFACT_NAME" --dir ./baseline-master/
-              cp "./baseline-master/current-sizes.json" ./master-sizes.json
-              echo "found=true" >> "$GITHUB_OUTPUT"
-            else
-              echo "found=false" >> "$GITHUB_OUTPUT"
-            fi
-          else
-            echo "found=false" >> "$GITHUB_OUTPUT"
-          fi
-
-      - name: Generate size comparison report
-        if: github.event_name == 'pull_request'
-        id: report
-        run: |
-          ARGS="./current-sizes.json"
-          if [ -f ./develop-sizes.json ]; then
-            ARGS="$ARGS --baseline develop:./develop-sizes.json"
-          fi
-          if [ -f ./master-sizes.json ]; then
-            ARGS="$ARGS --baseline master:./master-sizes.json"
-          fi
-          REPORT=$(python3 bin/size_report.py $ARGS)
-          if [ -z "$REPORT" ]; then
-            echo "has_report=false" >> "$GITHUB_OUTPUT"
-          else
-            echo "has_report=true" >> "$GITHUB_OUTPUT"
-            {
-              echo '<!-- firmware-size-report -->'
-              echo '# Firmware Size Report'
-              echo ''
-              echo "$REPORT"
-              echo ''
-              echo '---'
-              echo "*Updated for ${{ github.sha }}*"
-            } > ./size-report.md
-            cat ./size-report.md >> "$GITHUB_STEP_SUMMARY"
-          fi
-
-      - name: Save PR number
-        if: github.event_name == 'pull_request' && steps.report.outputs.has_report == 'true'
-        run: echo "${{ github.event.pull_request.number }}" > ./pr-number.txt
-
-      - name: Upload size report
-        if: github.event_name == 'pull_request' && steps.report.outputs.has_report == 'true'
-        uses: actions/upload-artifact@v7
-        with:
-          name: size-report
-          path: |
-            ./size-report.md
-            ./pr-number.txt
-          retention-days: 5
+          base: ${{ github.base_ref }}
+          head: ${{ github.sha }}
+      # Currently broken (for-loop through EVERY artifact -- rate limiting)
+      # - name: Download the old manifests
+      #   if: github.event_name == 'pull_request'
+      #   run: gh run download -R "$repo" --name "manifests-$merge_base" --dir manifest-old/
+      #   env:
+      #     GH_TOKEN: ${{ github.token }}
+      #     merge_base: ${{ env.MERGE_BASE }}
+      #     repo: ${{ github.repository }}
+      # - name: Do scan and post comment
+      #   if: github.event_name == 'pull_request'
+      #   run: python3 bin/shame.py ${{ github.event.pull_request.number }} manifests-old/ manifests-new/
 
   release-artifacts:
     permissions: # Needed for 'gh release upload'.

.github/workflows/update_protobufs.yml

@@ -16,18 +16,13 @@ jobs:
           submodules: true
 
       - name: Update submodule
-        if: ${{ github.ref_name == 'master' || github.ref_name == 'develop' }}
-        working-directory: protobufs
-        env:
-          # Use the branch that triggered the workflow as the protobuf branch.
-          GIT_BRANCH: ${{ github.ref_name }}
+        if: ${{ github.ref == 'refs/heads/master' || github.ref == 'refs/heads/develop' }}
         run: |
-          git fetch --prune origin $GIT_BRANCH
-          git checkout origin/$GIT_BRANCH
+          git submodule update --remote protobufs
 
       - name: Download nanopb
         run: |
-          wget https://github.com/nanopb/nanopb/releases/download/nanopb-0.4.9.1/nanopb-0.4.9.1-linux-x86.tar.gz
+          wget https://jpa.kapsi.fi/nanopb/download/nanopb-0.4.9.1-linux-x86.tar.gz
           tar xvzf nanopb-0.4.9.1-linux-x86.tar.gz
           mv nanopb-0.4.9.1-linux-x86 nanopb-0.4.9
 
@@ -38,7 +33,7 @@ jobs:
       - name: Create pull request
         uses: peter-evans/create-pull-request@v8
         with:
-          branch: create-pull-request/update-protobufs-${{ github.ref_name }}
+          branch: create-pull-request/update-protobufs
           labels: submodules
           title: Update protobufs and classes
           commit-message: Update protobufs

AGENTS.md

@@ -10,18 +10,18 @@ This file (`AGENTS.md`) is a short pointer + quick reference for agents that don
 
 ## Quick command reference
 
-| Action                           | Command                                                                                                                                                                                                        |
-| -------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Build a firmware variant         | `pio run -e <env>` (e.g. `pio run -e rak4631`, `pio run -e heltec-v3`)                                                                                                                                         |
-| Build native macOS host binary   | `pio run -e native-macos` (Homebrew prereqs + CH341 LoRa setup in `variants/native/portduino/platformio.ini`)                                                                                                  |
-| Clean + rebuild                  | `pio run -e <env> -t clean && pio run -e <env>`                                                                                                                                                                |
-| Flash a device                   | `pio run -e <env> -t upload --upload-port <port>` (or use the `pio_flash` MCP tool)                                                                                                                            |
-| Run firmware unit tests (native) | `~/.platformio/penv/bin/python -m platformio test -e native > /tmp/test_out.txt 2>&1` then `grep -E 'error:\|PASS\|FAIL\|succeeded\|failed' /tmp/test_out.txt` (redirect first — piping causes line-buffering) |
-| Run MCP hardware tests           | `./mcp-server/run-tests.sh`                                                                                                                                                                                    |
-| Live TUI test runner             | `mcp-server/.venv/bin/meshtastic-mcp-test-tui`                                                                                                                                                                 |
-| Format before commit             | `trunk fmt`                                                                                                                                                                                                    |
-| Regenerate protobuf bindings     | `bin/regen-protos.sh`                                                                                                                                                                                          |
-| Generate CI matrix               | `./bin/generate_ci_matrix.py all [--level pr]`                                                                                                                                                                 |
+| Action                           | Command                                                                                                       |
+| -------------------------------- | ------------------------------------------------------------------------------------------------------------- |
+| Build a firmware variant         | `pio run -e <env>` (e.g. `pio run -e rak4631`, `pio run -e heltec-v3`)                                        |
+| Build native macOS host binary   | `pio run -e native-macos` (Homebrew prereqs + CH341 LoRa setup in `variants/native/portduino/platformio.ini`) |
+| Clean + rebuild                  | `pio run -e <env> -t clean && pio run -e <env>`                                                               |
+| Flash a device                   | `pio run -e <env> -t upload --upload-port <port>` (or use the `pio_flash` MCP tool)                           |
+| Run firmware unit tests (native) | `pio test -e native`                                                                                          |
+| Run MCP hardware tests           | `./mcp-server/run-tests.sh`                                                                                   |
+| Live TUI test runner             | `mcp-server/.venv/bin/meshtastic-mcp-test-tui`                                                                |
+| Format before commit             | `trunk fmt`                                                                                                   |
+| Regenerate protobuf bindings     | `bin/regen-protos.sh`                                                                                         |
+| Generate CI matrix               | `./bin/generate_ci_matrix.py all [--level pr]`                                                                |
 
 ## MCP server (device + test automation)
 
@@ -108,7 +108,7 @@ Sequence these; don't parallelize on the same port.
 | `src/modules/`                    | Feature modules; `Telemetry/Sensor/` has 50+ I2C sensor drivers                                                          |
 | `variants/`                       | 200+ hardware variant definitions (`variant.h` + `platformio.ini` per board)                                             |
 | `protobufs/`                      | `.proto` definitions; regenerate with `bin/regen-protos.sh`                                                              |
-| `test/`                           | Firmware unit tests (17 suites; `pio test -e native`)                                                                    |
+| `test/`                           | Firmware unit tests (12 suites; `pio test -e native`)                                                                    |
 | `mcp-server/`                     | Python MCP server + pytest hardware integration tests                                                                    |
 | `mcp-server/tests/`               | Tiered pytest suite: `unit/`, `mesh/`, `telemetry/`, `monitor/`, `recovery/`, `ui/`, `fleet/`, `admin/`, `provisioning/` |
 | `.claude/commands/`               | Claude Code slash command bodies                                                                                         |

Dockerfile

@@ -14,7 +14,7 @@ ENV PIP_BREAK_SYSTEM_PACKAGES=1
 RUN apt-get update && apt-get install --no-install-recommends -y \
         curl wget g++ zip git ca-certificates pkg-config \
         python3-pip python3-grpc-tools \
-        libgpiod-dev libyaml-cpp-dev libjsoncpp-dev libbluetooth-dev libi2c-dev libuv1-dev \
+        libgpiod-dev libyaml-cpp-dev libbluetooth-dev libi2c-dev libuv1-dev \
         libusb-1.0-0-dev libulfius-dev liborcania-dev libssl-dev \
         libx11-dev libinput-dev libxkbcommon-x11-dev libsqlite3-dev libsdl2-dev \
     && apt-get clean && rm -rf /var/lib/apt/lists/* \
@@ -53,7 +53,7 @@ ENV TZ=Etc/UTC
 USER root
 
 RUN apt-get update && apt-get --no-install-recommends -y install \
-        libc-bin libc6 libgpiod3 libyaml-cpp0.8 libjsoncpp26 libi2c0 libuv1t64 libusb-1.0-0-dev \
+        libc-bin libc6 libgpiod3 libyaml-cpp0.8 libi2c0 libuv1t64 libusb-1.0-0-dev \
         liborcania2.3 libulfius2.7t64 libssl3t64 \
         libx11-6 libinput10 libxkbcommon-x11-0 libsdl2-2.0-0 \
     && apt-get clean && rm -rf /var/lib/apt/lists/* \

Dockerfile.test

@@ -7,7 +7,7 @@ ENV PIP_ROOT_USER_ACTION=ignore
 # hadolint ignore=DL3008
 RUN apt-get update && apt-get install --no-install-recommends -y \
         g++ git ca-certificates pkg-config \
-        libgpiod-dev libyaml-cpp-dev libjsoncpp-dev libbluetooth-dev libi2c-dev libuv1-dev \
+        libgpiod-dev libyaml-cpp-dev libbluetooth-dev libi2c-dev libuv1-dev \
         libusb-1.0-0-dev libulfius-dev liborcania-dev libssl-dev \
         libx11-dev libinput-dev libxkbcommon-x11-dev libsqlite3-dev libsdl2-dev \
     && apt-get clean && rm -rf /var/lib/apt/lists/* \

alpine.Dockerfile

@@ -16,7 +16,7 @@ ENV PIP_BREAK_SYSTEM_PACKAGES=1
 RUN apk --no-cache add \
         bash g++ libstdc++-dev linux-headers zip git ca-certificates libbsd-dev \
         py3-pip py3-grpcio-tools \
-        libgpiod-dev yaml-cpp-dev jsoncpp-dev bluez-dev \
+        libgpiod-dev yaml-cpp-dev bluez-dev \
         libusb-dev i2c-tools-dev libuv-dev openssl-dev pkgconf argp-standalone \
         libx11-dev libinput-dev libxkbcommon-dev sqlite-dev sdl2-dev \
     && rm -rf /var/cache/apk/* \
@@ -48,7 +48,7 @@ LABEL org.opencontainers.image.title="Meshtastic" \
 USER root
 
 RUN apk --no-cache add \
-        shadow libstdc++ libbsd libgpiod yaml-cpp jsoncpp libusb \
+        shadow libstdc++ libbsd libgpiod yaml-cpp libusb \
         i2c-tools libuv libx11 libinput libxkbcommon sdl2 \
     && rm -rf /var/cache/apk/* \
     && mkdir -p /var/lib/meshtasticd \

bin/collect_sizes.py

@@ -1,53 +0,0 @@
-#!/usr/bin/env python3
-
-"""Collect firmware binary sizes from manifest (.mt.json) files into a single report."""
-
-import json
-import os
-import sys
-
-
-def collect_sizes(manifest_dir):
-    """Scan manifest_dir for .mt.json files and return {board: size_bytes} dict."""
-    sizes = {}
-    for fname in sorted(os.listdir(manifest_dir)):
-        if not fname.endswith(".mt.json"):
-            continue
-        path = os.path.join(manifest_dir, fname)
-        with open(path) as f:
-            data = json.load(f)
-        board = data.get("platformioTarget", fname.replace(".mt.json", ""))
-        # Find the main firmware .bin size (largest .bin, excluding OTA/littlefs/bleota)
-        bin_size = None
-        for entry in data.get("files", []):
-            name = entry.get("name", "")
-            if name.startswith("firmware-") and name.endswith(".bin"):
-                bin_size = entry["bytes"]
-                break
-        # Fallback: any .bin that isn't ota/littlefs/bleota
-        if bin_size is None:
-            for entry in data.get("files", []):
-                name = entry.get("name", "")
-                if name.endswith(".bin") and not any(
-                    x in name for x in ["littlefs", "bleota", "ota"]
-                ):
-                    bin_size = entry["bytes"]
-                    break
-        if bin_size is not None:
-            sizes[board] = bin_size
-    return sizes
-
-
-if __name__ == "__main__":
-    if len(sys.argv) != 3:
-        print(f"Usage: {sys.argv[0]} <manifest_dir> <output.json>", file=sys.stderr)
-        sys.exit(1)
-
-    manifest_dir = sys.argv[1]
-    output_path = sys.argv[2]
-
-    sizes = collect_sizes(manifest_dir)
-    with open(output_path, "w") as f:
-        json.dump(sizes, f, indent=2, sort_keys=True)
-
-    print(f"Collected sizes for {len(sizes)} targets -> {output_path}")

bin/config.d/lora-RAK6421-13300-slot2.yaml

@@ -5,9 +5,7 @@ Meta:
     - raspberry-pi
 
 Lora:
-  
-  ### RAK13300 in Slot 2
-  Module: sx1262
+  ### RAK13300 in Slot 2 pins
   IRQ: 18 #IO6
   Reset: 24 # IO4
   Busy: 19 # IO5
@@ -15,7 +13,5 @@ Lora:
   Enable_Pins:
     - 26
     - 23
-  DIO3_TCXO_VOLTAGE: true
-  DIO2_AS_RF_SWITCH: true
   spidev: spidev0.1
   # CS: 7

bin/config.d/lora-RAK6421-13302-slot2.yaml

@@ -5,18 +5,14 @@ Meta:
     - raspberry-pi
 
 Lora:
-
-  ### RAK13302 in Slot 2
-  Module: sx1262
+  ### RAK13302 in Slot 2 pins
   IRQ: 18 #IO6
   Reset: 24 # IO4
   Busy: 19 # IO5
-  # Ant_sw: 23 # IO3
+  # Ant_sw: 23 # IO3 
   Enable_Pins:
     - 26
     - 23
-  DIO3_TCXO_VOLTAGE: true
-  DIO2_AS_RF_SWITCH: true
   spidev: spidev0.1
   # CS: 7
   TX_GAIN_LORA: [9, 9, 10, 11, 9, 8, 9, 10, 10, 10, 11, 12, 12, 12, 12, 12, 12, 12, 12, 10, 9, 8]

bin/shame.py

@@ -0,0 +1,95 @@
+import sys
+import os
+import json
+from github import Github
+
+def parseFile(path):
+    with open(path, "r") as f:
+        data = json.loads(f)
+    for file in data["files"]:
+        if file["name"].endswith(".bin"):
+            return file["name"], file["bytes"]
+
+if len(sys.argv) != 4:
+    print(f"expected usage: {sys.argv[0]} <PR number> <path to old-manifests> <path to new-manifests>")
+    sys.exit(1)
+
+pr_number = int(sys.argv[1])
+
+token = os.getenv("GITHUB_TOKEN")
+if not token:
+    raise EnvironmentError("GITHUB_TOKEN not found in environment.")
+
+repo_name = os.getenv("GITHUB_REPOSITORY")  # "owner/repo"
+if not repo_name:
+    raise EnvironmentError("GITHUB_REPOSITORY not found in environment.")
+
+oldFiles = sys.argv[2]
+old = set(os.path.join(oldFiles, f) for f in os.listdir(oldFiles) if os.path.isfile(f))
+newFiles = sys.argv[3]
+new = set(os.path.join(newFiles, f) for f in os.listdir(newFiles) if os.path.isfile(f))
+
+startMarkdown = "# Target Size Changes\n\n"
+markdown = ""
+
+newlyIntroduced = new - old
+if len(newlyIntroduced) > 0:
+    markdown += "## Newly Introduced Targets\n\n"
+    # create a table
+    markdown += "| File | Size |\n"
+    markdown += "| ---- | ---- |\n"
+    for f in newlyIntroduced:
+        name, size = parseFile(f)
+        markdown += f"| `{name}` | {size}b |\n"
+
+# do not log removed targets
+# PRs only run a small subset of builds, so removed targets are not meaningful
+# since they are very likely to just be not ran in PR CI
+
+both = old & new
+degradations = []
+improvements = []
+for f in both:
+    oldName, oldSize = parseFile(f)
+    _, newSize = parseFile(f)
+    if oldSize != newSize:
+        if newSize < oldSize:
+            improvements.append((oldName, oldSize, newSize))
+        else:
+            degradations.append((oldName, oldSize, newSize))
+
+if len(degradations) > 0:
+    markdown += "\n## Degradation\n\n"
+    # create a table
+    markdown += "| File | Difference | Old Size | New Size |\n"
+    markdown += "| ---- | ---------- | -------- | -------- |\n"
+    for oldName, oldSize, newSize in degradations:
+        markdown += f"| `{oldName}` | **{oldSize - newSize}b** | {oldSize}b | {newSize}b |\n"
+
+if len(improvements) > 0:
+    markdown += "\n## Improvement\n\n"
+    # create a table
+    markdown += "| File | Difference | Old Size | New Size |\n"
+    markdown += "| ---- | ---------- | -------- | -------- |\n"
+    for oldName, oldSize, newSize in improvements:
+        markdown += f"| `{oldName}` | **{oldSize - newSize}b** | {oldSize}b | {newSize}b |\n"
+
+if len(markdown) == 0:
+    markdown = "No changes in target sizes detected."
+
+g = Github(token)
+repo = g.get_repo(repo_name)
+pr = repo.get_pull(pr_number)
+
+existing_comment = None
+for comment in pr.get_issue_comments():
+    if comment.body.startswith(startMarkdown):
+        existing_comment = comment
+        break
+
+final_markdown = startMarkdown + markdown
+
+if existing_comment:
+    existing_comment.edit(body=final_markdown)
+else:
+    pr.create_issue_comment(body=final_markdown)

bin/size_report.py

@@ -1,171 +0,0 @@
-#!/usr/bin/env python3
-
-"""Compare firmware size reports and generate a markdown summary.
-
-Usage:
-    size_report.py <new_sizes.json> [--baseline <label>:<old_sizes.json>]...
-
-Examples:
-    # Compare PR against develop and master baselines
-    size_report.py pr.json --baseline develop:develop.json --baseline master:master.json
-
-    # Single baseline comparison
-    size_report.py pr.json --baseline develop:develop.json
-
-    # No baselines — shows sizes with blank delta columns
-    size_report.py pr.json
-"""
-
-import argparse
-import json
-import sys
-
-
-def load_sizes(path):
-    with open(path) as f:
-        return json.load(f)
-
-
-def format_delta(n):
-    """Format byte delta with sign and human-friendly suffix."""
-    sign = "+" if n > 0 else ""
-    if abs(n) >= 1024:
-        return f"{sign}{n:,} ({sign}{n / 1024:.1f} KB)"
-    return f"{sign}{n:,}"
-
-
-def generate_markdown(new_sizes, baselines, top_n=5):
-    """Generate a single table with current size and delta columns per baseline.
-
-    baselines: list of (label, old_sizes_dict), may be empty
-    """
-    labels = [label for label, _ in baselines]
-
-    # Build rows: (board, current_size, [(delta, abs_delta) per baseline])
-    rows = []
-    for board in sorted(new_sizes):
-        current = new_sizes[board]
-        deltas = []
-        for _, old_sizes in baselines:
-            old = old_sizes.get(board)
-            if old is not None:
-                d = current - old
-                deltas.append((d, abs(d)))
-            else:
-                deltas.append((None, 0))
-        # Sort key: max abs delta across baselines (biggest changes first)
-        max_abs = max((ad for _, ad in deltas), default=0)
-        rows.append((board, current, deltas, max_abs))
-
-    rows.sort(key=lambda r: r[3], reverse=True)
-
-    # Summary line
-    sections = []
-    summary_parts = [f"{len(new_sizes)} targets"]
-    for i, (label, old_sizes) in enumerate(baselines):
-        increases = sum(
-            1 for _, _, deltas, _ in rows if deltas[i][0] is not None and deltas[i][0] > 0
-        )
-        decreases = sum(
-            1 for _, _, deltas, _ in rows if deltas[i][0] is not None and deltas[i][0] < 0
-        )
-        net = sum(
-            deltas[i][0] for _, _, deltas, _ in rows if deltas[i][0] is not None
-        )
-        parts = []
-        if increases:
-            parts.append(f"{increases} increased")
-        if decreases:
-            parts.append(f"{decreases} decreased")
-        if parts:
-            parts.append(f"net {format_delta(net)}")
-            summary_parts.append(f"vs `{label}`: {', '.join(parts)}")
-        else:
-            summary_parts.append(f"vs `{label}`: no changes")
-
-    if not baselines:
-        summary_parts.append("no baseline available yet")
-
-    sections.append(f"**{' | '.join(summary_parts)}**\n")
-
-    # Table header
-    header = "| Target | Size |"
-    separator = "|--------|-----:|"
-    for label in labels:
-        header += f" vs `{label}` |"
-        separator += "----------:|"
-    sections.append(header)
-    sections.append(separator)
-
-    def format_row(board, current, deltas):
-        row = f"| `{board}` | {current:,} |"
-        for d, _ in deltas:
-            if d is None:
-                row += " |"
-            elif d == 0:
-                row += " 0 |"
-            else:
-                icon = "📈" if d > 0 else "📉"
-                row += f" {icon} {format_delta(d)} |"
-        return row
-
-    # Top N rows always visible
-    top = rows[:top_n]
-    for board, current, deltas, _ in top:
-        sections.append(format_row(board, current, deltas))
-
-    # Remaining rows in expandable section
-    rest = rows[top_n:]
-    if rest:
-        sections.append("")
-        sections.append(
-            f"<details><summary>Show {len(rest)} more target(s)</summary>\n"
-        )
-        sections.append(header)
-        sections.append(separator)
-        for board, current, deltas, _ in rest:
-            sections.append(format_row(board, current, deltas))
-        sections.append("\n</details>")
-
-    sections.append("")
-    return "\n".join(sections)
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Compare firmware size reports")
-    parser.add_argument("new_sizes", help="Path to new sizes JSON")
-    parser.add_argument(
-        "--baseline",
-        action="append",
-        default=[],
-        metavar="LABEL:PATH",
-        help="Baseline to compare against (e.g. develop:develop.json)",
-    )
-    parser.add_argument(
-        "--top",
-        type=int,
-        default=5,
-        help="Number of top changes to show before collapsing (default: 5)",
-    )
-    args = parser.parse_args()
-
-    new_sizes = load_sizes(args.new_sizes)
-
-    # Silence output when no targets were built — repo maintainer choice
-    if not new_sizes:
-        return
-
-    baselines = []
-    for b in args.baseline:
-        if ":" not in b:
-            print(f"Error: baseline must be LABEL:PATH, got '{b}'", file=sys.stderr)
-            sys.exit(1)
-        label, path = b.split(":", 1)
-        baselines.append((label, load_sizes(path)))
-
-    md = generate_markdown(new_sizes, baselines, top_n=args.top)
-    print(md)
-
-
-if __name__ == "__main__":
-    main()

bin/test_size_scripts.py

@@ -1,262 +0,0 @@
-#!/usr/bin/env python3
-
-"""Tests for bin/collect_sizes.py and bin/size_report.py."""
-
-import json
-import os
-import subprocess
-import sys
-import tempfile
-
-SCRIPTS_DIR = os.path.join(os.path.dirname(__file__), "..", "bin")
-
-
-def make_manifest(target, firmware_bytes, extra_files=None):
-    """Create a minimal .mt.json manifest dict."""
-    files = [{"name": f"firmware-{target}-2.6.0.bin", "bytes": firmware_bytes}]
-    if extra_files:
-        files.extend(extra_files)
-    return {
-        "platformioTarget": target,
-        "version": "2.6.0.test",
-        "files": files,
-    }
-
-
-def write_manifests(tmpdir, manifests):
-    """Write manifest dicts as .mt.json files into tmpdir."""
-    for target, data in manifests.items():
-        path = os.path.join(tmpdir, f"firmware-{target}.mt.json")
-        with open(path, "w") as f:
-            json.dump(data, f)
-
-
-def run_script(script, args):
-    """Run a Python script and return (returncode, stdout, stderr)."""
-    result = subprocess.run(
-        [sys.executable, os.path.join(SCRIPTS_DIR, script)] + args,
-        capture_output=True,
-        text=True,
-    )
-    return result.returncode, result.stdout, result.stderr
-
-
-def test_collect_sizes_basic():
-    """collect_sizes picks up firmware-*.bin entries from manifests."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        outfile = os.path.join(tmpdir, "sizes.json")
-        manifests = {
-            "heltec-v3": make_manifest("heltec-v3", 1048576),
-            "rak4631": make_manifest("rak4631", 524288),
-            "tbeam": make_manifest("tbeam", 786432),
-        }
-        write_manifests(tmpdir, manifests)
-
-        rc, stdout, stderr = run_script("collect_sizes.py", [tmpdir, outfile])
-        assert rc == 0, f"collect_sizes failed: {stderr}"
-        assert "3 targets" in stdout
-
-        with open(outfile) as f:
-            sizes = json.load(f)
-        assert sizes == {"heltec-v3": 1048576, "rak4631": 524288, "tbeam": 786432}
-
-
-def test_collect_sizes_fallback_bin():
-    """collect_sizes falls back to non-firmware-prefixed .bin if no firmware-*.bin."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        outfile = os.path.join(tmpdir, "sizes.json")
-        # Manifest with only a generic .bin (no firmware- prefix)
-        data = {
-            "platformioTarget": "custom-board",
-            "files": [
-                {"name": "littlefs-custom-board.bin", "bytes": 100000},
-                {"name": "custom-board.bin", "bytes": 500000},
-            ],
-        }
-        path = os.path.join(tmpdir, "firmware-custom-board.mt.json")
-        with open(path, "w") as f:
-            json.dump(data, f)
-
-        rc, stdout, stderr = run_script("collect_sizes.py", [tmpdir, outfile])
-        assert rc == 0, f"collect_sizes failed: {stderr}"
-
-        with open(outfile) as f:
-            sizes = json.load(f)
-        assert sizes == {"custom-board": 500000}
-
-
-def test_collect_sizes_skips_ota_littlefs():
-    """collect_sizes ignores ota/littlefs/bleota .bin files in fallback."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        outfile = os.path.join(tmpdir, "sizes.json")
-        data = {
-            "platformioTarget": "board-x",
-            "files": [
-                {"name": "littlefs-board-x.bin", "bytes": 100000},
-                {"name": "bleota-board-x.bin", "bytes": 50000},
-                {"name": "mt-board-x-ota.bin", "bytes": 60000},
-            ],
-        }
-        path = os.path.join(tmpdir, "firmware-board-x.mt.json")
-        with open(path, "w") as f:
-            json.dump(data, f)
-
-        rc, stdout, stderr = run_script("collect_sizes.py", [tmpdir, outfile])
-        assert rc == 0
-        with open(outfile) as f:
-            sizes = json.load(f)
-        # No valid firmware .bin found, board should be absent
-        assert sizes == {}
-
-
-def test_collect_sizes_ignores_non_mt_json():
-    """collect_sizes skips non .mt.json files."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        outfile = os.path.join(tmpdir, "sizes.json")
-        # Write a valid manifest
-        manifests = {"rak4631": make_manifest("rak4631", 500000)}
-        write_manifests(tmpdir, manifests)
-        # Write a decoy file
-        with open(os.path.join(tmpdir, "readme.txt"), "w") as f:
-            f.write("not a manifest")
-
-        rc, stdout, stderr = run_script("collect_sizes.py", [tmpdir, outfile])
-        assert rc == 0
-        with open(outfile) as f:
-            sizes = json.load(f)
-        assert list(sizes.keys()) == ["rak4631"]
-
-
-def test_size_report_no_baseline():
-    """size_report with no baselines shows sizes only."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        sizes_file = os.path.join(tmpdir, "new.json")
-        with open(sizes_file, "w") as f:
-            json.dump({"heltec-v3": 1000000, "rak4631": 500000}, f)
-
-        rc, stdout, stderr = run_script("size_report.py", [sizes_file])
-        assert rc == 0, f"size_report failed: {stderr}"
-        assert "2 targets" in stdout
-        assert "no baseline available yet" in stdout
-        assert "`heltec-v3`" in stdout
-        assert "`rak4631`" in stdout
-
-
-def test_size_report_with_baseline():
-    """size_report shows deltas against a baseline."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        new_file = os.path.join(tmpdir, "new.json")
-        old_file = os.path.join(tmpdir, "old.json")
-        with open(new_file, "w") as f:
-            json.dump({"heltec-v3": 1050000, "rak4631": 500000, "tbeam": 800000}, f)
-        with open(old_file, "w") as f:
-            json.dump({"heltec-v3": 1000000, "rak4631": 500000, "tbeam": 810000}, f)
-
-        rc, stdout, stderr = run_script(
-            "size_report.py", [new_file, "--baseline", f"develop:{old_file}"]
-        )
-        assert rc == 0, f"size_report failed: {stderr}"
-        assert "3 targets" in stdout
-        assert "1 increased" in stdout
-        assert "1 decreased" in stdout
-        # heltec-v3 grew by 50000
-        assert "📈" in stdout
-        # tbeam shrank by 10000
-        assert "📉" in stdout
-        # rak4631 unchanged
-        assert "vs `develop`" in stdout
-
-
-def test_size_report_multiple_baselines():
-    """size_report handles multiple baselines."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        new_file = os.path.join(tmpdir, "new.json")
-        dev_file = os.path.join(tmpdir, "develop.json")
-        master_file = os.path.join(tmpdir, "master.json")
-        with open(new_file, "w") as f:
-            json.dump({"board-a": 100000}, f)
-        with open(dev_file, "w") as f:
-            json.dump({"board-a": 95000}, f)
-        with open(master_file, "w") as f:
-            json.dump({"board-a": 90000}, f)
-
-        rc, stdout, stderr = run_script(
-            "size_report.py",
-            [new_file, "--baseline", f"develop:{dev_file}", "--baseline", f"master:{master_file}"],
-        )
-        assert rc == 0, f"size_report failed: {stderr}"
-        assert "vs `develop`" in stdout
-        assert "vs `master`" in stdout
-
-
-def test_size_report_new_target_no_baseline_entry():
-    """size_report handles targets not present in baseline (new boards)."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        new_file = os.path.join(tmpdir, "new.json")
-        old_file = os.path.join(tmpdir, "old.json")
-        with open(new_file, "w") as f:
-            json.dump({"new-board": 300000, "existing": 500000}, f)
-        with open(old_file, "w") as f:
-            json.dump({"existing": 500000}, f)
-
-        rc, stdout, stderr = run_script(
-            "size_report.py", [new_file, "--baseline", f"develop:{old_file}"]
-        )
-        assert rc == 0, f"size_report failed: {stderr}"
-        assert "`new-board`" in stdout
-        assert "no changes" in stdout  # only existing is compared, delta=0
-
-
-def test_size_report_all_unchanged():
-    """size_report shows 'no changes' when all sizes match."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        sizes_file = os.path.join(tmpdir, "sizes.json")
-        with open(sizes_file, "w") as f:
-            json.dump({"board-a": 100000, "board-b": 200000}, f)
-
-        rc, stdout, stderr = run_script(
-            "size_report.py", [sizes_file, "--baseline", f"develop:{sizes_file}"]
-        )
-        assert rc == 0, f"size_report failed: {stderr}"
-        assert "no changes" in stdout
-
-
-def test_collect_sizes_bad_args():
-    """collect_sizes exits with error on wrong arg count."""
-    rc, stdout, stderr = run_script("collect_sizes.py", [])
-    assert rc == 1
-    assert "Usage" in stderr
-
-
-def test_size_report_bad_baseline_format():
-    """size_report exits with error on malformed --baseline."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        sizes_file = os.path.join(tmpdir, "sizes.json")
-        with open(sizes_file, "w") as f:
-            json.dump({"x": 1}, f)
-
-        rc, stdout, stderr = run_script(
-            "size_report.py", [sizes_file, "--baseline", "no-colon-here"]
-        )
-        assert rc == 1
-        assert "LABEL:PATH" in stderr
-
-
-if __name__ == "__main__":
-    tests = [v for k, v in globals().items() if k.startswith("test_")]
-    passed = 0
-    failed = 0
-    for test in tests:
-        try:
-            test()
-            print(f"  PASS: {test.__name__}")
-            passed += 1
-        except AssertionError as e:
-            print(f"  FAIL: {test.__name__}: {e}")
-            failed += 1
-        except Exception as e:
-            print(f"  ERROR: {test.__name__}: {type(e).__name__}: {e}")
-            failed += 1
-
-    print(f"\n{passed} passed, {failed} failed out of {passed + failed}")
-    sys.exit(1 if failed else 0)

debian/control

@@ -14,7 +14,6 @@ Build-Depends: debhelper-compat (= 13),
                g++,
                pkg-config,
                libyaml-cpp-dev,
-               libjsoncpp-dev,
                libgpiod-dev,
                libbluetooth-dev,
                libusb-1.0-0-dev,

extra_scripts/nrf52_lto.py

@@ -1,138 +0,0 @@
-#!/usr/bin/env python3
-# trunk-ignore-all(ruff/F821)
-# trunk-ignore-all(flake8/F821)
-#
-# Whole-image LTO for nrf52840 (~-60KB; ~-23KB beyond src-only LTO), EXCEPT the objects
-# that own interrupt/exception handlers.
-#
-# Every ISR is referenced only from the assembly vector table (gcc_startup_nrf52840.S),
-# which LTO cannot see -> whole-program LTO judges the handlers dead, removes them, and
-# the weak `b .` Default_Handler stubs prevail -> the IRQ lands in an infinite loop and the
-# chip hangs (or the peripheral silently stalls). Compiling the handler-bearing objects
-# WITHOUT LTO lets ordinary linking keep the strong handlers; everything else stays LTO'd:
-#   - framework core (/FrameworkArduino/, /cores/nRF5/): every nrfx ISR + the FreeRTOS
-#     SVC/PendSV port.
-#   - TinyUSB nrf port (Adafruit_TinyUSB_nrf.cpp): USBD_IRQHandler (USB data path).
-#   - library .cpp files that own a vector ISR (would otherwise be silently dropped):
-#       bluefruit.cpp     -> SD_EVT/SWI2_EGU2  (SoftDevice BLE-event delivery -- advertising
-#                            hangs without it)
-#       Wire_nRF52.cpp    -> SPIM0/TWIM0 + SPIM1/TWIM1 (interrupt-driven I2C/SPI)
-#       PDM.cpp           -> PDM_IRQHandler   (PDM microphone)
-#       RotaryEncoder.cpp -> QDEC_IRQHandler  (hardware quadrature/rotary encoder)
-#
-# A post-link guard (bottom of this file) fails the build if a critical handler was dropped
-# anyway -- so a future deps bump or a new ISR-owning library becomes a red build, not a field
-# hang. To hunt a dropped ISR by hand: nm the .elf for `_IRQHandler$` symbols marked `W`, then
-# grep the libs/framework for who defines them.
-#
-# HW-validated: RAK4631 (SX1262) + muzi-base (LR1121).
-import glob
-import os
-
-Import("env")
-
-env.Append(LINKFLAGS=["-flto", "-flto-partition=1to1"])
-
-# The -fno-lto re-compiles below run with the global env, which lacks the framework's
-# bundled-library include dirs -- and those libs cross-include each other (Wire pulls in
-# Adafruit_TinyUSB.h, which pulls in SPI.h, ...). Add every bundled-lib dir (+ its src/) so
-# the re-compiles resolve without chasing headers one at a time.
-_fw = env.PioPlatform().get_package_dir("framework-arduinoadafruitnrf52") or ""
-_extra_inc = []
-for _d in sorted(glob.glob(os.path.join(_fw, "libraries", "*"))):
-    if os.path.isdir(_d):
-        _extra_inc.append(_d)
-        if os.path.isdir(os.path.join(_d, "src")):
-            _extra_inc.append(os.path.join(_d, "src"))
-
-FRAMEWORK = ("/FrameworkArduino/", "/cores/nRF5/")
-USB_ISR = "Adafruit_TinyUSB_nrf"  # USBD_IRQHandler
-# Library .cpp files that define vector-table ISRs (the rest of their lib stays LTO'd):
-LIB_ISR = ("/bluefruit.cpp", "/Wire_nRF52.cpp", "/PDM.cpp", "/RotaryEncoder.cpp")
-
-
-def _no_lto(node):
-    try:
-        path = node.get_abspath()
-    except Exception:
-        path = str(node)
-    path = path.replace(
-        "\\", "/"
-    )  # normalize Windows backslashes so matches work cross-platform
-    if (
-        USB_ISR in path
-        or any(s in path for s in FRAMEWORK)
-        or any(s in path for s in LIB_ISR)
-    ):
-        return env.Object(
-            node,
-            CCFLAGS=env["CCFLAGS"] + ["-fno-lto"],
-            CPPPATH=env["CPPPATH"] + _extra_inc,
-        )
-    return node
-
-
-env.AddBuildMiddleware(_no_lto)
-
-
-# --- post-link guard: catch a dropped ISR handler at build time (CI footgun protection) ----
-# After every link, fail the build if one of these critical vector-table handlers resolved to
-# the weak `b .` Default_Handler stub -- i.e. LTO (or a deps bump, or a new ISR-owning library
-# that nobody added to LIB_ISR) silently dropped it. A dropped handler hangs the chip the
-# instant that IRQ fires; this turns a field hang into a red build. CI builds every nrf52840
-# target, so this runs on every PR automatically. All five are used by every nrf52840
-# Meshtastic build; if a board deliberately stops using one, edit this tuple on purpose.
-_REQUIRED_STRONG = (
-    "SWI2_EGU2_IRQHandler",  # SoftDevice BLE event (SD_EVT) -- advertising & connections
-    "GPIOTE_IRQHandler",  # GPIO interrupts: radio DIO + buttons
-    "RTC1_IRQHandler",  # FreeRTOS scheduler tick
-    "USBD_IRQHandler",  # USB CDC (serial console + 1200bps DFU trigger)
-    "POWER_CLOCK_IRQHandler",  # HF/LF clock + power (HFCLK start for radio & SoftDevice)
-)
-
-_tc = env.PioPlatform().get_package_dir("toolchain-gccarmnoneeabi") or ""
-_NM = os.path.join(_tc, "bin", "arm-none-eabi-nm")
-if not os.path.isfile(_NM):
-    _NM = "arm-none-eabi-nm"  # fall back to PATH
-
-
-def _assert_isr_handlers_survived(source, target, env):
-    import subprocess
-    import sys
-
-    try:
-        # Resolve the ELF at build time; target[0] is the buildprog alias, not the file.
-        elf = env.subst("$BUILD_DIR/${PROGNAME}.elf")
-        out = subprocess.check_output([_NM, elf], universal_newlines=True)
-    except Exception as exc:  # tooling hiccup: warn loudly, don't wedge the build
-        print("nrf52_lto: WARNING - ISR-handler guard skipped (nm failed: %s)" % exc)
-        return
-    # nm line: "<addr> <type> <symbol>". type 'T'/'t' = strong (good); 'W'/'w' = weak stub.
-    kind = {}
-    for line in out.split("\n"):
-        f = line.split()
-        if len(f) >= 3 and f[-1].endswith("_IRQHandler"):
-            kind[f[-1]] = f[-2]
-    dropped = [h for h in _REQUIRED_STRONG if kind.get(h, "W").upper() != "T"]
-    if dropped:
-        sys.stderr.write(
-            "\n*** nrf52 LTO guard: interrupt handler(s) DROPPED: %s ***\n"
-            "Each resolved to the weak Default_Handler stub, so the chip hangs when that IRQ\n"
-            "fires. Compile the .cpp that defines the handler with -fno-lto by adding it to\n"
-            "LIB_ISR in extra_scripts/nrf52_lto.py. Find the owner of FOO_IRQHandler with:\n"
-            "  grep -rl FOO_IRQHandler <framework-arduinoadafruitnrf52>/{libraries,cores}\n\n"
-            % ", ".join(dropped)
-        )
-        from SCons.Script import Exit
-
-        Exit(1)  # canonical SCons build-abort -> red build
-    print(
-        "nrf52_lto: ISR-handler guard OK -- %d critical handlers strong"
-        % len(_REQUIRED_STRONG)
-    )
-
-
-# Attach to the phony "buildprog" alias, NOT the .elf file node: SCons can skip a post-action
-# on a file target during an incremental relink (observed), but the buildprog alias runs every
-# build -- so the guard fires on local incremental rebuilds and clean CI builds alike.
-env.AddPostAction("buildprog", _assert_isr_handlers_survived)

mcp-server/run-tests.sh

@@ -191,12 +191,10 @@ echo
 # PASS/FAIL — every hardware test would SKIP with "role not present". We
 # narrow to tests/unit explicitly so the summary reads as "no hardware,
 # unit suite only" instead of "big skip count looks suspicious".
-# Keep terminal output condensed (`-q -r fE`) so skip-heavy runs do not print
-# each skipped test in full; skip counts still appear in pytest's summary.
 if [[ -z $DETECTED && $# -eq 0 ]]; then
 	echo "[pre-flight] no supported devices detected; running unit tier only."
 	echo
-	exec "$VENV_PY" -m pytest tests/unit -q -r fE --report-log=tests/reportlog.jsonl
+	exec "$VENV_PY" -m pytest tests/unit -v --report-log=tests/reportlog.jsonl
 fi
 
 # Default pytest args when the user passed none. Power users can invoke
@@ -212,13 +210,11 @@ fi
 # skipping half the hardware tests with "not baked with session profile"
 # errors. Power users who know their hardware is current and want to shave
 # those seconds can pass `--assume-baked` explicitly.
-# Defaults also use condensed reporting (`-q -r fE`) to avoid listing every
-# skipped test verbatim while still surfacing failures/errors and summary data.
 if [[ $# -eq 0 ]]; then
 	set -- tests/ \
 		--html=tests/report.html --self-contained-html \
 		--junitxml=tests/junit.xml \
-		-q -r fE --tb=short
+		-v --tb=short
 fi
 
 # UI tier requires opencv-python-headless (and ideally easyocr). If it's

meshtasticd.spec.rpkg

@@ -34,7 +34,6 @@ BuildRequires: python3dist(grpcio-tools)
 BuildRequires: git-core
 BuildRequires: gcc-c++
 BuildRequires: pkgconfig(yaml-cpp)
-BuildRequires: pkgconfig(jsoncpp)
 BuildRequires: pkgconfig(libgpiod)
 BuildRequires: pkgconfig(bluez)
 BuildRequires: pkgconfig(libusb-1.0)

platformio.ini

@@ -208,10 +208,16 @@ lib_deps =
 	https://github.com/adafruit/Adafruit_BMP3XX/archive/refs/tags/2.1.6.zip
 	# renovate: datasource=github-tags depName=Adafruit MAX1704X packageName=adafruit/Adafruit_MAX1704X
 	https://github.com/adafruit/Adafruit_MAX1704X/archive/refs/tags/1.0.3.zip
+	# renovate: datasource=github-tags depName=Adafruit SHTC3 packageName=adafruit/Adafruit_SHTC3
+	https://github.com/adafruit/Adafruit_SHTC3/archive/refs/tags/1.0.2.zip
 	# renovate: datasource=github-tags depName=Adafruit LPS2X packageName=adafruit/Adafruit_LPS2X
 	https://github.com/adafruit/Adafruit_LPS2X/archive/refs/tags/2.0.6.zip
+	# renovate: datasource=github-tags depName=Adafruit SHT31 packageName=adafruit/Adafruit_SHT31
+	https://github.com/adafruit/Adafruit_SHT31/archive/refs/tags/2.2.2.zip
 	# renovate: datasource=github-tags depName=Adafruit VEML7700 packageName=adafruit/Adafruit_VEML7700
 	https://github.com/adafruit/Adafruit_VEML7700/archive/refs/tags/2.1.6.zip
+	# renovate: datasource=github-tags depName=Adafruit SHT4x packageName=adafruit/Adafruit_SHT4X
+	https://github.com/adafruit/Adafruit_SHT4X/archive/refs/tags/1.0.5.zip
 	# renovate: datasource=github-tags depName=SparkFun Qwiic Scale NAU7802 packageName=sparkfun/SparkFun_Qwiic_Scale_NAU7802_Arduino_Library
 	https://github.com/sparkfun/SparkFun_Qwiic_Scale_NAU7802_Arduino_Library/archive/refs/tags/v1.0.6.zip
 	# renovate: datasource=custom.pio depName=ClosedCube OPT3001 packageName=closedcube/library/ClosedCube OPT3001

src/DisplayFormatters.cpp

@@ -51,12 +51,6 @@ const char *DisplayFormatters::getModemPresetDisplayName(meshtastic_Config_LoRaC
     case PRESET(NARROW_SLOW):
         return useShortName ? "NarS" : "NarrowSlow";
         break;
-    case PRESET(TINY_FAST):
-        return useShortName ? "TinyF" : "TinyFast";
-        break;
-    case PRESET(TINY_SLOW):
-        return useShortName ? "TinyS" : "TinySlow";
-        break;
     default:
         return useShortName ? "Custom" : "Invalid";
         break;

src/MessageStore.cpp

@@ -1,5 +1,5 @@
 #include "configuration.h"
-#if HAS_SCREEN || defined(MESHTASTIC_INCLUDE_NICHE_GRAPHICS)
+#if HAS_SCREEN
 #include "FSCommon.h"
 #include "MessageStore.h"
 #include "NodeDB.h"

src/MessageStore.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#if HAS_SCREEN || defined(MESHTASTIC_INCLUDE_NICHE_GRAPHICS)
+#if HAS_SCREEN
 
 // Disable debug logging entirely on release builds of HELTEC_MESH_SOLAR for space constraints
 #if defined(HELTEC_MESH_SOLAR)

src/Power.cpp

@@ -14,7 +14,6 @@
  * For more information, see: https://meshtastic.org/
  */
 #include "power.h"
-#include "BluetoothCommon.h"
 #include "MessageStore.h"
 #include "NodeDB.h"
 #include "PowerFSM.h"
@@ -963,10 +962,6 @@ void Power::readPowerStatus()
         lastLogTime = millis();
     }
     newStatus.notifyObservers(&powerStatus2);
-
-    // Mirror battery level to the BLE Battery Service (0x2A19); the platform layer clamps and dedupes.
-    if (hasBattery == OptTrue)
-        updateBatteryLevel(powerStatus2.getBatteryChargePercent());
 #ifdef DEBUG_HEAP
     if (lastheap != memGet.getFreeHeap()) {
         // Use stack-allocated buffer to avoid heap allocations in monitoring code

src/RF95Configuration.h

@@ -1,16 +1,6 @@
 // TODO refactor this out with better radio configuration system
 #ifdef USE_RF95
-
-#ifndef RF95_RESET
 #define RF95_RESET LORA_RESET
-#endif
-
-#ifndef RF95_IRQ
-#define RF95_IRQ LORA_DIO0 // on SX1262 version this is a no connect DIO0
-#endif
-
-#ifndef RF95_DIO1
+#define RF95_IRQ LORA_DIO0  // on SX1262 version this is a no connect DIO0
 #define RF95_DIO1 LORA_DIO1 // Note: not really used for RF95, but used for pure SX127x
 #endif
-
-#endif

src/RedirectablePrint.cpp

@@ -51,7 +51,7 @@ size_t RedirectablePrint::write(uint8_t c)
 size_t RedirectablePrint::vprintf(const char *logLevel, const char *format, va_list arg)
 {
     va_list copy;
-#if ARCH_PORTDUINO
+#if ENABLE_JSON_LOGGING || ARCH_PORTDUINO
     static char printBuf[512];
 #else
     static char printBuf[160];

src/concurrency/Lock.cpp

@@ -1,6 +1,7 @@
 #include "Lock.h"
 #include "configuration.h"
 #include <cassert>
+#include <logging.h>
 
 namespace concurrency
 {
@@ -33,13 +34,33 @@ void Lock::unlock()
     }
 }
 #else
-Lock::Lock() {}
+Lock::Lock()
+{
+    pthread_mutex_init(&mutex, NULL);
+}
 
-Lock::~Lock() {}
+void Lock::lock()
+{
+    if (locked) {
+        LOG_INFO("Attempt to lock an already locked Lock!");
+    }
+    pthread_mutex_lock(&mutex);
+    locked = true;
 
-void Lock::lock() {}
+    if (console)
+        LOG_WARN("Lock");
+}
 
-void Lock::unlock() {}
+void Lock::unlock()
+{
+    pthread_mutex_unlock(&mutex);
+    locked = false;
+}
+
+Lock::~Lock()
+{
+    pthread_mutex_destroy(&mutex);
+}
 #endif
 
 } // namespace concurrency

src/concurrency/Lock.h

@@ -30,6 +30,9 @@ class Lock
   private:
 #ifdef HAS_FREE_RTOS
     SemaphoreHandle_t handle;
+#else
+    pthread_mutex_t mutex;
+    bool locked = false;
 #endif
 };
 

src/configuration.h

@@ -31,11 +31,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #endif
 #if __has_include("SensorRtcHelper.hpp")
 #include "SensorRtcHelper.hpp"
-// SensorLib defines isBitSet as a macro; undefine it here to avoid conflicts
-// with the SparkFun MMC5983MA library, which has a class method of the same name.
-#ifdef isBitSet
-#undef isBitSet
-#endif
 #endif
 
 /* Offer chance for variant-specific defines */

src/gps/GPS.cpp

@@ -17,10 +17,7 @@
 #include "main.h" // pmu_found
 #include "sleep.h"
 
-#include "FSCommon.h"
 #include "GPSUpdateScheduling.h"
-#include "SPILock.h"
-#include "SafeFile.h"
 #include "cas.h"
 #include "ubx.h"
 
@@ -74,67 +71,6 @@ static struct uBloxGnssModelInfo {
 #define GPS_SOL_EXPIRY_MS 5000 // in millis. give 1 second time to combine different sentences. NMEA Frequency isn't higher anyway
 #define NMEA_MSG_GXGSA "GNGSA" // GSA message (GPGSA, GNGSA etc)
 
-namespace
-{
-// Versioned on-disk record for persisted GPS probe results.
-constexpr uint32_t GPS_PROBE_CACHE_MAGIC = 0x47504348UL; // "GPCH"
-constexpr uint16_t GPS_PROBE_CACHE_VERSION = 1;
-constexpr const char *GPS_PROBE_CACHE_FILE = "/prefs/gps_probe_cache.dat";
-
-struct GPSProbeCacheRecord {
-    uint32_t magic;
-    uint16_t version;
-    uint16_t reserved;
-    uint32_t baud;
-    uint8_t model;
-};
-
-bool isValidGnssModel(uint8_t model)
-{
-    // Keep persisted values bounded to known enum range.
-    return model <= static_cast<uint8_t>(GNSS_MODEL_CM121);
-}
-
-bool isValidProbeBaud(uint32_t baud)
-{
-    // Conservative sanity range for UART baud values.
-    return baud >= 1200 && baud <= 921600;
-}
-
-template <typename T> bool sawNmeaSentenceAtBaud(T *serialGps, uint32_t timeoutMs)
-{
-    // Lightweight passive check: look for at least one complete
-    // "$...,<field>\n" style NMEA sentence.
-    const uint32_t deadline = millis() + timeoutMs;
-    bool sawDollar = false;
-    bool sawComma = false;
-
-    while ((int32_t)(millis() - deadline) < 0) {
-        while (serialGps->available()) {
-            char c = static_cast<char>(serialGps->read());
-            if (c == '$') {
-                sawDollar = true;
-                sawComma = false;
-                continue;
-            }
-            if (c == ',') {
-                sawComma = true;
-            }
-            if (c == '\n' || c == '\r') {
-                if (sawDollar && sawComma) {
-                    return true;
-                }
-                sawDollar = false;
-                sawComma = false;
-            }
-        }
-        delay(10);
-    }
-
-    return false;
-}
-} // namespace
-
 // For logging
 static const char *getGPSPowerStateString(GPSPowerState state)
 {
@@ -556,201 +492,6 @@ static const int rareSerialSpeeds[3] = {4800, 57600, GPS_BAUDRATE};
 #define GPS_PROBETRIES 2
 #endif
 
-bool GPS::loadProbeCache()
-{
-#ifdef FSCom
-    // Load the last known-good GPS model/baud pair so we can avoid a full probe
-    // sweep on every boot.
-    triedProbeCache = true; // Latch this boot's load attempt, even if no cache.
-    GPSProbeCacheRecord record = {};
-    size_t bytesRead = 0;
-
-    spiLock->lock();
-    auto file = FSCom.open(GPS_PROBE_CACHE_FILE, FILE_O_READ);
-    if (!file) {
-        spiLock->unlock();
-        return false;
-    }
-    bytesRead = file.read(reinterpret_cast<uint8_t *>(&record), sizeof(record));
-    file.close();
-    spiLock->unlock();
-
-    const bool headerValid = (bytesRead == sizeof(record)) && (record.magic == GPS_PROBE_CACHE_MAGIC) &&
-                             (record.version == GPS_PROBE_CACHE_VERSION) && (record.reserved == 0U);
-    if (!headerValid || !isValidGnssModel(record.model) || !isValidProbeBaud(record.baud)) {
-        clearProbeCache(); // Drop corrupt/invalid cache so next boot can
-                           // recover.
-        return false;
-    }
-
-    cachedProbeBaud = static_cast<int32_t>(record.baud);
-    cachedProbeModel = static_cast<GnssModel_t>(record.model);
-    hasProbeCache = true;
-    triedProbeCache = false;
-    LOG_INFO("Loaded cached GPS probe: baud=%u", record.baud);
-    return true;
-#else
-    return false;
-#endif
-}
-
-void GPS::clearProbeCache()
-{
-    // Invalidate in-memory and on-disk cache so next boot is forced to do a
-    // full probe.
-    hasProbeCache = false;
-    triedProbeCache = true;
-    cachedProbeBaud = 0;
-    cachedProbeModel = GNSS_MODEL_UNKNOWN;
-#ifdef FSCom
-    spiLock->lock();
-    if (FSCom.exists(GPS_PROBE_CACHE_FILE)) {
-        FSCom.remove(GPS_PROBE_CACHE_FILE);
-    }
-    spiLock->unlock();
-#endif
-}
-
-bool GPS::saveProbeCache() const
-{
-#ifdef FSCom
-    if (gnssModel == GNSS_MODEL_UNKNOWN || !isValidGnssModel(static_cast<uint8_t>(gnssModel)) ||
-        !isValidProbeBaud(detectedBaud)) {
-        return false;
-    }
-
-    spiLock->lock();
-    FSCom.mkdir("/prefs");
-    spiLock->unlock();
-    GPSProbeCacheRecord record = {
-        GPS_PROBE_CACHE_MAGIC, GPS_PROBE_CACHE_VERSION, 0, static_cast<uint32_t>(detectedBaud), static_cast<uint8_t>(gnssModel),
-    };
-
-    auto file = SafeFile(GPS_PROBE_CACHE_FILE, true);
-    spiLock->lock();
-    const size_t written = file.write(reinterpret_cast<const uint8_t *>(&record), sizeof(record));
-    spiLock->unlock();
-    return (written == sizeof(record)) && file.close();
-#else
-    return false;
-#endif
-}
-
-bool GPS::verifyCachedProbePresence()
-{
-    if (!hasProbeCache || cachedProbeModel == GNSS_MODEL_UNKNOWN || !isValidProbeBaud(cachedProbeBaud)) {
-        return false;
-    }
-
-#if defined(ARCH_NRF52) || defined(ARCH_PORTDUINO) || defined(ARCH_STM32WL)
-    _serial_gps->end();
-    _serial_gps->begin(cachedProbeBaud);
-#elif defined(ARCH_RP2040)
-    _serial_gps->end();
-    _serial_gps->setFIFOSize(256);
-    _serial_gps->begin(cachedProbeBaud);
-#else
-    if (_serial_gps->baudRate() != cachedProbeBaud) {
-        LOG_DEBUG("Set GPS Baud to %i (cached verify)", cachedProbeBaud);
-        _serial_gps->updateBaudRate(cachedProbeBaud);
-    }
-#endif
-
-    // Before trusting cached model/baud, require either active model-specific
-    // response or passive NMEA flow.
-    clearBuffer();
-    bool present = false;
-
-    // Model-specific "active ping" checks to avoid false stale decisions on
-    // modules that start streaming late.
-    const char *cachedProbeModelName = "UNKNOWN";
-    switch (cachedProbeModel) {
-    case GNSS_MODEL_MTK:
-        cachedProbeModelName = "L76K/MTK";
-        _serial_gps->write("$PCAS06,0*1B\r\n");
-        present = (getACK("$GPTXT,01,01,02,SW=", 700) == GNSS_RESPONSE_OK);
-        break;
-    case GNSS_MODEL_MTK_L76B:
-        cachedProbeModelName = "L76B";
-    case GNSS_MODEL_MTK_PA1010D:
-        if (cachedProbeModel == GNSS_MODEL_MTK_PA1010D)
-            cachedProbeModelName = "PA1010D";
-    case GNSS_MODEL_MTK_PA1616S:
-        if (cachedProbeModel == GNSS_MODEL_MTK_PA1616S)
-            cachedProbeModelName = "PA1616S";
-    case GNSS_MODEL_LS20031:
-        if (cachedProbeModel == GNSS_MODEL_LS20031)
-            cachedProbeModelName = "LS20031";
-        _serial_gps->write("$PMTK605*31\r\n");
-        present = (getACK("$PMTK705", 900) == GNSS_RESPONSE_OK);
-        break;
-    case GNSS_MODEL_AG3335:
-        cachedProbeModelName = "AG3335";
-    case GNSS_MODEL_AG3352:
-        if (cachedProbeModel == GNSS_MODEL_AG3352)
-            cachedProbeModelName = "AG3352";
-        _serial_gps->write("$PAIR021*39\r\n");
-        present = (getACK("$PAIR021,", 900) == GNSS_RESPONSE_OK);
-        break;
-    case GNSS_MODEL_ATGM336H:
-        cachedProbeModelName = "ATGM336H";
-        _serial_gps->write("$PCAS06,1*1A\r\n");
-        present = (getACK("$GPTXT,01,01,02,HW=ATGM", 900) == GNSS_RESPONSE_OK);
-        break;
-    case GNSS_MODEL_UC6580:
-        cachedProbeModelName = "UC6580/UM600";
-        _serial_gps->write("$PDTINFO\r\n");
-        present = (getACK("UC6580", 900) == GNSS_RESPONSE_OK) || (getACK("UM600", 900) == GNSS_RESPONSE_OK);
-        break;
-    case GNSS_MODEL_CM121:
-        cachedProbeModelName = "CM121";
-        _serial_gps->write("$PDTINFO\r\n");
-        present = (getACK("CM121", 900) == GNSS_RESPONSE_OK);
-        break;
-    case GNSS_MODEL_UBLOX6:
-    case GNSS_MODEL_UBLOX7:
-    case GNSS_MODEL_UBLOX8:
-    case GNSS_MODEL_UBLOX9:
-    case GNSS_MODEL_UBLOX10: {
-        if (cachedProbeModel == GNSS_MODEL_UBLOX6)
-            cachedProbeModelName = "U-blox 6";
-        else if (cachedProbeModel == GNSS_MODEL_UBLOX7)
-            cachedProbeModelName = "U-blox 7";
-        else if (cachedProbeModel == GNSS_MODEL_UBLOX8)
-            cachedProbeModelName = "U-blox 8";
-        else if (cachedProbeModel == GNSS_MODEL_UBLOX9)
-            cachedProbeModelName = "U-blox 9";
-        else if (cachedProbeModel == GNSS_MODEL_UBLOX10)
-            cachedProbeModelName = "U-blox 10";
-
-        uint8_t cfg_rate[] = {0xB5, 0x62, 0x06, 0x08, 0x00, 0x00, 0x00, 0x00};
-        UBXChecksum(cfg_rate, sizeof(cfg_rate));
-        _serial_gps->write(cfg_rate, sizeof(cfg_rate));
-        present = (getACK(0x06, 0x08, 900) != GNSS_RESPONSE_NONE);
-        break;
-    }
-    default:
-        break;
-    }
-
-    if (!present) {
-        // Some modules may not respond to probes while still streaming NMEA, so
-        // allow a passive fallback check.
-        present = sawNmeaSentenceAtBaud(_serial_gps, 3000);
-    }
-    if (!present) {
-        LOG_WARN("Cached GPS probe is stale (%s @ %d), clearing cache", cachedProbeModelName, cachedProbeBaud);
-        clearProbeCache();
-        cachedProbeFailedThisBoot = true;
-        return false;
-    }
-
-    detectedBaud = cachedProbeBaud;
-    gnssModel = cachedProbeModel;
-    LOG_INFO("Using cached GPS probe: %s @ %d", cachedProbeModelName, detectedBaud);
-    return true;
-}
-
 /**
  * @brief  Setup the GPS based on the model detected.
  *  We detect the GPS by cycling through a set of baud rates, first common then rare.
@@ -762,46 +503,25 @@ bool GPS::setup()
 {
     if (!didSerialInit) {
         int msglen = 0;
-        if (cachedProbeFailedThisBoot) {
-            // If cached verification failed, suppress further probing until
-            // reboot.
-            didSerialInit = true;
-            return true;
-        }
-
         if (tx_gpio && gnssModel == GNSS_MODEL_UNKNOWN) {
-            if (!hasProbeCache && !triedProbeCache) {
-                (void)loadProbeCache();
-            }
-
-            if (hasProbeCache && !triedProbeCache) {
-                triedProbeCache = true;
-                if (!verifyCachedProbePresence()) {
-                    // Cache was stale and got wiped; skip scanning this boot
-                    // and let next boot do a full probe.
-                    didSerialInit = true;
-                    return true;
-                }
-            } else if (probeTries < GPS_PROBETRIES) {
-                // No usable cache: walk common baud rates first.
+            if (probeTries < GPS_PROBETRIES) {
                 gnssModel = probe(serialSpeeds[speedSelect]);
-                if (gnssModel != GNSS_MODEL_UNKNOWN) {
-                    detectedBaud = serialSpeeds[speedSelect];
-                } else if (currentStep == 0 && ++speedSelect == array_count(serialSpeeds)) {
-                    speedSelect = 0;
-                    ++probeTries;
+                if (gnssModel == GNSS_MODEL_UNKNOWN) {
+                    if (currentStep == 0 && ++speedSelect == array_count(serialSpeeds)) {
+                        speedSelect = 0;
+                        ++probeTries;
+                    }
                 }
             }
             // Rare Serial Speeds
 #ifndef CONFIG_IDF_TARGET_ESP32C6
-            else if (probeTries == GPS_PROBETRIES) {
-                // Then try less common baud rates before giving up.
+            if (probeTries == GPS_PROBETRIES) {
                 gnssModel = probe(rareSerialSpeeds[speedSelect]);
-                if (gnssModel != GNSS_MODEL_UNKNOWN) {
-                    detectedBaud = rareSerialSpeeds[speedSelect];
-                } else if (currentStep == 0 && ++speedSelect == array_count(rareSerialSpeeds)) {
-                    LOG_WARN("Give up on GPS probe and set to %d", GPS_BAUDRATE);
-                    return true;
+                if (gnssModel == GNSS_MODEL_UNKNOWN) {
+                    if (currentStep == 0 && ++speedSelect == array_count(rareSerialSpeeds)) {
+                        LOG_WARN("Give up on GPS probe and set to %d", GPS_BAUDRATE);
+                        return true;
+                    }
                 }
             }
 #endif
@@ -809,7 +529,6 @@ bool GPS::setup()
 
         if (gnssModel != GNSS_MODEL_UNKNOWN) {
             setConnected();
-            (void)saveProbeCache();
         } else {
             return false;
         }
@@ -1383,12 +1102,6 @@ int32_t GPS::runOnce()
         if (!setup())
             return currentDelay; // Setup failed, re-run in two seconds
 
-        if (cachedProbeFailedThisBoot || gnssModel == GNSS_MODEL_UNKNOWN) {
-            LOG_WARN("GPS not detected at cached settings; marked not present "
-                     "for this boot");
-            return disable();
-        }
-
         // We have now loaded our saved preferences from flash
         if (config.position.gps_mode != meshtastic_Config_PositionConfig_GpsMode_ENABLED) {
             return disable();

src/gps/GPS.h

@@ -155,19 +155,8 @@ class GPS : private concurrency::OSThread
      * @return true if we've acquired a new location
      */
     virtual bool lookForLocation();
-    // Load persisted GPS model+baud from /prefs.
-    bool loadProbeCache();
-    // Clear persisted GPS model+baud cache.
-    void clearProbeCache();
-    // Persist the currently detected GPS model+baud.
-    bool saveProbeCache() const;
-    // Verify the cached model+baud still maps to a live GPS device.
-    bool verifyCachedProbePresence();
 
     GnssModel_t gnssModel = GNSS_MODEL_UNKNOWN;
-    int32_t detectedBaud = GPS_BAUDRATE;
-    int32_t cachedProbeBaud = 0;
-    GnssModel_t cachedProbeModel = GNSS_MODEL_UNKNOWN;
 
     TinyGPSPlus reader;
     uint8_t fixQual = 0; // fix quality from GPGGA
@@ -189,12 +178,6 @@ class GPS : private concurrency::OSThread
 
     uint8_t speedSelect = 0;
     uint8_t probeTries = 0;
-    // Cache file is successfully loaded.
-    bool hasProbeCache = false;
-    // Ensures cached probe is attempted once per boot.
-    bool triedProbeCache = false;
-    // Latched when cached presence check fails
-    bool cachedProbeFailedThisBoot = false;
 
     /**
      * hasValidLocation - indicates that the position variables contain a complete

src/graphics/Screen.cpp

@@ -50,7 +50,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "MeshService.h"
 #include "MessageStore.h"
 #include "RadioLibInterface.h"
-#include "SPILock.h"
 #include "error.h"
 #include "gps/GeoCoord.h"
 #include "gps/RTC.h"
@@ -656,10 +655,6 @@ void Screen::setup()
         brightness = uiconfig.screen_brightness;
     }
 
-    // Restore which frames the user has hidden (persisted across reboots).
-    // Must happen before the first setFrames().
-    loadFrameVisibility();
-
     // Detect OLED subtype (if supported by board variant)
 #ifdef AutoOLEDWire_h
     if (isAUTOOled)
@@ -1421,9 +1416,6 @@ void Screen::toggleFrameVisibility(const std::string &frameName)
     if (frameName == "chirpy") {
         hiddenFrames.chirpy = !hiddenFrames.chirpy;
     }
-
-    // Save the new visibility state so it survives a reboot.
-    saveFrameVisibility();
 }
 
 bool Screen::isFrameHidden(const std::string &frameName) const
@@ -1462,167 +1454,6 @@ bool Screen::isFrameHidden(const std::string &frameName) const
     return false;
 }
 
-// ---------------------------------------------------------------------------
-// Frame visibility persistence
-//
-// The set of hideable frames varies by build (USE_EINK, HAS_GPS, ...), so we
-// serialize to a fixed bitmask where each frame name owns a permanent bit
-// position. Bits for frames that don't exist in the current build are simply
-// left untouched, which keeps the saved file portable across firmware variants.
-// ---------------------------------------------------------------------------
-namespace
-{
-static const char *frameVisibilityFileName = "/prefs/framevis";
-constexpr uint32_t FRAMEVIS_MAGIC = 0x53495646; // "FVIS" little-endian
-constexpr uint8_t FRAMEVIS_VERSION = 1;
-
-// Permanent bit assignments. Never renumber these; only append new ones.
-enum FrameVisBit : uint8_t {
-    FVBIT_TEXT_MESSAGE = 0,
-    FVBIT_WAYPOINT = 1,
-    FVBIT_WIFI = 2,
-    FVBIT_SYSTEM = 3,
-    FVBIT_HOME = 4,
-    FVBIT_CLOCK = 5,
-    FVBIT_NODELIST_NODES = 6,
-    FVBIT_NODELIST_LOCATION = 7,
-    FVBIT_NODELIST_LASTHEARD = 8,
-    FVBIT_NODELIST_HOPSIGNAL = 9,
-    FVBIT_NODELIST_DISTANCE = 10,
-    FVBIT_NODELIST_BEARINGS = 11,
-    FVBIT_GPS = 12,
-    FVBIT_LORA = 13,
-    FVBIT_SHOW_FAVORITES = 14,
-    FVBIT_CHIRPY = 15,
-};
-
-struct __attribute__((packed)) FrameVisFile {
-    uint32_t magic;
-    uint8_t version;
-    uint32_t mask;
-};
-
-inline void setBit(uint32_t &mask, uint8_t bit, bool value)
-{
-    if (value)
-        mask |= (1UL << bit);
-    else
-        mask &= ~(1UL << bit);
-}
-
-inline bool getBit(uint32_t mask, uint8_t bit)
-{
-    return (mask & (1UL << bit)) != 0;
-}
-} // namespace
-
-uint32_t Screen::packHiddenFrames() const
-{
-    uint32_t mask = 0;
-    setBit(mask, FVBIT_TEXT_MESSAGE, hiddenFrames.textMessage);
-    setBit(mask, FVBIT_WAYPOINT, hiddenFrames.waypoint);
-    setBit(mask, FVBIT_WIFI, hiddenFrames.wifi);
-    setBit(mask, FVBIT_SYSTEM, hiddenFrames.system);
-    setBit(mask, FVBIT_HOME, hiddenFrames.home);
-    setBit(mask, FVBIT_CLOCK, hiddenFrames.clock);
-#ifndef USE_EINK
-    setBit(mask, FVBIT_NODELIST_NODES, hiddenFrames.nodelist_nodes);
-    setBit(mask, FVBIT_NODELIST_LOCATION, hiddenFrames.nodelist_location);
-#endif
-#ifdef USE_EINK
-    setBit(mask, FVBIT_NODELIST_LASTHEARD, hiddenFrames.nodelist_lastheard);
-    setBit(mask, FVBIT_NODELIST_HOPSIGNAL, hiddenFrames.nodelist_hopsignal);
-    setBit(mask, FVBIT_NODELIST_DISTANCE, hiddenFrames.nodelist_distance);
-#endif
-#if HAS_GPS
-#ifdef USE_EINK
-    setBit(mask, FVBIT_NODELIST_BEARINGS, hiddenFrames.nodelist_bearings);
-#endif
-    setBit(mask, FVBIT_GPS, hiddenFrames.gps);
-#endif
-    setBit(mask, FVBIT_LORA, hiddenFrames.lora);
-    setBit(mask, FVBIT_SHOW_FAVORITES, hiddenFrames.show_favorites);
-    setBit(mask, FVBIT_CHIRPY, hiddenFrames.chirpy);
-    return mask;
-}
-
-void Screen::applyHiddenFramesMask(uint32_t mask)
-{
-    hiddenFrames.textMessage = getBit(mask, FVBIT_TEXT_MESSAGE);
-    hiddenFrames.waypoint = getBit(mask, FVBIT_WAYPOINT);
-    hiddenFrames.wifi = getBit(mask, FVBIT_WIFI);
-    hiddenFrames.system = getBit(mask, FVBIT_SYSTEM);
-    hiddenFrames.home = getBit(mask, FVBIT_HOME);
-    hiddenFrames.clock = getBit(mask, FVBIT_CLOCK);
-#ifndef USE_EINK
-    hiddenFrames.nodelist_nodes = getBit(mask, FVBIT_NODELIST_NODES);
-    hiddenFrames.nodelist_location = getBit(mask, FVBIT_NODELIST_LOCATION);
-#endif
-#ifdef USE_EINK
-    hiddenFrames.nodelist_lastheard = getBit(mask, FVBIT_NODELIST_LASTHEARD);
-    hiddenFrames.nodelist_hopsignal = getBit(mask, FVBIT_NODELIST_HOPSIGNAL);
-    hiddenFrames.nodelist_distance = getBit(mask, FVBIT_NODELIST_DISTANCE);
-#endif
-#if HAS_GPS
-#ifdef USE_EINK
-    hiddenFrames.nodelist_bearings = getBit(mask, FVBIT_NODELIST_BEARINGS);
-#endif
-    hiddenFrames.gps = getBit(mask, FVBIT_GPS);
-#endif
-    hiddenFrames.lora = getBit(mask, FVBIT_LORA);
-    hiddenFrames.show_favorites = getBit(mask, FVBIT_SHOW_FAVORITES);
-    hiddenFrames.chirpy = getBit(mask, FVBIT_CHIRPY);
-}
-
-void Screen::loadFrameVisibility()
-{
-#ifdef FSCom
-    spiLock->lock();
-    auto file = FSCom.open(frameVisibilityFileName, FILE_O_READ);
-    if (file) {
-        FrameVisFile data{};
-        bool ok = file.read((uint8_t *)&data, sizeof(data)) == sizeof(data) && data.magic == FRAMEVIS_MAGIC &&
-                  data.version == FRAMEVIS_VERSION;
-        file.close();
-        spiLock->unlock();
-        if (ok) {
-            applyHiddenFramesMask(data.mask);
-            LOG_INFO("Loaded frame visibility (mask 0x%08x)", data.mask);
-        } else {
-            LOG_WARN("Frame visibility file invalid, keeping defaults");
-        }
-        return;
-    }
-    spiLock->unlock();
-    LOG_DEBUG("No saved frame visibility, using defaults");
-#endif
-}
-
-void Screen::saveFrameVisibility()
-{
-#ifdef FSCom
-    spiLock->lock();
-    FSCom.mkdir("/prefs");
-    if (FSCom.exists(frameVisibilityFileName))
-        FSCom.remove(frameVisibilityFileName);
-
-    auto file = FSCom.open(frameVisibilityFileName, FILE_O_WRITE);
-    if (file) {
-        FrameVisFile data{};
-        data.magic = FRAMEVIS_MAGIC;
-        data.version = FRAMEVIS_VERSION;
-        data.mask = packHiddenFrames();
-        file.write((uint8_t *)&data, sizeof(data));
-        file.flush();
-        file.close();
-        LOG_INFO("Saved frame visibility (mask 0x%08x)", data.mask);
-    } else {
-        LOG_WARN("Failed to open %s for writing", frameVisibilityFileName);
-    }
-    spiLock->unlock();
-#endif
-}
-
 void Screen::handleStartFirmwareUpdateScreen()
 {
     LOG_DEBUG("Show firmware screen");

src/graphics/Screen.h

@@ -12,7 +12,7 @@
 #define getStringCenteredX(s) ((SCREEN_WIDTH - display->getStringWidth(s)) / 2)
 namespace graphics
 {
-enum notificationTypeEnum { none, text_banner, selection_picker, node_picker, number_picker, hex_picker, text_input };
+enum notificationTypeEnum { none, text_banner, selection_picker, node_picker, number_picker, text_input };
 
 struct BannerOverlayOptions {
     const char *message;
@@ -623,11 +623,6 @@ class Screen : public concurrency::OSThread
     void toggleFrameVisibility(const std::string &frameName);
     bool isFrameHidden(const std::string &frameName) const;
 
-    // Persist / restore which frames are hidden, across reboots.
-    // Stored as a single uint32 bitmask in /prefs (see Screen.cpp for the format).
-    void loadFrameVisibility();
-    void saveFrameVisibility();
-
 #ifdef USE_EINK
     /// Draw an image to remain on E-Ink display after screen off
     void setScreensaverFrames(FrameCallback einkScreensaver = NULL);
@@ -743,11 +738,6 @@ class Screen : public concurrency::OSThread
         bool chirpy = true;
     } hiddenFrames;
 
-    // Convert hiddenFrames to a uint32 bitmask. Bit positions are fixed per
-    // frame name (see Screen.cpp).
-    uint32_t packHiddenFrames() const;
-    void applyHiddenFramesMask(uint32_t mask);
-
     /// Try to start drawing ASAP
     void setFastFramerate();
 

src/graphics/SharedUIDisplay.cpp

@@ -578,11 +578,7 @@ void drawCommonFooter(OLEDDisplay *display, int16_t x, int16_t y)
 #endif
 
     display->setColor(BLACK);
-#if GRAPHICS_TFT_COLORING_ENABLED
     display->fillRect(0, footerY, SCREEN_WIDTH, footerH);
-#else
-    display->fillRect(0, footerY, connection_icon_width + 1, footerH);
-#endif
     display->setColor(WHITE);
     if (currentResolution == ScreenResolution::High) {
         const int bytesPerRow = (connection_icon_width + 7) / 8;

src/graphics/draw/ClockRenderer.cpp

@@ -183,13 +183,9 @@ void drawDigitalClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int1
     static float segmentHeight = SEGMENT_HEIGHT * 0.75f;
 
     if (!scaleInitialized) {
-#ifdef DISPLAY_FORCE_SMALL_FONTS
-        float screenwidth_target_ratio = 0.70f; // Target 70% of display width (adjustable)
-#else
         float screenwidth_target_ratio = 0.80f; // Target 80% of display width (adjustable)
-#endif
-        float max_scale = 3.5f; // Safety limit to avoid runaway scaling
-        float step = 0.05f;     // Step increment per iteration
+        float max_scale = 3.5f;                 // Safety limit to avoid runaway scaling
+        float step = 0.05f;                     // Step increment per iteration
 
         float target_width = display->getWidth() * screenwidth_target_ratio;
         float target_height =

src/graphics/draw/MenuHandler.cpp

@@ -126,7 +126,6 @@ void launchReplyForMessage(const StoredMessage &message, bool freetext)
 
 menuHandler::screenMenus menuHandler::menuQueue = MenuNone;
 uint32_t menuHandler::pickedNodeNum = 0;
-meshtastic_Config_LoRaConfig_RegionCode menuHandler::pendingRegion = meshtastic_Config_LoRaConfig_RegionCode_UNSET;
 bool test_enabled = false;
 uint8_t test_count = 0;
 
@@ -175,48 +174,6 @@ void menuHandler::OnboardMessage()
     screen->showOverlayBanner(bannerOptions);
 }
 
-static void applyLoraRegion(meshtastic_Config_LoRaConfig_RegionCode region, bool isHam)
-{
-    config.lora.region = region;
-    config.lora.channel_num = 0; // Reset to default channel
-
-    // Reconcile the preset with the explicitly chosen region: a preset locked to another
-    // region would leave config.lora invalid until applyModemConfig() repairs it with
-    // error/critical-error side effects — or, for the swappable EU trio, the clamp would
-    // flip the region right back. The user picked the region, so the preset follows it.
-    const RegionInfo *newRegion = getRegion(region);
-    if (config.lora.use_preset && !newRegion->supportsPreset(config.lora.modem_preset)) {
-        LOG_INFO("Preset %s not available in %s, using default %s",
-                 DisplayFormatters::getModemPresetDisplayName(config.lora.modem_preset, false, true), newRegion->name,
-                 DisplayFormatters::getModemPresetDisplayName(newRegion->getDefaultPreset(), false, true));
-        config.lora.modem_preset = newRegion->getDefaultPreset();
-    }
-
-    if (isHam && adminModule) {
-        meshtastic_HamParameters hamParams = meshtastic_HamParameters_init_zero;
-        strncpy(hamParams.call_sign, "N0CALL", sizeof(hamParams.call_sign) - 1);
-        strncpy(hamParams.short_name, "N0CL", sizeof(hamParams.short_name));
-        hamParams.tx_power = config.lora.tx_power;
-        hamParams.frequency = config.lora.override_frequency;
-        adminModule->handleSetHamMode(hamParams);
-    }
-    auto changes = SEGMENT_CONFIG;
-#if !(MESHTASTIC_EXCLUDE_PKI_KEYGEN || MESHTASTIC_EXCLUDE_PKI)
-    if (crypto) {
-        crypto->ensurePkiKeys(config.security, owner);
-    }
-#endif
-    initRegion();
-    if (getEffectiveDutyCycle() < 100) {
-        config.lora.ignore_mqtt = true;
-    }
-    if (strncmp(moduleConfig.mqtt.root, default_mqtt_root, strlen(default_mqtt_root)) == 0) {
-        snprintf(moduleConfig.mqtt.root, sizeof(moduleConfig.mqtt.root), "%s/%s", default_mqtt_root, myRegion->name);
-        changes |= SEGMENT_MODULECONFIG;
-    }
-    service->reloadConfig(changes);
-}
-
 void menuHandler::LoraRegionPicker(uint32_t duration)
 {
     static const LoraRegionOption regionOptions[] = {
@@ -249,10 +206,6 @@ void menuHandler::LoraRegionPicker(uint32_t duration)
         {"KZ_863", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_KZ_863},
         {"NP_865", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_NP_865},
         {"BR_902", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_BR_902},
-        {"ITU1_2M (144-146)", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_ITU1_2M},
-        {"ITU2_2M (144-148)", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_ITU2_2M},
-        {"ITU3_2M (144-148)", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_ITU3_2M},
-        {"ITU2_125CM (220-225)", OptionsAction::Select, meshtastic_Config_LoRaConfig_RegionCode_ITU2_125CM},
 
     };
 
@@ -275,34 +228,37 @@ void menuHandler::LoraRegionPicker(uint32_t duration)
                 return;
             }
 
-            // Guard: without a reboot, reconfigure() applies the region directly, so reject
-            // regions this node can't use up front: unrecognized codes, licensed-only regions,
-            // and radio hardware mismatches (2.4 GHz vs sub-GHz) — the same checks the admin
-            // set-config path applies, but side-effect-free: ignoring a menu selection should
-            // not record a critical error or notify clients. getRadio() used to catch hardware
-            // mismatches post-reboot only.
-            auto candidateLora = config.lora;
-            candidateLora.region = selectedRegion;
-            char regionErr[160];
-            if (!RadioInterface::checkConfigRegion(candidateLora, regionErr, sizeof(regionErr))) {
-                LOG_WARN("Ignoring region selection: %s", regionErr);
+            // Guard: without a reboot, reconfigure() applies the region directly.
+            // Reject LORA_24 on sub-GHz-only hardware — getRadio() used to catch this post-reboot.
+            // TODO: change this to either use the validateLoraConfig() logic or at least check the region for wideLora
+            // rather than a hardcoded check for LORA_24.
+            if (selectedRegion == meshtastic_Config_LoRaConfig_RegionCode_LORA_24 &&
+                !(RadioLibInterface::instance && RadioLibInterface::instance->wideLora())) {
+                LOG_WARN("Radio hardware does not support 2.4 GHz; ignoring region selection");
                 return;
             }
 
-            bool hamMode = getRegion(selectedRegion)->profile->licensedOnly;
-            if (hamMode) {
-                LOG_INFO("User chose an amateur radio mode region");
-                pendingRegion = selectedRegion;
-                menuQueue = HamModeConfirm;
-                screen->runNow();
-            } else if (owner.is_licensed) {
-                LOG_INFO("Licensed user chose a non-ham region; prompting to revert licensed mode");
-                pendingRegion = selectedRegion;
-                menuQueue = LicensedToNormalConfirm;
-                screen->runNow();
-            } else {
-                applyLoraRegion(selectedRegion, false);
+            config.lora.region = selectedRegion;
+            auto changes = SEGMENT_CONFIG;
+
+#if !(MESHTASTIC_EXCLUDE_PKI_KEYGEN || MESHTASTIC_EXCLUDE_PKI)
+            if (crypto) {
+                crypto->ensurePkiKeys(config.security, owner);
             }
+#endif
+            config.lora.tx_enabled = true;
+            initRegion();
+            if (getEffectiveDutyCycle() < 100) {
+                config.lora.ignore_mqtt = true; // Ignore MQTT by default if region has a duty cycle limit
+            }
+
+            if (strncmp(moduleConfig.mqtt.root, default_mqtt_root, strlen(default_mqtt_root)) == 0) {
+                //  Default broker is in use, so subscribe to the appropriate MQTT root topic for this region
+                sprintf(moduleConfig.mqtt.root, "%s/%s", default_mqtt_root, myRegion->name);
+                changes |= SEGMENT_MODULECONFIG;
+            }
+
+            service->reloadConfig(changes);
         });
 
     bannerOptions.durationMs = duration;
@@ -319,38 +275,6 @@ void menuHandler::LoraRegionPicker(uint32_t duration)
     screen->showOverlayBanner(bannerOptions);
 }
 
-void menuHandler::hamModeConfirmMenu()
-{
-    static const char *confirmOptions[] = {"No", "Yes"};
-    BannerOverlayOptions confirmBanner;
-    confirmBanner.message = "I confirm I am a\nlicensed amateur\nradio operator";
-    confirmBanner.optionsArrayPtr = confirmOptions;
-    confirmBanner.optionsCount = 2;
-    confirmBanner.bannerCallback = [](int selected) {
-        if (selected == 1)
-            applyLoraRegion(pendingRegion, true);
-    };
-    screen->showOverlayBanner(confirmBanner);
-}
-
-void menuHandler::licensedToNormalConfirmMenu()
-{
-    static const char *confirmOptions[] = {"Keep licensed", "Revert to Normal"};
-    BannerOverlayOptions confirmBanner;
-    confirmBanner.message = "Revert licensed\nmode? This will\nre-enable encryption.";
-    confirmBanner.optionsArrayPtr = confirmOptions;
-    confirmBanner.optionsCount = 2;
-    confirmBanner.bannerCallback = [](int selected) {
-        if (selected == 1) {
-            owner.is_licensed = false;
-            config.lora.override_duty_cycle = false;
-            service->reloadOwner(false);
-        }
-        applyLoraRegion(pendingRegion, false);
-    };
-    screen->showOverlayBanner(confirmBanner);
-}
-
 void menuHandler::deviceRolePicker()
 {
     static const char *optionsArray[] = {"Back", "Client", "Client Mute", "Lost and Found", "Tracker"};
@@ -2894,12 +2818,6 @@ void menuHandler::handleMenuSwitch(OLEDDisplay *display)
     case ThemeMenu:
         themeMenu();
         break;
-    case HamModeConfirm:
-        hamModeConfirmMenu();
-        break;
-    case LicensedToNormalConfirm:
-        licensedToNormalConfirmMenu();
-        break;
     }
     menuQueue = MenuNone;
 }

src/graphics/draw/MenuHandler.h

@@ -55,13 +55,10 @@ class menuHandler
         FrameToggles,
         DisplayUnits,
         MessageBubblesMenu,
-        ThemeMenu,
-        HamModeConfirm,
-        LicensedToNormalConfirm
+        ThemeMenu
     };
     static screenMenus menuQueue;
     static uint32_t pickedNodeNum; // node selected by NodePicker for ManageNodeMenu
-    static meshtastic_Config_LoRaConfig_RegionCode pendingRegion;
 
     static void OnboardMessage();
     static void LoraRegionPicker(uint32_t duration = 30000);
@@ -114,8 +111,6 @@ class menuHandler
     static void messageBubblesMenu();
     static void themeMenu();
     static void textMessageMenu();
-    static void hamModeConfirmMenu();
-    static void licensedToNormalConfirmMenu();
 
   private:
     static void saveUIConfig();

src/graphics/draw/NotificationRenderer.cpp

@@ -66,15 +66,6 @@ uint32_t pow_of_10(uint32_t n)
     return ret;
 }
 
-uint64_t pow_of_16(uint32_t n)
-{
-    uint64_t ret = 1;
-    for (uint32_t i = 0; i < n; i++) {
-        ret *= 16ULL;
-    }
-    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] = {};
@@ -268,9 +259,6 @@ void NotificationRenderer::drawBannercallback(OLEDDisplay *display, OLEDDisplayU
     case notificationTypeEnum::number_picker:
         drawNumberPicker(display, state);
         break;
-    case notificationTypeEnum::hex_picker:
-        drawHexPicker(display, state);
-        break;
     }
 }
 
@@ -357,105 +345,6 @@ void NotificationRenderer::drawNumberPicker(OLEDDisplay *display, OLEDDisplayUiS
     drawNotificationBox(display, state, linePointers, totalLines, 0);
 }
 
-void NotificationRenderer::drawHexPicker(OLEDDisplay *display, OLEDDisplayUiState *state)
-{
-    const char *lineStarts[MAX_LINES + 1] = {0};
-    uint16_t lineCount = 0;
-
-    // Parse lines
-    char *alertEnd = alertBannerMessage + strnlen(alertBannerMessage, sizeof(alertBannerMessage));
-    lineStarts[lineCount] = alertBannerMessage;
-
-    // Find lines
-    while ((lineCount < MAX_LINES) && (lineStarts[lineCount] < alertEnd)) {
-        lineStarts[lineCount + 1] = std::find((char *)lineStarts[lineCount], alertEnd, '\n');
-        if (lineStarts[lineCount + 1][0] == '\n')
-            lineStarts[lineCount + 1] += 1;
-        lineCount++;
-    }
-    // modulo to extract
-    uint8_t this_digit = (currentNumber % (pow_of_16(numDigits - curSelected))) / (pow_of_16(numDigits - curSelected - 1));
-    // Handle input
-    if (inEvent.inputEvent == INPUT_BROKER_UP || inEvent.inputEvent == INPUT_BROKER_ALT_PRESS ||
-        inEvent.inputEvent == INPUT_BROKER_UP_LONG) {
-        if (this_digit == 15) {
-            currentNumber -= 15 * (pow_of_16(numDigits - curSelected - 1));
-        } else {
-            currentNumber += (pow_of_16(numDigits - curSelected - 1));
-        }
-    } else if (inEvent.inputEvent == INPUT_BROKER_DOWN || inEvent.inputEvent == INPUT_BROKER_USER_PRESS ||
-               inEvent.inputEvent == INPUT_BROKER_DOWN_LONG) {
-        if (this_digit == 0) {
-            currentNumber += 15 * (pow_of_16(numDigits - curSelected - 1));
-        } else {
-            currentNumber -= (pow_of_16(numDigits - curSelected - 1));
-        }
-    } else if (inEvent.inputEvent == INPUT_BROKER_ANYKEY) {
-        if (inEvent.kbchar > 47 && inEvent.kbchar < 58) { // have a digit
-            currentNumber -= this_digit * (pow_of_16(numDigits - curSelected - 1));
-            currentNumber += (inEvent.kbchar - 48) * (pow_of_16(numDigits - curSelected - 1));
-            curSelected++;
-        }
-    } else if (inEvent.inputEvent == INPUT_BROKER_SELECT || inEvent.inputEvent == INPUT_BROKER_RIGHT) {
-        curSelected++;
-    } else if (inEvent.inputEvent == INPUT_BROKER_LEFT) {
-        curSelected--;
-    } else if ((inEvent.inputEvent == INPUT_BROKER_CANCEL || inEvent.inputEvent == INPUT_BROKER_ALT_LONG) &&
-               alertBannerUntil != 0) {
-        resetBanner();
-        return;
-    }
-    if (curSelected == static_cast<int8_t>(numDigits)) {
-        alertBannerCallback(currentNumber);
-        resetBanner();
-        return;
-    }
-
-    inEvent.inputEvent = INPUT_BROKER_NONE;
-    if (alertBannerMessage[0] == '\0')
-        return;
-
-    uint16_t totalLines = lineCount + 2;
-    const char *linePointers[totalLines + 1] = {0}; // this is sort of a dynamic allocation
-
-    // copy the linestarts to display to the linePointers holder
-    for (uint16_t i = 0; i < lineCount; i++) {
-        linePointers[i] = lineStarts[i];
-    }
-    std::string digits = " ";
-    std::string arrowPointer = " ";
-    for (uint16_t i = 0; i < numDigits; i++) {
-        // Modulo minus modulo to return just the current number
-        uint8_t digitValue = (currentNumber % (pow_of_16(numDigits - i))) / (pow_of_16(numDigits - i - 1));
-        if (digitValue < 10) {
-            digits += std::to_string(digitValue) + " ";
-        } else if (digitValue == 10) {
-            digits += "A ";
-        } else if (digitValue == 11) {
-            digits += "B ";
-        } else if (digitValue == 12) {
-            digits += "C ";
-        } else if (digitValue == 13) {
-            digits += "D ";
-        } else if (digitValue == 14) {
-            digits += "E ";
-        } else if (digitValue == 15) {
-            digits += "F ";
-        }
-
-        if (curSelected == i) {
-            arrowPointer += "^ ";
-        } else {
-            arrowPointer += "_ ";
-        }
-    }
-
-    linePointers[lineCount++] = digits.c_str();
-    linePointers[lineCount++] = arrowPointer.c_str();
-
-    drawNotificationBox(display, state, linePointers, totalLines, 0);
-}
-
 void NotificationRenderer::drawNodePicker(OLEDDisplay *display, OLEDDisplayUiState *state)
 {
     static uint32_t selectedNodenum = 0;

src/graphics/draw/NotificationRenderer.h

@@ -42,7 +42,6 @@ class NotificationRenderer
     static void drawBannercallback(OLEDDisplay *display, OLEDDisplayUiState *state);
     static void drawAlertBannerOverlay(OLEDDisplay *display, OLEDDisplayUiState *state);
     static void drawNumberPicker(OLEDDisplay *display, OLEDDisplayUiState *state);
-    static void drawHexPicker(OLEDDisplay *display, OLEDDisplayUiState *state);
     static void drawNodePicker(OLEDDisplay *display, OLEDDisplayUiState *state);
     static void drawTextInput(OLEDDisplay *display, OLEDDisplayUiState *state);
     static void drawNotificationBox(OLEDDisplay *display, OLEDDisplayUiState *state, const char *lines[MAX_LINES + 1],

src/graphics/draw/UIRenderer.cpp

@@ -79,12 +79,10 @@ static inline void transformNeedlePoint(float localX, float localY, float sinHea
     outY = static_cast<int16_t>(y);
 }
 
-#if GRAPHICS_TFT_COLORING_ENABLED
 static float getCompassRingAngleOffset(float heading)
 {
     return (uiconfig.compass_mode != meshtastic_CompassMode_FIXED_RING) ? -heading : 0.0f;
 }
-#endif
 
 static inline StandardCompassNeedlePoints computeStandardCompassNeedlePoints(int16_t compassX, int16_t compassY,
                                                                              uint16_t compassDiam, float headingRadian,
@@ -1144,16 +1142,11 @@ void UIRenderer::drawDeviceFocused(OLEDDisplay *display, OLEDDisplayUiState *sta
     bool origBold = config.display.heading_bold;
     config.display.heading_bold = false;
 
-    if (!config.lora.tx_enabled) {
-        const char *txdisabled = "Transmit Disabled";
-        display->drawString(x, getTextPositions(display)[line], txdisabled);
+    // Display Region and Channel Utilization
+    if (currentResolution == ScreenResolution::UltraLow) {
+        drawNodes(display, x, getTextPositions(display)[line] + 2, nodeStatus, -1, false, "online");
     } else {
-        // Display Region and Channel Utilization
-        if (currentResolution == ScreenResolution::UltraLow) {
-            drawNodes(display, x, getTextPositions(display)[line] + 2, nodeStatus, -1, false, "online");
-        } else {
-            drawNodes(display, x + 1, getTextPositions(display)[line] + 2, nodeStatus, -1, false, "online");
-        }
+        drawNodes(display, x + 1, getTextPositions(display)[line] + 2, nodeStatus, -1, false, "online");
     }
     char uptimeStr[32] = "";
     if (currentResolution != ScreenResolution::UltraLow) {

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

@@ -6,12 +6,15 @@
     FastEPD buffer format: 1bpp, horizontal bytes, MSB = leftmost pixel, 1 = white
 
     Both formats share the same pixel layout and polarity (1 = white, 0 = black).
-    The InkHUD safe-area buffer (928×508) is copied into the centre of the physical
+    The InkHUD safe-area buffer (944×523) is copied into the centre of the physical
     960×540 FastEPD buffer so content clears the panel's inactive edge border.
     See ED047TC1.h for the H_OFFSET_BYTES / V_OFFSET_TOP / V_OFFSET_BOTTOM constants.
 
 */
 
+// Ruler diagnostic — uncomment to draw calibration lines at each physical edge.
+// #define EINK_EDGE_LINES
+
 #ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
 #ifdef T5_S3_EPAPER_PRO
 
@@ -209,6 +212,35 @@ void ED047TC1::update(uint8_t *imageData, UpdateTypes type)
         memcpy(dstRow, srcRow, srcRowBytes);
     }
 
+#ifdef EINK_EDGE_LINES
+    // Draw a 1px black box at the exact boundary of the safe area within the
+    // physical buffer. If the margins are correct, all 4 lines should be
+    // fully visible and right at the edge of the usable display area.
+
+    auto setPixelBlack = [&](uint32_t col, uint32_t row) { cur[row * dstRowBytes + col / 8] &= ~(0x80 >> (col % 8)); };
+
+    const uint32_t safeX = H_OFFSET_BYTES * 8;
+    const uint32_t safeY = V_OFFSET_TOP;
+    const uint32_t safeW = DISPLAY_WIDTH;
+    const uint32_t safeH = DISPLAY_HEIGHT;
+
+    // Top edge: horizontal line at safeY
+    for (uint32_t col = safeX; col < safeX + safeW; col++)
+        setPixelBlack(col, safeY);
+
+    // Bottom edge: horizontal line at safeY + safeH - 1
+    for (uint32_t col = safeX; col < safeX + safeW; col++)
+        setPixelBlack(col, safeY + safeH - 1);
+
+    // Left edge: vertical line at safeX
+    for (uint32_t row = safeY; row < safeY + safeH; row++)
+        setPixelBlack(safeX, row);
+
+    // Right edge: vertical line at safeX + safeW - 1
+    for (uint32_t row = safeY; row < safeY + safeH; row++)
+        setPixelBlack(safeX + safeW - 1, row);
+#endif
+
     if (type == FULL) {
         epaper->fullUpdate(CLEAR_SLOW, false);
         epaper->backupPlane(); // Sync pPrevious so next partialUpdate has a correct baseline

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

@@ -18,9 +18,9 @@
     V_OFFSET_TOP and V_OFFSET_BOTTOM (vertical, pixel rows) to position it.
 
     Changing these constants shifts content inward from each physical edge:
-        H_OFFSET_BYTES = 2   →  16px left margin, 16px right margin  (960 – 16 – 16 = 928)
-        V_OFFSET_TOP   = 16  →  16px top margin
-        V_OFFSET_BOTTOM = 16 →  16px bottom margin                   (540 – 16 – 16 = 508)
+        H_OFFSET_BYTES = 1  →  8px left margin, 8px right margin   (960 – 8 – 8   = 944)
+        V_OFFSET_TOP   = 9  →  9px top margin  (asymmetric: top ≠ bottom)
+        V_OFFSET_BOTTOM = 8 →  8px bottom margin                    (540 – 9 – 8   = 523)
 
 */
 
@@ -61,13 +61,13 @@ class ED047TC1 : public EInk
     //
     // Calibrated by flashing a 1px border box and adjusting until all 4 sides are visible.
 
-    static constexpr uint16_t DISPLAY_WIDTH = 928;  // 960 − H_OFFSET_BYTES×8 − right_margin (16+16 = 32px)
-    static constexpr uint16_t DISPLAY_HEIGHT = 508; // 540 − V_OFFSET_TOP − V_OFFSET_BOTTOM (16+16 = 32px)
+    static constexpr uint16_t DISPLAY_WIDTH = 944;  // 960 − H_OFFSET_BYTES×8 − right_margin (8+8 = 16px)
+    static constexpr uint16_t DISPLAY_HEIGHT = 523; // 540 − V_OFFSET_TOP − V_OFFSET_BOTTOM (9+8 = 17px)
 
-    static constexpr uint8_t H_OFFSET_BYTES = 2;   // visual TOP  : 16px physical left margin
-                                                   // visual BOTTOM: 960−16−928=16px physical right margin
-    static constexpr uint8_t V_OFFSET_TOP = 16;    // visual RIGHT : 16px physical top margin
-    static constexpr uint8_t V_OFFSET_BOTTOM = 16; // visual LEFT  : 16px physical bottom margin
+    static constexpr uint8_t H_OFFSET_BYTES = 1;  // visual TOP  : 8px physical left margin
+                                                  // visual BOTTOM: 960−8−944=8px physical right margin
+    static constexpr uint8_t V_OFFSET_TOP = 9;    // visual RIGHT : CONFIRMED OK
+    static constexpr uint8_t V_OFFSET_BOTTOM = 8; // visual LEFT  : 8px physical bottom margin
 
     static constexpr UpdateTypes supported = static_cast<UpdateTypes>(FULL | FAST);
 

src/graphics/niche/InkHUD/Applets/System/Menu/MenuAction.h

@@ -66,10 +66,6 @@ enum MenuAction {
     SET_REGION_BR_902,
     SET_REGION_EU_866,
     SET_REGION_NARROW_868,
-    SET_REGION_ITU1_2M,
-    SET_REGION_ITU2_2M,
-    SET_REGION_ITU3_2M,
-    SET_REGION_ITU2_125CM,
     // Device Roles
     SET_ROLE_CLIENT,
     SET_ROLE_CLIENT_MUTE,
@@ -88,8 +84,6 @@ enum MenuAction {
     SET_PRESET_LITE_FAST,
     SET_PRESET_NARROW_SLOW,
     SET_PRESET_NARROW_FAST,
-    SET_PRESET_TINY_SLOW,
-    SET_PRESET_TINY_FAST,
     SET_PRESET_FROM_REGION, // Dynamic: preset chosen from region-available list
     // Timezones
     SET_TZ_US_HAWAII,

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

@@ -287,7 +287,7 @@ static void applyLoRaRegion(meshtastic_Config_LoRaConfig_RegionCode region)
     }
 
     if (strncmp(moduleConfig.mqtt.root, default_mqtt_root, strlen(default_mqtt_root)) == 0) {
-        snprintf(moduleConfig.mqtt.root, sizeof(moduleConfig.mqtt.root), "%s/%s", default_mqtt_root, myRegion->name);
+        sprintf(moduleConfig.mqtt.root, "%s/%s", default_mqtt_root, myRegion->name);
         changes |= SEGMENT_MODULECONFIG;
     }
     // Notify UI that changes are being applied
@@ -784,22 +784,6 @@ void InkHUD::MenuApplet::execute(MenuItem item)
         applyLoRaRegion(meshtastic_Config_LoRaConfig_RegionCode_EU_N_868);
         break;
 
-    case SET_REGION_ITU1_2M:
-        applyLoRaRegion(meshtastic_Config_LoRaConfig_RegionCode_ITU1_2M);
-        break;
-
-    case SET_REGION_ITU2_2M:
-        applyLoRaRegion(meshtastic_Config_LoRaConfig_RegionCode_ITU2_2M);
-        break;
-
-    case SET_REGION_ITU3_2M:
-        applyLoRaRegion(meshtastic_Config_LoRaConfig_RegionCode_ITU3_2M);
-        break;
-
-    case SET_REGION_ITU2_125CM:
-        applyLoRaRegion(meshtastic_Config_LoRaConfig_RegionCode_ITU2_125CM);
-        break;
-
     // Roles
     case SET_ROLE_CLIENT:
         applyDeviceRole(meshtastic_Config_DeviceConfig_Role_CLIENT);
@@ -850,22 +834,6 @@ void InkHUD::MenuApplet::execute(MenuItem item)
         applyLoRaPreset(PRESET(SHORT_TURBO));
         break;
 
-    case SET_PRESET_NARROW_SLOW:
-        applyLoRaPreset(PRESET(NARROW_SLOW));
-        break;
-
-    case SET_PRESET_NARROW_FAST:
-        applyLoRaPreset(PRESET(NARROW_FAST));
-        break;
-
-    case SET_PRESET_TINY_SLOW:
-        applyLoRaPreset(PRESET(TINY_SLOW));
-        break;
-
-    case SET_PRESET_TINY_FAST:
-        applyLoRaPreset(PRESET(TINY_FAST));
-        break;
-
     case SET_PRESET_FROM_REGION: {
         // cursor - 1 because index 0 is "Back"
         const uint8_t index = cursor - 1;
@@ -1501,10 +1469,6 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
         items.push_back(MenuItem("KZ 863", MenuAction::SET_REGION_KZ_863, MenuPage::EXIT));
         items.push_back(MenuItem("NP 865", MenuAction::SET_REGION_NP_865, MenuPage::EXIT));
         items.push_back(MenuItem("BR 902", MenuAction::SET_REGION_BR_902, MenuPage::EXIT));
-        items.push_back(MenuItem("ITU1_2M (144-146)", MenuAction::SET_REGION_ITU1_2M, MenuPage::EXIT));
-        items.push_back(MenuItem("ITU2_2M (144-148)", MenuAction::SET_REGION_ITU2_2M, MenuPage::EXIT));
-        items.push_back(MenuItem("ITU3_2M (144-148)", MenuAction::SET_REGION_ITU3_2M, MenuPage::EXIT));
-        items.push_back(MenuItem("ITU2_125CM (220-225)", MenuAction::SET_REGION_ITU2_125CM, MenuPage::EXIT));
         items.push_back(MenuItem("Exit", MenuPage::EXIT));
         break;
 

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

@@ -3,7 +3,6 @@
 #include "./NotificationApplet.h"
 
 #include "./Notification.h"
-#include "MessageStore.h"
 #include "graphics/niche/InkHUD/Persistence.h"
 
 #include "meshUtils.h"
@@ -232,7 +231,7 @@ std::string InkHUD::NotificationApplet::getNotificationText(uint16_t widthAvaila
         bool msgIsBroadcast = currentNotification.type == Notification::Type::NOTIFICATION_MESSAGE_BROADCAST;
 
         // Pick source of message
-        const StoredMessage *message =
+        const MessageStore::Message *message =
             msgIsBroadcast ? &inkhud->persistence->latestMessage.broadcast : &inkhud->persistence->latestMessage.dm;
 
         // Find info about the sender
@@ -262,7 +261,7 @@ std::string InkHUD::NotificationApplet::getNotificationText(uint16_t widthAvaila
                 text += hexifyNodeNum(message->sender);
 
             text += ": ";
-            text += MessageStore::getText(*message);
+            text += message->text;
         }
     }
 

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

@@ -2,8 +2,6 @@
 
 #include "./AllMessageApplet.h"
 
-#include "MessageStore.h"
-
 using namespace NicheGraphics;
 
 void InkHUD::AllMessageApplet::onActivate()
@@ -39,7 +37,7 @@ int InkHUD::AllMessageApplet::onReceiveTextMessage(const meshtastic_MeshPacket *
 void InkHUD::AllMessageApplet::onRender(bool full)
 {
     // Find newest message, regardless of whether DM or broadcast
-    StoredMessage *message;
+    MessageStore::Message *message;
     if (latestMessage->wasBroadcast)
         message = &latestMessage->broadcast;
     else
@@ -98,7 +96,7 @@ void InkHUD::AllMessageApplet::onRender(bool full)
     // ===================
 
     // Parse any non-ascii chars in the message
-    std::string text = parse(std::string(MessageStore::getText(*message)));
+    std::string text = parse(message->text);
 
     // Extra gap below the header
     int16_t textTop = headerDivY + padDivH;

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

@@ -2,8 +2,6 @@
 
 #include "./DMApplet.h"
 
-#include "MessageStore.h"
-
 using namespace NicheGraphics;
 
 void InkHUD::DMApplet::onActivate()
@@ -94,7 +92,7 @@ void InkHUD::DMApplet::onRender(bool full)
     // ===================
 
     // Parse any non-ascii chars in the message
-    std::string text = parse(std::string(MessageStore::getText(latestMessage->dm)));
+    std::string text = parse(latestMessage->dm.text);
 
     // Extra gap below the header
     int16_t textTop = headerDivY + padDivH;

src/graphics/niche/InkHUD/Applets/User/ThreadedMessage/ThreadedMessageApplet.cpp

@@ -7,9 +7,19 @@
 
 using namespace NicheGraphics;
 
+// Hard limits on how much message data to write to flash
+// Avoid filling the storage if something goes wrong
+// Normal usage should be well below this size
+constexpr uint8_t MAX_MESSAGES_SAVED = 10;
+constexpr uint32_t MAX_MESSAGE_SIZE = 250;
+
 InkHUD::ThreadedMessageApplet::ThreadedMessageApplet(uint8_t channelIndex)
     : SinglePortModule("ThreadedMessageApplet", meshtastic_PortNum_TEXT_MESSAGE_APP), channelIndex(channelIndex)
 {
+    // Create the message store
+    // Will shortly attempt to load messages from RAM, if applet is active
+    // Label (filename in flash) is set from channel index
+    store = new MessageStore("ch" + to_string(channelIndex));
 }
 
 void InkHUD::ThreadedMessageApplet::onRender(bool full)
@@ -51,24 +61,17 @@ void InkHUD::ThreadedMessageApplet::onRender(bool full)
     const uint16_t msgW = (msgR - msgL) + 1;
 
     int16_t msgB = height() - 1; // Vertical cursor for drawing. Messages are bottom-aligned to this value.
+    uint8_t i = 0;               // Index of stored message
 
-    // Iterate the global store newest-first, showing only broadcast messages on our channel
-    const auto &allMessages = messageStore.getLiveMessages();
-    int msgIdx = (int)allMessages.size() - 1;
-
-    while (msgB >= (0 - fontSmall.lineHeight()) && msgIdx >= 0) {
-
-        const StoredMessage &m = allMessages.at(msgIdx);
-
-        // Skip messages that don't belong to this channel or are DMs
-        if (m.type != MessageType::BROADCAST || m.channelIndex != channelIndex) {
-            msgIdx--;
-            continue;
-        }
+    // Loop over messages
+    // - until no messages left, or
+    // - until no part of message fits on screen
+    while (msgB >= (0 - fontSmall.lineHeight()) && i < store->messages.size()) {
 
         // Grab data for message
-        bool outgoing = (m.sender == myNodeInfo.my_node_num);
-        std::string bodyText = parse(std::string(MessageStore::getText(m))); // Parse any non-ascii chars
+        const MessageStore::Message &m = store->messages.at(i);
+        bool outgoing = (m.sender == 0) || (m.sender == myNodeInfo.my_node_num); // Own NodeNum if canned message
+        std::string bodyText = parse(m.text);                                    // Parse any non-ascii chars in the message
 
         // Cache bottom Y of message text
         // - Used when drawing vertical line alongside
@@ -149,13 +152,18 @@ void InkHUD::ThreadedMessageApplet::onRender(bool full)
         // Move cursor up: padding before next message
         msgB -= fontSmall.lineHeight() * 0.5;
 
-        msgIdx--;
+        i++;
     } // End of loop: drawing each message
 
     // Fade effect:
     // Area immediately below the divider. Overdraw with sparse white lines.
     // Make text appear to pass behind the header
     hatchRegion(0, dividerY + 1, width(), fontSmall.lineHeight() / 3, 2, WHITE);
+
+    // If we've run out of screen to draw messages, we can drop any leftover data from the queue
+    // Those messages have been pushed off the screen-top by newer ones
+    while (i < store->messages.size())
+        store->messages.pop_back();
 }
 
 // Code which runs when the applet begins running
@@ -190,8 +198,16 @@ ProcessMessage InkHUD::ThreadedMessageApplet::handleReceived(const meshtastic_Me
     if (mp.to != NODENUM_BROADCAST)
         return ProcessMessage::CONTINUE;
 
-    // Store in the global messageStore — this handles sender, timestamp, channel, text, and ack status
-    messageStore.addFromPacket(mp);
+    // Extract info into our slimmed-down "StoredMessage" type
+    MessageStore::Message newMessage;
+    newMessage.timestamp = getValidTime(RTCQuality::RTCQualityDevice, true); // Current RTC time
+    newMessage.sender = mp.from;
+    newMessage.channelIndex = mp.channel;
+    newMessage.text = std::string((const char *)mp.decoded.payload.bytes, mp.decoded.payload.size);
+
+    // Store newest message at front
+    // These records are used when rendering, and also stored in flash at shutdown
+    store->messages.push_front(newMessage);
 
     // If this was an incoming message, suggest that our applet becomes foreground, if permitted
     if (getFrom(&mp) != nodeDB->getNodeNum())
@@ -216,25 +232,37 @@ bool InkHUD::ThreadedMessageApplet::approveNotification(Notification &n)
         return true;
 }
 
-// Save messages to flash via the global messageStore.
-// The global store holds messages for all channels; no per-channel file is needed.
+// Save several recent messages to flash
+// Stores the contents of ThreadedMessageApplet::messages
+// Just enough messages to fill the display
+// Messages are packed "back-to-back", to minimize blocks of flash used
 void InkHUD::ThreadedMessageApplet::saveMessagesToFlash()
 {
-    messageStore.saveToFlash();
+    // Create a label (will become the filename in flash)
+    std::string label = "ch" + to_string(channelIndex);
+
+    store->saveToFlash();
 }
 
-// Messages are loaded once by InkHUD::begin() before applets start.
-// Nothing to do here at per-applet activation time.
+// Load recent messages to flash
+// Fills ThreadedMessageApplet::messages with previous messages
+// Just enough messages have been stored to cover the display
 void InkHUD::ThreadedMessageApplet::loadMessagesFromFlash()
 {
-    // No-op: messageStore.loadFromFlash() is called in InkHUD::begin()
+    // Create a label (will become the filename in flash)
+    std::string label = "ch" + to_string(channelIndex);
+
+    store->loadFromFlash();
 }
 
 // Code to run when device is shutting down
 // This is in addition to any onDeactivate() code, which will also run
+// Todo: implement before a reboot also
 void InkHUD::ThreadedMessageApplet::onShutdown()
 {
-    // messageStore.saveToFlash() is called centrally by Events::beforeDeepSleep / beforeReboot
+    // Save our current set of messages to flash, provided the applet isn't disabled
+    if (isActive())
+        saveMessagesToFlash();
 }
 
-#endif
+#endif

src/graphics/niche/InkHUD/Applets/User/ThreadedMessage/ThreadedMessageApplet.h

@@ -20,8 +20,8 @@ Suggest a max of two channel, to minimize fs usage?
 
 #include "configuration.h"
 
-#include "MessageStore.h"
 #include "graphics/niche/InkHUD/Applet.h"
+#include "graphics/niche/InkHUD/MessageStore.h"
 
 #include "modules/TextMessageModule.h"
 
@@ -49,6 +49,7 @@ class ThreadedMessageApplet : public Applet, public SinglePortModule
     void saveMessagesToFlash();
     void loadMessagesFromFlash();
 
+    MessageStore *store; // Messages, held in RAM for use, ready to save to flash on shutdown
     uint8_t channelIndex = 0;
 };
 

src/graphics/niche/InkHUD/Events.cpp

@@ -2,7 +2,6 @@
 
 #include "./Events.h"
 
-#include "MessageStore.h"
 #include "PowerFSM.h"
 #include "RTC.h"
 #include "buzz.h"
@@ -515,7 +514,6 @@ int InkHUD::Events::beforeReboot(void *unused)
         inkhud->persistence->saveLatestMessage();
     } else {
         NicheGraphics::clearFlashData();
-        messageStore.clearAllMessages(); // also wipe the shared message store
     }
 
     // Note: no forceUpdate call here
@@ -534,27 +532,32 @@ int InkHUD::Events::onReceiveTextMessage(const meshtastic_MeshPacket *packet)
     if (getFrom(packet) == nodeDB->getNodeNum())
         return 0;
 
-    bool isBroadcastMsg = isBroadcast(packet->to);
-    inkhud->persistence->latestMessage.wasBroadcast = isBroadcastMsg;
+    // Determine whether the message is broadcast or a DM
+    // Store this info to prevent confusion after a reboot
+    // Avoids need to compare timestamps, because of situation where "future" messages block newly received, if time not set
+    inkhud->persistence->latestMessage.wasBroadcast = isBroadcast(packet->to);
 
-    if (!isBroadcastMsg) {
-        // DMs never pass through ThreadedMessageApplet, so add them to the global store here
-        // so they survive reboots. Derive the latestMessage cache entry from the stored result.
-        inkhud->persistence->latestMessage.dm = messageStore.addFromPacket(*packet);
-    } else {
-        // Broadcasts are added to the global store by ThreadedMessageApplet::handleReceived().
-        // Here we only update the latestMessage cache used by AllMessageApplet / NotificationApplet.
-        StoredMessage &sm = inkhud->persistence->latestMessage.broadcast;
-        sm.sender = packet->from;
-        sm.timestamp = getValidTime(RTCQuality::RTCQualityDevice, true);
-        sm.channelIndex = packet->channel;
-        const char *payload = reinterpret_cast<const char *>(packet->decoded.payload.bytes);
-        size_t storedLen = packet->decoded.payload.size;
-        if (storedLen >= MAX_MESSAGE_SIZE)
-            storedLen = MAX_MESSAGE_SIZE - 1;
-        sm.textOffset = MessageStore::storeText(payload, storedLen);
-        sm.textLength = static_cast<uint16_t>(storedLen);
-    }
+    // Pick the appropriate variable to store the message in
+    MessageStore::Message *storedMessage = inkhud->persistence->latestMessage.wasBroadcast
+                                               ? &inkhud->persistence->latestMessage.broadcast
+                                               : &inkhud->persistence->latestMessage.dm;
+
+    // Store nodenum of the sender
+    // Applets can use this to fetch user data from nodedb, if they want
+    storedMessage->sender = packet->from;
+
+    // Store the time (epoch seconds) when message received
+    storedMessage->timestamp = getValidTime(RTCQuality::RTCQualityDevice, true); // Current RTC time
+
+    // Store the channel
+    // - (potentially) used to determine whether notification shows
+    // - (potentially) used to determine which applet to focus
+    storedMessage->channelIndex = packet->channel;
+
+    // Store the text
+    // Need to specify manually how many bytes, because source not null-terminated
+    storedMessage->text =
+        std::string(&packet->decoded.payload.bytes[0], &packet->decoded.payload.bytes[packet->decoded.payload.size]);
 
     return 0; // Tell caller to continue notifying other observers. (No reason to abort this event)
 }

src/graphics/niche/InkHUD/InkHUD.cpp

@@ -9,10 +9,6 @@
 #include "./SystemApplet.h"
 #include "./Tile.h"
 #include "./WindowManager.h"
-#include "FSCommon.h"
-#include "MessageStore.h"
-#include "SPILock.h"
-#include "concurrency/LockGuard.h"
 
 using namespace NicheGraphics;
 
@@ -64,102 +60,11 @@ void InkHUD::InkHUD::notifyApplyingChanges()
     }
 }
 
-// One-time migration from the old per-channel InkHUD message files (/NicheGraphics/ch*.msgs)
-// to the firmware-wide MessageStore format (/Messages_default.msgs).
-// Only runs when the new store loaded empty, meaning this is the first boot after the format change.
-// Old files are deleted once migrated.
-static void migrateOldInkHUDMessages()
-{
-#ifdef FSCom
-    bool migrated = false;
-    constexpr uint8_t MAX_CHANNELS = 8;
-    constexpr uint32_t OLD_MAX_MSG_SIZE = 250;
-
-    for (uint8_t ch = 0; ch < MAX_CHANNELS; ch++) {
-        std::string path = "/NicheGraphics/ch";
-        path += std::to_string(ch);
-        path += ".msgs";
-
-        spiLock->lock();
-        bool exists = FSCom.exists(path.c_str());
-        spiLock->unlock();
-        if (!exists)
-            continue;
-
-        concurrency::LockGuard guard(spiLock);
-
-        auto f = FSCom.open(path.c_str(), FILE_O_READ);
-        if (!f || f.size() == 0) {
-            if (f)
-                f.close();
-            FSCom.remove(path.c_str());
-            continue;
-        }
-
-        uint8_t count = 0;
-        f.readBytes(reinterpret_cast<char *>(&count), 1);
-
-        std::vector<StoredMessage> channelMsgs;
-        for (uint8_t i = 0; i < count; i++) {
-            StoredMessage sm;
-            f.readBytes(reinterpret_cast<char *>(&sm.timestamp), sizeof(sm.timestamp));
-            f.readBytes(reinterpret_cast<char *>(&sm.sender), sizeof(sm.sender));
-            f.readBytes(reinterpret_cast<char *>(&sm.channelIndex), sizeof(sm.channelIndex));
-
-            char textBuf[OLD_MAX_MSG_SIZE + 1] = {};
-            uint32_t textLen = 0;
-            char c;
-            while (textLen < OLD_MAX_MSG_SIZE) {
-                if (f.readBytes(&c, 1) != 1)
-                    break;
-                if (c == '\0')
-                    break;
-                textBuf[textLen++] = c;
-            }
-
-            sm.dest = NODENUM_BROADCAST;
-            sm.type = MessageType::BROADCAST;
-            sm.isBootRelative = false;
-            sm.ackStatus = AckStatus::ACKED;
-            size_t storedLen = (textLen >= MAX_MESSAGE_SIZE) ? MAX_MESSAGE_SIZE - 1 : textLen;
-            sm.textOffset = MessageStore::storeText(textBuf, storedLen);
-            sm.textLength = static_cast<uint16_t>(storedLen);
-
-            channelMsgs.push_back(sm);
-        }
-
-        // Old format stored newest-first (push_front); insert oldest-first for correct chronological order
-        for (int i = static_cast<int>(channelMsgs.size()) - 1; i >= 0; i--)
-            messageStore.addLiveMessage(channelMsgs[i]);
-        if (!channelMsgs.empty())
-            migrated = true;
-
-        f.close();
-        FSCom.remove(path.c_str());
-        LOG_INFO("Migrated %u messages from %s", static_cast<uint32_t>(count), path.c_str());
-    }
-
-    // Delete the old latest.msgs; the latestMessage cache will be re-derived from migrated channel messages
-    spiLock->lock();
-    if (FSCom.exists("/NicheGraphics/latest.msgs"))
-        FSCom.remove("/NicheGraphics/latest.msgs");
-    spiLock->unlock();
-
-    if (migrated) {
-        LOG_INFO("InkHUD message migration complete, saving to new format");
-        messageStore.saveToFlash();
-    }
-#endif
-}
-
 // Start InkHUD!
 // Call this only after you have configured InkHUD
 void InkHUD::InkHUD::begin()
 {
     persistence->loadSettings();
-    messageStore.loadFromFlash(); // Load persisted messages before deriving latestMessage cache
-    if (messageStore.getLiveMessages().empty())
-        migrateOldInkHUDMessages(); // First boot after format change: import old per-channel files
     persistence->loadLatestMessage();
 
     windowManager->begin();

src/graphics/niche/InkHUD/MessageStore.cpp

@@ -0,0 +1,156 @@
+#ifdef MESHTASTIC_INCLUDE_INKHUD
+
+#include "./MessageStore.h"
+
+#include "SafeFile.h"
+
+using namespace NicheGraphics;
+
+// Hard limits on how much message data to write to flash
+// Avoid filling the storage if something goes wrong
+// Normal usage should be well below this size
+constexpr uint8_t MAX_MESSAGES_SAVED = 10;
+constexpr uint32_t MAX_MESSAGE_SIZE = 250;
+
+InkHUD::MessageStore::MessageStore(const std::string &label)
+{
+    filename = "";
+    filename += "/NicheGraphics";
+    filename += "/";
+    filename += label;
+    filename += ".msgs";
+}
+
+// Write the contents of the MessageStore::messages object to flash
+// Takes the firmware's SPI lock during FS operations. Implemented for consistency, but only relevant when using SD card.
+// Need to lock and unlock around specific FS methods, as the SafeFile class takes the lock for itself internally
+void InkHUD::MessageStore::saveToFlash()
+{
+    assert(!filename.empty());
+
+#ifdef FSCom
+    // Make the directory, if doesn't already exist
+    // This is the same directory accessed by NicheGraphics::FlashData
+    spiLock->lock();
+    FSCom.mkdir("/NicheGraphics");
+    spiLock->unlock();
+
+    // Open or create the file
+    // No "full atomic": don't save then rename
+    auto f = SafeFile(filename.c_str(), false);
+
+    LOG_INFO("Saving messages in %s", filename.c_str());
+
+    // Take firmware's SPI Lock while writing
+    spiLock->lock();
+
+    // 1st byte: how many messages will be written to store
+    f.write(messages.size());
+
+    // For each message
+    for (uint8_t i = 0; i < messages.size() && i < MAX_MESSAGES_SAVED; i++) {
+        Message &m = messages.at(i);
+        f.write(reinterpret_cast<const uint8_t *>(&m.timestamp), sizeof(m.timestamp));       // Write timestamp. 4 bytes
+        f.write(reinterpret_cast<const uint8_t *>(&m.sender), sizeof(m.sender));             // Write sender NodeId. 4 Bytes
+        f.write(reinterpret_cast<const uint8_t *>(&m.channelIndex), sizeof(m.channelIndex)); // Write channel index. 1 Byte
+        f.write(reinterpret_cast<const uint8_t *>(m.text.c_str()),
+                min((size_t)MAX_MESSAGE_SIZE, m.text.size())); // Write message text
+        f.write('\0');                                         // Append null term
+        LOG_DEBUG("Wrote message %u, length %u, text \"%s\"", static_cast<uint32_t>(i),
+                  min((size_t)MAX_MESSAGE_SIZE, m.text.size()), m.text.c_str());
+    }
+
+    // Release firmware's SPI lock, because SafeFile::close needs it
+    spiLock->unlock();
+
+    bool writeSucceeded = f.close();
+
+    if (!writeSucceeded) {
+        LOG_ERROR("Can't write data!");
+    }
+#else
+    LOG_ERROR("ERROR: Filesystem not implemented\n");
+#endif
+}
+
+// Attempt to load the previous contents of the MessageStore:message deque from flash.
+// Filename is controlled by the "label" parameter
+// Takes the firmware's SPI lock during FS operations. Implemented for consistency, but only relevant when using SD card.
+void InkHUD::MessageStore::loadFromFlash()
+{
+    // Hopefully redundant. Initial intention is to only load / save once per boot.
+    messages.clear();
+
+#ifdef FSCom
+
+    // Take the firmware's SPI Lock, in case filesystem is on SD card
+    concurrency::LockGuard guard(spiLock);
+
+    // Check that the file *does* actually exist
+    if (!FSCom.exists(filename.c_str())) {
+        LOG_WARN("'%s' not found. Using default values", filename.c_str());
+        return;
+    }
+
+    // Check that the file *does* actually exist
+    if (!FSCom.exists(filename.c_str())) {
+        LOG_INFO("'%s' not found.", filename.c_str());
+        return;
+    }
+
+    // Open the file
+    auto f = FSCom.open(filename.c_str(), FILE_O_READ);
+
+    if (f.size() == 0) {
+        LOG_INFO("%s is empty", filename.c_str());
+        f.close();
+        return;
+    }
+
+    // If opened, start reading
+    if (f) {
+        LOG_INFO("Loading threaded messages '%s'", filename.c_str());
+
+        // First byte: how many messages are in the flash store
+        uint8_t flashMessageCount = 0;
+        f.readBytes(reinterpret_cast<char *>(&flashMessageCount), 1);
+        LOG_DEBUG("Messages available: %u", static_cast<uint32_t>(flashMessageCount));
+
+        // For each message
+        for (uint8_t i = 0; i < flashMessageCount && i < MAX_MESSAGES_SAVED; i++) {
+            Message m;
+
+            // Read meta data (fixed width)
+            f.readBytes(reinterpret_cast<char *>(&m.timestamp), sizeof(m.timestamp));
+            f.readBytes(reinterpret_cast<char *>(&m.sender), sizeof(m.sender));
+            f.readBytes(reinterpret_cast<char *>(&m.channelIndex), sizeof(m.channelIndex));
+
+            // Read characters until we find a null term
+            char c;
+            while (m.text.size() < MAX_MESSAGE_SIZE) {
+                f.readBytes(&c, 1);
+                if (c != '\0')
+                    m.text += c;
+                else
+                    break;
+            }
+
+            // Store in RAM
+            messages.push_back(m);
+
+            LOG_DEBUG("#%u, timestamp=%u, sender(num)=%u, text=\"%s\"", static_cast<uint32_t>(i), m.timestamp, m.sender,
+                      m.text.c_str());
+        }
+
+        f.close();
+    } else {
+        LOG_ERROR("Could not open / read %s", filename.c_str());
+    }
+#else
+    LOG_ERROR("Filesystem not implemented");
+    state = LoadFileState::NO_FILESYSTEM;
+#endif
+    return;
+}
+
+#endif

src/graphics/niche/InkHUD/MessageStore.h

@@ -0,0 +1,47 @@
+#ifdef MESHTASTIC_INCLUDE_INKHUD
+
+/*
+
+We hold a few recent messages, for features like the threaded message applet.
+This class contains a struct for storing those messages,
+and methods for serializing them to flash.
+
+*/
+
+#pragma once
+
+#include "configuration.h"
+
+#include <deque>
+
+#include "mesh/MeshTypes.h"
+
+namespace NicheGraphics::InkHUD
+{
+
+class MessageStore
+{
+  public:
+    // A stored message
+    struct Message {
+        uint32_t timestamp; // Epoch seconds
+        NodeNum sender = 0;
+        uint8_t channelIndex;
+        std::string text;
+    };
+
+    MessageStore() = delete;
+    explicit MessageStore(const std::string &label); // Label determines filename in flash
+
+    void saveToFlash();
+    void loadFromFlash();
+
+    std::deque<Message> messages; // Interact with this object!
+
+  private:
+    std::string filename;
+};
+
+} // namespace NicheGraphics::InkHUD
+
+#endif

src/graphics/niche/InkHUD/Persistence.cpp

@@ -17,23 +17,23 @@ void InkHUD::Persistence::loadSettings()
         LOG_WARN("Settings version changed. Using defaults");
 }
 
-// Rebuild the latestMessage cache from the global messageStore.
-// Called after messageStore.loadFromFlash() so that the most recent broadcast and DM
-// are immediately available to applets (DMApplet, AllMessageApplet, NotificationApplet).
+// Load settings and latestMessage data
 void InkHUD::Persistence::loadLatestMessage()
 {
-    int lastBroadcastPos = -1, lastDMPos = -1, pos = 0;
-    for (const StoredMessage &m : messageStore.getLiveMessages()) {
-        if (m.type == MessageType::BROADCAST) {
-            latestMessage.broadcast = m;
-            lastBroadcastPos = pos;
-        } else if (m.type == MessageType::DM_TO_US) {
-            latestMessage.dm = m;
-            lastDMPos = pos;
-        }
-        pos++;
+    // Load previous "latestMessages" data from flash
+    MessageStore store("latest");
+    store.loadFromFlash();
+
+    // Place into latestMessage struct, for convenient access
+    // Number of strings loaded determines whether last message was broadcast or dm
+    if (store.messages.size() == 1) {
+        latestMessage.dm = store.messages.at(0);
+        latestMessage.wasBroadcast = false;
+    } else if (store.messages.size() == 2) {
+        latestMessage.dm = store.messages.at(0);
+        latestMessage.broadcast = store.messages.at(1);
+        latestMessage.wasBroadcast = true;
     }
-    latestMessage.wasBroadcast = (lastBroadcastPos > lastDMPos);
 }
 
 // Save the InkHUD settings to flash
@@ -42,10 +42,15 @@ void InkHUD::Persistence::saveSettings()
     FlashData<Settings>::save(&settings, "settings");
 }
 
-// Persist all messages via the global messageStore.
+// Save latestMessage data to flash
 void InkHUD::Persistence::saveLatestMessage()
 {
-    messageStore.saveToFlash();
+    // Number of strings saved determines whether last message was broadcast or dm
+    MessageStore store("latest");
+    store.messages.push_back(latestMessage.dm);
+    if (latestMessage.wasBroadcast)
+        store.messages.push_back(latestMessage.broadcast);
+    store.saveToFlash();
 }
 
 /*

src/graphics/niche/InkHUD/Persistence.h

@@ -15,7 +15,7 @@ The save / load mechanism is a shared NicheGraphics feature.
 #include "configuration.h"
 
 #include "./InkHUD.h"
-#include "MessageStore.h"
+#include "graphics/niche/InkHUD/MessageStore.h"
 #include "graphics/niche/Utils/FlashData.h"
 
 namespace NicheGraphics::InkHUD
@@ -120,12 +120,12 @@ class Persistence
     };
 
     // Most recently received text message
-    // Value is updated by InkHUD::Events, as a courtesy to applets.
-    // Populated at boot from the global messageStore, then updated live on receive.
+    // Value is updated by InkHUD::WindowManager, as a courtesy to applets
+    // InkHUD keeps its own latest-message cache for applets.
     struct LatestMessage {
-        StoredMessage broadcast; // Most recent broadcast message received
-        StoredMessage dm;        // Most recent DM received
-        bool wasBroadcast;       // True if most recent broadcast is newer than most recent dm
+        MessageStore::Message broadcast; // Most recent message received broadcast
+        MessageStore::Message dm;        // Most recent received DM
+        bool wasBroadcast;               // True if most recent broadcast is newer than most recent dm
     };
 
     void loadSettings();

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

@@ -422,11 +422,9 @@ Stores InkHUD data in flash
 - settings
 - most recent text message received (both for broadcast and DM)
 
-Message history (used by `ThreadedMessageApplet`) is stored by the firmware-wide `MessageStore` (`src/MessageStore.h`), not by `Persistence` directly.
+In rare cases, applets may store their own specific data separately (e.g. `ThreadedMessageApplet`)
 
-Settings are saved only on shutdown / reboot. Not saved if power is removed unexpectedly.
-
-Message history is saved periodically (every 2 hours by default), as well as on shutdown / reboot.
+Data saved only on shutdown / reboot. Not saved if power is removed unexpectedly.
 
 ---
 
@@ -468,21 +466,18 @@ Collected here, so various user applets don't all have to store their own copy o
 
 We keep this separate latest-message cache for this purpose, because:
 
-- we want to expose both the most recent broadcast and most recent DM independently
-- applets like `DMApplet` and `NotificationApplet` need quick access without scanning the full message history
-
-#### How messages reach the store
-
-Broadcasts and DMs take different paths into `messageStore`:
-
-- **Broadcasts** — `ThreadedMessageApplet::handleReceived()` calls `messageStore.addFromPacket()`. `Events::onReceiveTextMessage()` then updates `latestMessage.broadcast` separately for fast access by `AllMessageApplet` and `NotificationApplet`.
-- **DMs** — `ThreadedMessageApplet` skips DMs entirely. `Events::onReceiveTextMessage()` calls `messageStore.addFromPacket()` directly and stores the result in `latestMessage.dm`.
+- it is cleared by an outgoing text message
+- we want to store both a recent broadcast and a recent DM
 
 #### Saving / Loading
 
-The `LatestMessage` cache is not persisted to its own file. On boot, `InkHUD::begin()` calls `messageStore.loadFromFlash()` first, then `Persistence::loadLatestMessage()` rebuilds the cache by scanning the loaded messages for the most recent broadcast and DM.
+_A bit of a hack.._
+Stored to flash using `InkHUD::MessageStore`, which is really intended for storing a thread of messages (see `ThreadedMessageApplet`). Used because it stores strings more efficiently than `FlashData.h`.
 
-Text is stored in the firmware-wide shared text pool. Use `MessageStore::getText(msg)` to retrieve it from a `StoredMessage`.
+The hack is:
+
+- If most recent message was a DM, we only store the DM.
+- If most recent message was a broadcast, we store both a DM and a broadcast. The DM may be 0-length string.
 
 ---
 
@@ -587,17 +582,13 @@ Handles events which impact the InkHUD system generally (e.g. shutdown, button p
 
 Applets themselves do also listen separately for various events, but for the purpose of gathering information which they would like to display.
 
-#### Text Messages
-
-`Events::onReceiveTextMessage()` is the central handler for all incoming text messages. It updates the `LatestMessage` cache and, for DMs, also adds the message to `messageStore` (since `ThreadedMessageApplet` only handles broadcasts). See `Persistence::LatestMessage` for details on how the two message types are stored.
-
 #### Buttons
 
 Button input is sometimes handled by a system applet. `InkHUD::Events` determines whether the button should be handled by a specific system applet, or should instead trigger a default behavior
 
 #### Factory Reset
 
-The Events class handles the admin message(s) which trigger factory reset. We set `Events::eraseOnReboot = true`, which causes `Events::onReboot` to erase the contents of InkHUD's data directory (`/NicheGraphics/`) and also call `messageStore.clearAllMessages()` to wipe the firmware-wide message store (`/Messages_default.msgs`). Both are cleared during reboot rather than earlier, to avoid data being re-written by applets still running before shutdown.
+The Events class handles the admin messages(s) which trigger factory reset. We set `Events::eraseOnReboot = true`, which causes `Events::onReboot` to erase the contents of InkHUD's data directory. We do this because some applets (e.g. ThreadedMessageApplet) save their own data to flash, so if we erased earlier, that data would get re-written during reboot.
 
 ---
 

src/main.cpp

@@ -1243,7 +1243,7 @@ void loop()
     }
 #endif
 #endif
-#if (HAS_SCREEN || defined(MESHTASTIC_INCLUDE_NICHE_GRAPHICS)) && ENABLE_MESSAGE_PERSISTENCE
+#if HAS_SCREEN && ENABLE_MESSAGE_PERSISTENCE
     messageStoreAutosaveTick();
 #endif
     long delayMsec = mainController.runOrDelay();

src/mesh/Default.h

@@ -37,12 +37,6 @@ enum class TrafficType { POSITION, TELEMETRY };
 #define default_traffic_mgmt_position_precision_bits 24               // ~10m grid cells
 #define default_traffic_mgmt_position_min_interval_secs (ONE_DAY / 2) // 12 hours between identical positions
 
-// Hop scaling defaults
-#define default_hop_scaling_min_target_nodes 40          // walk threshold: first hop reaching this cumulative count
-#define default_hop_scaling_max_target_nodes 80          // generous extension ceiling (2 × min)
-#define default_hop_scaling_min_target_nodes_floor 5     // minimum allowed min_target_nodes
-#define default_hop_scaling_max_target_nodes_ceiling 512 // maximum allowed max_target_nodes
-
 #ifdef USERPREFS_RINGTONE_NAG_SECS
 #define default_ringtone_nag_secs USERPREFS_RINGTONE_NAG_SECS
 #else

src/mesh/LoRaFEMInterface.cpp

@@ -2,58 +2,11 @@
 #include "LoRaFEMInterface.h"
 
 #if defined(ARCH_ESP32)
-#include <driver/gpio.h>
 #include <driver/rtc_io.h>
 #include <esp_sleep.h>
 #endif
 
 LoRaFEMInterface loraFEMInterface;
-
-static void enableFEMPower()
-{
-    bool wasOff = digitalRead(LORA_PA_POWER) != HIGH;
-    digitalWrite(LORA_PA_POWER, HIGH);
-    if (wasOff) {
-        delay(5); // This is an arbitrary 5ms for FEM rail power-up.
-    }
-}
-
-#if defined(ARCH_ESP32)
-static void releasePinHold(int pin)
-{
-    if (pin < 0) {
-        return;
-    }
-
-    gpio_num_t gpio = (gpio_num_t)pin;
-
-#if SOC_RTCIO_HOLD_SUPPORTED
-    if (rtc_gpio_is_valid_gpio(gpio)) {
-        rtc_gpio_hold_dis(gpio);
-        return;
-    }
-#endif
-    if (GPIO_IS_VALID_OUTPUT_GPIO(gpio)) {
-        gpio_hold_dis(gpio);
-    }
-}
-
-static void releaseSleepHolds()
-{
-    releasePinHold(LORA_PA_POWER);
-#ifdef HELTEC_V4
-    releasePinHold(LORA_KCT8103L_PA_CSD);
-    releasePinHold(LORA_KCT8103L_PA_CTX);
-#elif defined(USE_GC1109_PA)
-    releasePinHold(LORA_GC1109_PA_EN);
-    releasePinHold(LORA_GC1109_PA_TX_EN);
-#elif defined(USE_KCT8103L_PA)
-    releasePinHold(LORA_KCT8103L_PA_CSD);
-    releasePinHold(LORA_KCT8103L_PA_CTX);
-#endif
-}
-#endif
-
 void LoRaFEMInterface::init(void)
 {
     setLnaCanControl(false); // Default is uncontrollable
@@ -68,7 +21,6 @@ void LoRaFEMInterface::init(void)
     if (digitalRead(LORA_KCT8103L_PA_CSD) == HIGH) {
         // FEM is KCT8103L
         fem_type = KCT8103L_PA;
-        LOG_INFO("Detected KCT8103L LoRa FEM");
         rtc_gpio_hold_dis((gpio_num_t)LORA_KCT8103L_PA_CTX);
         pinMode(LORA_KCT8103L_PA_CSD, OUTPUT);
         digitalWrite(LORA_KCT8103L_PA_CSD, HIGH);
@@ -78,7 +30,6 @@ void LoRaFEMInterface::init(void)
     } else if (digitalRead(LORA_KCT8103L_PA_CSD) == LOW) {
         // FEM is GC1109
         fem_type = GC1109_PA;
-        LOG_INFO("Detected GC1109 LoRa FEM");
         // LORA_GC1109_PA_EN and LORA_KCT8103L_PA_CSD are the same pin and do not need to be repeatedly turned off and held.
         //  rtc_gpio_hold_dis((gpio_num_t)LORA_GC1109_PA_EN);
         pinMode(LORA_GC1109_PA_EN, OUTPUT);
@@ -90,7 +41,6 @@ void LoRaFEMInterface::init(void)
     }
 #elif defined(USE_GC1109_PA)
     fem_type = GC1109_PA;
-    LOG_INFO("Using GC1109 LoRa FEM");
     pinMode(LORA_PA_POWER, OUTPUT);
     digitalWrite(LORA_PA_POWER, HIGH);
 #if defined(ARCH_ESP32)
@@ -105,7 +55,6 @@ void LoRaFEMInterface::init(void)
     digitalWrite(LORA_GC1109_PA_TX_EN, LOW);
 #elif defined(USE_KCT8103L_PA)
     fem_type = KCT8103L_PA;
-    LOG_INFO("Using KCT8103L LoRa FEM");
     pinMode(LORA_PA_POWER, OUTPUT);
     digitalWrite(LORA_PA_POWER, HIGH);
 #if defined(ARCH_ESP32)
@@ -124,10 +73,6 @@ void LoRaFEMInterface::init(void)
 
 void LoRaFEMInterface::setSleepModeEnable(void)
 {
-#if defined(ARCH_ESP32)
-    releaseSleepHolds();
-#endif
-
 #ifdef HELTEC_V4
     if (fem_type == GC1109_PA) {
         /*
@@ -139,7 +84,6 @@ void LoRaFEMInterface::setSleepModeEnable(void)
     } else if (fem_type == KCT8103L_PA) {
         // shutdown the PA
         digitalWrite(LORA_KCT8103L_PA_CSD, LOW);
-        digitalWrite(LORA_PA_POWER, LOW);
     }
 #elif defined(USE_GC1109_PA)
     digitalWrite(LORA_GC1109_PA_EN, LOW);
@@ -147,22 +91,16 @@ void LoRaFEMInterface::setSleepModeEnable(void)
 #elif defined(USE_KCT8103L_PA)
     // shutdown the PA
     digitalWrite(LORA_KCT8103L_PA_CSD, LOW);
-    digitalWrite(LORA_PA_POWER, LOW);
 #endif
 }
 
 void LoRaFEMInterface::setTxModeEnable(void)
 {
-#if defined(ARCH_ESP32)
-    releaseSleepHolds();
-#endif
-
 #ifdef HELTEC_V4
     if (fem_type == GC1109_PA) {
         digitalWrite(LORA_GC1109_PA_EN, HIGH);    // CSD=1: Chip enabled
         digitalWrite(LORA_GC1109_PA_TX_EN, HIGH); // CPS: 1=full PA, 0=bypass (for RX, CPS is don't care)
     } else if (fem_type == KCT8103L_PA) {
-        enableFEMPower();
         digitalWrite(LORA_KCT8103L_PA_CSD, HIGH);
         digitalWrite(LORA_KCT8103L_PA_CTX, HIGH);
     }
@@ -170,7 +108,6 @@ void LoRaFEMInterface::setTxModeEnable(void)
     digitalWrite(LORA_GC1109_PA_EN, HIGH);    // CSD=1: Chip enabled
     digitalWrite(LORA_GC1109_PA_TX_EN, HIGH); // CPS: 1=full PA, 0=bypass (for RX, CPS is don't care)
 #elif defined(USE_KCT8103L_PA)
-    enableFEMPower();
     digitalWrite(LORA_KCT8103L_PA_CSD, HIGH);
     digitalWrite(LORA_KCT8103L_PA_CTX, HIGH);
 #endif
@@ -178,16 +115,11 @@ void LoRaFEMInterface::setTxModeEnable(void)
 
 void LoRaFEMInterface::setRxModeEnable(void)
 {
-#if defined(ARCH_ESP32)
-    releaseSleepHolds();
-#endif
-
 #ifdef HELTEC_V4
     if (fem_type == GC1109_PA) {
         digitalWrite(LORA_GC1109_PA_EN, HIGH); // CSD=1: Chip enabled
         digitalWrite(LORA_GC1109_PA_TX_EN, LOW);
     } else if (fem_type == KCT8103L_PA) {
-        enableFEMPower();
         digitalWrite(LORA_KCT8103L_PA_CSD, HIGH);
         if (lna_enabled) {
             digitalWrite(LORA_KCT8103L_PA_CTX, LOW);
@@ -199,7 +131,6 @@ void LoRaFEMInterface::setRxModeEnable(void)
     digitalWrite(LORA_GC1109_PA_EN, HIGH);    // CSD=1: Chip enabled
     digitalWrite(LORA_GC1109_PA_TX_EN, LOW);
 #elif defined(USE_KCT8103L_PA)
-    enableFEMPower();
     digitalWrite(LORA_KCT8103L_PA_CSD, HIGH);
     if (lna_enabled) {
         digitalWrite(LORA_KCT8103L_PA_CTX, LOW);
@@ -211,14 +142,12 @@ void LoRaFEMInterface::setRxModeEnable(void)
 
 void LoRaFEMInterface::setRxModeEnableWhenMCUSleep(void)
 {
-#if defined(ARCH_ESP32)
-    releaseSleepHolds();
-#endif
 
 #ifdef HELTEC_V4
-    // Keep FEM rail powered during deep sleep so LoRa RX wake can work (GC1109 keeps LNA active; KCT8103L uses RX bypass).
-    // Set PA_POWER HIGH (overrides SX126xInterface::sleep() shutdown), then latch with RTC hold so the state survives deep sleep.
-    enableFEMPower();
+    // Keep GC1109 FEM powered during deep sleep so LNA remains active for RX wake.
+    // Set PA_POWER and PA_EN HIGH (overrides SX126xInterface::sleep() shutdown),
+    // then latch with RTC hold so the state survives deep sleep.
+    digitalWrite(LORA_PA_POWER, HIGH);
     rtc_gpio_hold_en((gpio_num_t)LORA_PA_POWER);
     if (fem_type == GC1109_PA) {
         digitalWrite(LORA_GC1109_PA_EN, HIGH);
@@ -227,11 +156,15 @@ void LoRaFEMInterface::setRxModeEnableWhenMCUSleep(void)
     } else if (fem_type == KCT8103L_PA) {
         digitalWrite(LORA_KCT8103L_PA_CSD, HIGH);
         rtc_gpio_hold_en((gpio_num_t)LORA_KCT8103L_PA_CSD);
-        digitalWrite(LORA_KCT8103L_PA_CTX, HIGH); // RX bypass while MCU sleeps
+        if (lna_enabled) {
+            digitalWrite(LORA_KCT8103L_PA_CTX, LOW);
+        } else {
+            digitalWrite(LORA_KCT8103L_PA_CTX, HIGH);
+        }
         rtc_gpio_hold_en((gpio_num_t)LORA_KCT8103L_PA_CTX);
     }
 #elif defined(USE_GC1109_PA)
-    enableFEMPower();
+    digitalWrite(LORA_PA_POWER, HIGH);
     digitalWrite(LORA_GC1109_PA_EN, HIGH);
 #if defined(ARCH_ESP32)
     rtc_gpio_hold_en((gpio_num_t)LORA_PA_POWER);
@@ -239,11 +172,13 @@ void LoRaFEMInterface::setRxModeEnableWhenMCUSleep(void)
     gpio_pulldown_en((gpio_num_t)LORA_GC1109_PA_TX_EN);
 #endif
 #elif defined(USE_KCT8103L_PA)
-    enableFEMPower();
     digitalWrite(LORA_KCT8103L_PA_CSD, HIGH);
-    digitalWrite(LORA_KCT8103L_PA_CTX, HIGH); // RX bypass while MCU sleeps
+    if (lna_enabled) {
+        digitalWrite(LORA_KCT8103L_PA_CTX, LOW);
+    } else {
+        digitalWrite(LORA_KCT8103L_PA_CTX, HIGH);
+    }
 #if defined(ARCH_ESP32)
-    rtc_gpio_hold_en((gpio_num_t)LORA_PA_POWER);
     rtc_gpio_hold_en((gpio_num_t)LORA_KCT8103L_PA_CSD);
     rtc_gpio_hold_en((gpio_num_t)LORA_KCT8103L_PA_CTX);
 #endif
@@ -292,4 +227,4 @@ int8_t LoRaFEMInterface::powerConversion(int8_t loraOutputPower)
     return loraOutputPower;
 }
 
-#endif
+#endif

src/mesh/MeshRadio.h

@@ -15,7 +15,7 @@ static const meshtastic_Config_LoRaConfig_ModemPreset MODEM_PRESET_END =
 
 #define PRESET(name) meshtastic_Config_LoRaConfig_ModemPreset_##name
 
-// Override slot magic numbers for RegionInfo.overrideSlot
+// Override slot magic numbers for RegionProfile.overrideSlot
 #define OVERRIDE_SLOT_DEFAULT_CHANNEL_HASH 0 // Use hash of primary channel name
 #define OVERRIDE_SLOT_PRESET_HASH -1         // Use hash of preset name instead
 // Positive values (1-32767) are explicit slot numbers
@@ -30,6 +30,8 @@ struct RegionProfile {
     int8_t textThrottle;      // throttle for text - future expansion
     int8_t positionThrottle;  // throttle for location data - future expansion
     int8_t telemetryThrottle; // throttle for telemetry - future expansion
+    int16_t overrideSlot;     // a per-region override slot for if we need to fix it in place
+                              // Magic values: 0 = use channel name hash, -1 = use preset name hash, >0 = explicit slot
 };
 
 /**
@@ -44,8 +46,7 @@ extern const RegionProfile PROFILE_EU868;
 extern const RegionProfile PROFILE_UNDEF;
 extern const RegionProfile PROFILE_LITE;
 extern const RegionProfile PROFILE_NARROW;
-extern const RegionProfile PROFILE_HAM_20KHZ;
-extern const RegionProfile PROFILE_HAM_100KHZ;
+// extern const RegionProfile  PROFILE_HAM;
 
 // Map from old region names to new region enums
 struct RegionInfo {
@@ -58,21 +59,11 @@ struct RegionInfo {
     bool wideLora;
     const RegionProfile *profile;
     meshtastic_Config_LoRaConfig_ModemPreset defaultPreset;
-    int16_t overrideSlot; // per-region override slot for frequency selection
-                          // Magic values: 0 = use channel name hash, -1 = use preset name hash, >0 = explicit slot
-    const char *name;     // EU433 etc
+    const char *name; // EU433 etc
 
     // Preset accessors (delegate through profile)
     meshtastic_Config_LoRaConfig_ModemPreset getDefaultPreset() const { return defaultPreset; }
     const meshtastic_Config_LoRaConfig_ModemPreset *getAvailablePresets() const { return profile->presets; }
-    bool supportsPreset(meshtastic_Config_LoRaConfig_ModemPreset preset) const
-    {
-        for (size_t i = 0; profile->presets[i] != MODEM_PRESET_END; i++) {
-            if (profile->presets[i] == preset)
-                return true;
-        }
-        return false;
-    }
     size_t getNumPresets() const
     {
         size_t n = 0;
@@ -86,7 +77,6 @@ extern const RegionInfo regions[];
 extern const RegionInfo *myRegion;
 
 extern void initRegion();
-extern const RegionInfo *getRegion(meshtastic_Config_LoRaConfig_RegionCode code);
 
 // Valid LoRa spread factor range and defaults
 constexpr uint8_t LORA_SF_MIN = 5;
@@ -133,18 +123,8 @@ static inline float clampBandwidthKHz(float bwKHz)
 
 static inline float bwCodeToKHz(uint16_t bwCode)
 {
-    if (bwCode == 8)
-        return 7.8f;
-    if (bwCode == 10)
-        return 10.4f;
-    if (bwCode == 16)
-        return 15.6f;
-    if (bwCode == 21)
-        return 20.8f;
     if (bwCode == 31)
         return 31.25f;
-    if (bwCode == 42)
-        return 41.7f;
     if (bwCode == 62)
         return 62.5f;
     if (bwCode == 200)
@@ -160,18 +140,8 @@ static inline float bwCodeToKHz(uint16_t bwCode)
 
 static inline uint16_t bwKHzToCode(float bwKHz)
 {
-    if (bwKHz > 7.7f && bwKHz < 7.9f)
-        return 8;
-    if (bwKHz > 10.3f && bwKHz < 10.5f)
-        return 10;
-    if (bwKHz > 15.5f && bwKHz < 15.7f)
-        return 16;
-    if (bwKHz > 20.7f && bwKHz < 20.9f)
-        return 21;
     if (bwKHz > 31.24f && bwKHz < 31.26f)
         return 31;
-    if (bwKHz > 41.6f && bwKHz < 41.8f)
-        return 42;
     if (bwKHz > 62.49f && bwKHz < 62.51f)
         return 62;
     if (bwKHz > 203.12f && bwKHz < 203.13f)
@@ -249,16 +219,6 @@ static inline void modemPresetToParams(meshtastic_Config_LoRaConfig_ModemPreset
         cr = 6;
         sf = 8;
         break;
-    case PRESET(TINY_FAST):
-        bwKHz = 15.6f;
-        cr = 5;
-        sf = 7;
-        break;
-    case PRESET(TINY_SLOW):
-        bwKHz = 15.6f;
-        cr = 6;
-        sf = 8;
-        break;
     default: // LONG_FAST (or illegal)
         bwKHz = wideLora ? 812.5f : 250.0f;
         cr = 5;

src/mesh/NodeDB.cpp

@@ -25,9 +25,6 @@
 #include "mesh/generated/meshtastic/deviceonly_legacy.pb.h"
 #include "meshUtils.h"
 #include "modules/NeighborInfoModule.h"
-#if HAS_VARIABLE_HOPS
-#include "modules/HopScalingModule.h"
-#endif
 #include "xmodem.h"
 #include <ErriezCRC32.h>
 #include <algorithm>
@@ -1989,14 +1986,6 @@ bool NodeDB::saveDeviceStateToDisk()
 
 bool NodeDB::saveNodeDatabaseToDisk()
 {
-    // Don't persist the node DB until this device has a PKI keypair
-    // TODO: revisit when https://github.com/meshtastic/firmware/pull/10478 lands
-#if !(MESHTASTIC_EXCLUDE_PKI_KEYGEN || MESHTASTIC_EXCLUDE_PKI)
-    if (owner.public_key.size != 32 && !owner.is_licensed) {
-        LOG_DEBUG("Skip NodeDB without key");
-        return true;
-    }
-#endif
 
     // do not try to save anything if power level is not safe. In many cases flash will be lock-protected
     // and all writes will fail anyway. Device should be sleeping at this point anyway.
@@ -2549,14 +2538,6 @@ void NodeDB::updateFrom(const meshtastic_MeshPacket &mp)
         nodeInfoLiteSetBit(info, NODEINFO_BITFIELD_VIA_MQTT_MASK,
                            mp.via_mqtt); // Store if we received this packet via MQTT
 
-#if HAS_VARIABLE_HOPS
-        // Only sample packets that arrived over LoRa.
-        if (mp.transport_mechanism == meshtastic_MeshPacket_TransportMechanism_TRANSPORT_LORA && hopScalingModule) {
-            uint8_t hopCount = std::max(int8_t(0), getHopsAway(mp));
-            hopScalingModule->samplePacketForHistogram(mp.from, hopCount);
-        }
-#endif
-
         // If hopStart was set and there wasn't someone messing with the limit in the middle, add hopsAway
         const int8_t hopsAway = getHopsAway(mp);
         if (hopsAway >= 0) {

src/mesh/NodeDB.h

@@ -132,7 +132,7 @@ inline bool shouldDropPacketForPreHop(const meshtastic_MeshPacket &p)
     if (isFromUs(&p)) {
         return false; // local-originated packets should never be dropped by pre-hop drop policy
     }
-    return classifyHopStart(p) != HopStartStatus::VALID;
+    return classifyHopStart(p) == HopStartStatus::INVALID;
 #endif
 }
 

src/mesh/RadioInterface.cpp

@@ -49,25 +49,18 @@ static const meshtastic_Config_LoRaConfig_ModemPreset PRESETS_LITE[] = {PRESET(L
 static const meshtastic_Config_LoRaConfig_ModemPreset PRESETS_NARROW[] = {PRESET(NARROW_FAST), PRESET(NARROW_SLOW),
                                                                           MODEM_PRESET_END};
 
-static const meshtastic_Config_LoRaConfig_ModemPreset PRESETS_TINY[] = {PRESET(TINY_FAST), PRESET(TINY_SLOW), MODEM_PRESET_END};
-
 // Region profiles: bundle preset list + regulatory parameters shared across regions
-// presets, spacing, padding, audio, licensed, text throttle, position throttle, telemetry throttle
-const RegionProfile PROFILE_STD = {PRESETS_STD, 0, 0, true, false, 0, 1, 1};
-const RegionProfile PROFILE_EU868 = {PRESETS_EU_868, 0, 0, false, false, 0, 1, 1};
-const RegionProfile PROFILE_UNDEF = {PRESETS_UNDEF, 0, 0, true, false, 0, 1, 1};
-const RegionProfile PROFILE_LITE = {PRESETS_LITE, 0.4, 0.0375f, false, false, 0, 10, 10};
-const RegionProfile PROFILE_NARROW = {PRESETS_NARROW, 0, 0.0104f, true, false, 0, 1, 1};
-// Ham '20kHz' profile. 15.6kHz bandwidth coerced to 20kHz via padding.
-const RegionProfile PROFILE_HAM_20KHZ = {PRESETS_TINY, 0, 0.0022f, false, true, 0, 2, 2};
-// Ham '100kHz' profile. 62.5kHz bandwidth coerced to 100kHz via padding.
-const RegionProfile PROFILE_HAM_100KHZ = {PRESETS_NARROW, 0, 0.01875f, false, true, 0, 1, 1};
+// presets, spacing, padding, audio, licensed, text throttle, position throttle, telemetry throttle, override slot
+const RegionProfile PROFILE_STD = {PRESETS_STD, 0, 0, true, false, 0, 1, 1, 0};
+const RegionProfile PROFILE_EU868 = {PRESETS_EU_868, 0, 0, false, false, 0, 1, 1, 0};
+const RegionProfile PROFILE_UNDEF = {PRESETS_UNDEF, 0, 0, true, false, 0, 1, 1, 0};
+const RegionProfile PROFILE_LITE = {PRESETS_LITE, 0.4, 0.0375f, false, false, 0, 10, 10, 0};
+const RegionProfile PROFILE_NARROW = {PRESETS_NARROW, 0, 0.0104f, true, false, 0, 1, 1, 1};
 
-#define RDEF(name, freq_start, freq_end, duty_cycle, power_limit, frequency_switching, wide_lora, profile_ptr, default_preset,   \
-             override_slot)                                                                                                      \
+#define RDEF(name, freq_start, freq_end, duty_cycle, power_limit, frequency_switching, wide_lora, profile_ptr, default_preset)   \
     {                                                                                                                            \
         meshtastic_Config_LoRaConfig_RegionCode_##name, freq_start, freq_end, duty_cycle, power_limit, frequency_switching,      \
-            wide_lora, &profile_ptr, default_preset, override_slot, #name                                                        \
+            wide_lora, &profile_ptr, default_preset, #name                                                                       \
     }
 
 const RegionInfo regions[] = {
@@ -75,7 +68,7 @@ const RegionInfo regions[] = {
         https://link.springer.com/content/pdf/bbm%3A978-1-4842-4357-2%2F1.pdf
         https://www.thethingsnetwork.org/docs/lorawan/regional-parameters/
     */
-    RDEF(US, 902.0f, 928.0f, 100, 30, false, false, PROFILE_STD, PRESET(LONG_FAST), 0),
+    RDEF(US, 902.0f, 928.0f, 100, 30, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         EN300220 ETSI V3.2.1 [Table B.1, Item H, p. 21]
@@ -83,58 +76,48 @@ const RegionInfo regions[] = {
         https://www.etsi.org/deliver/etsi_en/300200_300299/30022002/03.02.01_60/en_30022002v030201p.pdf
         FIXME: https://github.com/meshtastic/firmware/issues/3371
      */
-    RDEF(EU_433, 433.0f, 434.0f, 10, 10, false, false, PROFILE_STD, PRESET(LONG_FAST), 0),
+    RDEF(EU_433, 433.0f, 434.0f, 10, 10, false, false, PROFILE_STD, PRESET(LONG_FAST)),
     /*
-        https://www.thethingsnetwork.org/docs/lorawan/duty-cycle/
-        https://www.thethingsnetwork.org/docs/lorawan/regional-parameters/
-        https://www.legislation.gov.uk/uksi/1999/930/schedule/6/part/III/made/data.xht?view=snippet&wrap=true
+       https://www.thethingsnetwork.org/docs/lorawan/duty-cycle/
+       https://www.thethingsnetwork.org/docs/lorawan/regional-parameters/
+       https://www.legislation.gov.uk/uksi/1999/930/schedule/6/part/III/made/data.xht?view=snippet&wrap=true
 
-        audio_permitted = false per regulation
+       audio_permitted = false per regulation
 
-        Special Note:
-        The link above describes LoRaWAN's band plan, stating a power limit of 16 dBm. This is their own suggested specification,
-        we do not need to follow it. The European Union regulations clearly state that the power limit for this frequency range is
-        500 mW, or 27 dBm. It also states that we can use interference avoidance and spectrum access techniques (such as LBT +
-        AFA) to avoid a duty cycle. (Please refer to line P page 22 of this document.)
-        https://www.etsi.org/deliver/etsi_en/300200_300299/30022002/03.01.01_60/en_30022002v030101p.pdf
-
-        EU 866MHz band (Band no. 46b of 2006/771/EC and subsequent amendments) for Non-specific short-range devices (SRD)
-        Gives 4 channels at 865.7/866.3/866.9/867.5 MHz, 400 kHz gap plus 37.5 kHz padding between channels, 27 dBm,
-        duty cycle 2.5% (mobile) or 10% (fixed) https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX:02006D0771(01)-20250123
-
-        EU 868MHz band: 3 channels at 869.410/869.4625/869.577 MHz
-        Channel centres at 869.442/869.525/869.608 MHz,
-        10.4 kHz padding on channels, 27 dBm, duty cycle 10%
-    */
-    RDEF(EU_868, 869.4f, 869.65f, 10, 27, false, false, PROFILE_EU868, PRESET(LONG_FAST), 0),
-    RDEF(EU_866, 865.6f, 867.6f, 2.5, 27, false, false, PROFILE_LITE, PRESET(LITE_FAST), 0),
-    RDEF(EU_N_868, 869.4f, 869.65f, 10, 27, false, false, PROFILE_NARROW, PRESET(NARROW_SLOW), 1),
+       Special Note:
+       The link above describes LoRaWAN's band plan, stating a power limit of 16 dBm. This is their own suggested specification,
+       we do not need to follow it. The European Union regulations clearly state that the power limit for this frequency range is
+       500 mW, or 27 dBm. It also states that we can use interference avoidance and spectrum access techniques (such as LBT +
+       AFA) to avoid a duty cycle. (Please refer to line P page 22 of this document.)
+       https://www.etsi.org/deliver/etsi_en/300200_300299/30022002/03.01.01_60/en_30022002v030101p.pdf
+     */
+    RDEF(EU_868, 869.4f, 869.65f, 10, 27, false, false, PROFILE_EU868, PRESET(LONG_FAST)),
 
     /*
         https://lora-alliance.org/wp-content/uploads/2020/11/lorawan_regional_parameters_v1.0.3reva_0.pdf
      */
-    RDEF(CN, 470.0f, 510.0f, 100, 19, false, false, PROFILE_STD, PRESET(LONG_FAST), 0),
+    RDEF(CN, 470.0f, 510.0f, 100, 19, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         https://lora-alliance.org/wp-content/uploads/2020/11/lorawan_regional_parameters_v1.0.3reva_0.pdf
         https://www.arib.or.jp/english/html/overview/doc/5-STD-T108v1_5-E1.pdf
         https://qiita.com/ammo0613/items/d952154f1195b64dc29f
      */
-    RDEF(JP, 920.5f, 923.5f, 100, 13, false, false, PROFILE_STD, PRESET(LONG_FAST), 0),
+    RDEF(JP, 920.5f, 923.5f, 100, 13, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         https://www.iot.org.au/wp/wp-content/uploads/2016/12/IoTSpectrumFactSheet.pdf
         https://iotalliance.org.nz/wp-content/uploads/sites/4/2019/05/IoT-Spectrum-in-NZ-Briefing-Paper.pdf
         Also used in Brazil.
      */
-    RDEF(ANZ, 915.0f, 928.0f, 100, 30, false, false, PROFILE_STD, PRESET(LONG_FAST), 0),
+    RDEF(ANZ, 915.0f, 928.0f, 100, 30, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         433.05 - 434.79 MHz, 25mW EIRP max, No duty cycle restrictions
         AU Low Interference Potential https://www.acma.gov.au/licences/low-interference-potential-devices-lipd-class-licence
         NZ General User Radio Licence for Short Range Devices https://gazette.govt.nz/notice/id/2022-go3100
      */
-    RDEF(ANZ_433, 433.05f, 434.79f, 100, 14, false, false, PROFILE_STD, PRESET(LONG_FAST), 0),
+    RDEF(ANZ_433, 433.05f, 434.79f, 100, 14, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         https://digital.gov.ru/uploaded/files/prilozhenie-12-k-reshenyu-gkrch-18-46-03-1.pdf
@@ -142,13 +125,13 @@ const RegionInfo regions[] = {
         Note:
             - We do LBT, so 100% is allowed.
      */
-    RDEF(RU, 868.7f, 869.2f, 100, 20, false, false, PROFILE_STD, PRESET(LONG_FAST), 0),
+    RDEF(RU, 868.7f, 869.2f, 100, 20, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         https://www.law.go.kr/LSW/admRulLsInfoP.do?admRulId=53943&efYd=0
         https://resources.lora-alliance.org/technical-specifications/rp002-1-0-4-regional-parameters
      */
-    RDEF(KR, 920.0f, 923.0f, 100, 23, false, false, PROFILE_STD, PRESET(LONG_FAST), 0),
+    RDEF(KR, 920.0f, 923.0f, 100, 23, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         Taiwan, 920-925Mhz, limited to 0.5W indoor or coastal, 1.0W outdoor.
@@ -156,40 +139,40 @@ const RegionInfo regions[] = {
         https://www.ncc.gov.tw/english/files/23070/102_5190_230703_1_doc_C.PDF
         https://gazette.nat.gov.tw/egFront/e_detail.do?metaid=147283
      */
-    RDEF(TW, 920.0f, 925.0f, 100, 27, false, false, PROFILE_STD, PRESET(LONG_FAST), 0),
+    RDEF(TW, 920.0f, 925.0f, 100, 27, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         https://lora-alliance.org/wp-content/uploads/2020/11/lorawan_regional_parameters_v1.0.3reva_0.pdf
      */
-    RDEF(IN, 865.0f, 867.0f, 100, 30, false, false, PROFILE_STD, PRESET(LONG_FAST), 0),
+    RDEF(IN, 865.0f, 867.0f, 100, 30, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
          https://rrf.rsm.govt.nz/smart-web/smart/page/-smart/domain/licence/LicenceSummary.wdk?id=219752
          https://iotalliance.org.nz/wp-content/uploads/sites/4/2019/05/IoT-Spectrum-in-NZ-Briefing-Paper.pdf
       */
-    RDEF(NZ_865, 864.0f, 868.0f, 100, 36, false, false, PROFILE_STD, PRESET(LONG_FAST), 0),
+    RDEF(NZ_865, 864.0f, 868.0f, 100, 36, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
        https://lora-alliance.org/wp-content/uploads/2020/11/lorawan_regional_parameters_v1.0.3reva_0.pdf
        https://standard.nbtc.go.th/getattachment/Standards/%E0%B8%A1%E0%B8%B2%E0%B8%95%E0%B8%A3%E0%B8%90%E0%B8%B2%E0%B8%99%E0%B8%97%E0%B8%B2%E0%B8%87%E0%B9%80%E0%B8%97%E0%B8%84%E0%B8%99%E0%B8%B4%E0%B8%84%E0%B8%82%E0%B8%AD%E0%B8%87%E0%B9%80%E0%B8%84%E0%B8%A3%E0%B8%B7%E0%B9%88%E0%B8%AD%E0%B8%87%E0%B9%82%E0%B8%97%E0%B8%A3%E0%B8%84%E0%B8%A1%E0%B8%99%E0%B8%B2%E0%B8%84%E0%B8%A1/1033-2565.pdf.aspx?lang=th-TH
        Thailand 920–925 MHz set max TX power to 27 dBm and enforce 10% duty cycle, aligned with NBTC regulations.
     */
-    RDEF(TH, 920.0f, 925.0f, 10, 27, false, false, PROFILE_STD, PRESET(LONG_FAST), 0),
+    RDEF(TH, 920.0f, 925.0f, 10, 27, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         433,05-434,7 Mhz 10 mW
         868,0-868,6 Mhz 25 mW
         https://nkrzi.gov.ua/images/upload/256/5810/PDF_UUZ_19_01_2016.pdf
     */
-    RDEF(UA_433, 433.0f, 434.7f, 10, 10, false, false, PROFILE_STD, PRESET(LONG_FAST), 0),
-    RDEF(UA_868, 868.0f, 868.6f, 1, 14, false, false, PROFILE_STD, PRESET(LONG_FAST), 0),
+    RDEF(UA_433, 433.0f, 434.7f, 10, 10, false, false, PROFILE_STD, PRESET(LONG_FAST)),
+    RDEF(UA_868, 868.0f, 868.6f, 1, 14, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         Malaysia
         433 - 435 MHz at 100mW, no restrictions.
         https://www.mcmc.gov.my/skmmgovmy/media/General/pdf/Short-Range-Devices-Specification.pdf
     */
-    RDEF(MY_433, 433.0f, 435.0f, 100, 20, false, false, PROFILE_STD, PRESET(LONG_FAST), 0),
+    RDEF(MY_433, 433.0f, 435.0f, 100, 20, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         Malaysia
@@ -198,14 +181,14 @@ const RegionInfo regions[] = {
         Frequency hopping is used for 919 - 923 MHz.
         https://www.mcmc.gov.my/skmmgovmy/media/General/pdf/Short-Range-Devices-Specification.pdf
     */
-    RDEF(MY_919, 919.0f, 924.0f, 100, 27, true, false, PROFILE_STD, PRESET(LONG_FAST), 0),
+    RDEF(MY_919, 919.0f, 924.0f, 100, 27, true, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         Singapore
         SG_923 Band 30d: 917 - 925 MHz at 100mW, no restrictions.
         https://www.imda.gov.sg/-/media/imda/files/regulation-licensing-and-consultations/ict-standards/telecommunication-standards/radio-comms/imdatssrd.pdf
     */
-    RDEF(SG_923, 917.0f, 925.0f, 100, 20, false, false, PROFILE_STD, PRESET(LONG_FAST), 0),
+    RDEF(SG_923, 917.0f, 925.0f, 100, 20, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         Philippines
@@ -215,9 +198,9 @@ const RegionInfo regions[] = {
                 https://github.com/meshtastic/firmware/issues/4948#issuecomment-2394926135
     */
 
-    RDEF(PH_433, 433.0f, 434.7f, 100, 10, false, false, PROFILE_STD, PRESET(LONG_FAST), 0),
-    RDEF(PH_868, 868.0f, 869.4f, 100, 14, false, false, PROFILE_STD, PRESET(LONG_FAST), 0),
-    RDEF(PH_915, 915.0f, 918.0f, 100, 24, false, false, PROFILE_STD, PRESET(LONG_FAST), 0),
+    RDEF(PH_433, 433.0f, 434.7f, 100, 10, false, false, PROFILE_STD, PRESET(LONG_FAST)),
+    RDEF(PH_868, 868.0f, 869.4f, 100, 14, false, false, PROFILE_STD, PRESET(LONG_FAST)),
+    RDEF(PH_915, 915.0f, 918.0f, 100, 24, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         Kazakhstan
@@ -225,71 +208,46 @@ const RegionInfo regions[] = {
                 863 - 868 MHz <25 mW EIRP, 500kHz channels allowed, must not be used at airfields
                                 https://github.com/meshtastic/firmware/issues/7204
     */
-    RDEF(KZ_433, 433.075f, 434.775f, 100, 10, false, false, PROFILE_STD, PRESET(LONG_FAST), 0),
-    RDEF(KZ_863, 863.0f, 868.0f, 100, 30, false, false, PROFILE_STD, PRESET(LONG_FAST), 0),
+    RDEF(KZ_433, 433.075f, 434.775f, 100, 10, false, false, PROFILE_STD, PRESET(LONG_FAST)),
+    RDEF(KZ_863, 863.0f, 868.0f, 100, 30, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         Nepal
         865 MHz to 868 MHz frequency band for IoT (Internet of Things), M2M (Machine-to-Machine), and smart metering use,
        specifically in non-cellular mode. https://www.nta.gov.np/uploads/contents/Radio-Frequency-Policy-2080-English.pdf
     */
-    RDEF(NP_865, 865.0f, 868.0f, 100, 30, false, false, PROFILE_STD, PRESET(LONG_FAST), 0),
+    RDEF(NP_865, 865.0f, 868.0f, 100, 30, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
         Brazil
         902 - 907.5 MHz , 1W power limit, no duty cycle restrictions
         https://github.com/meshtastic/firmware/issues/3741
     */
-    RDEF(BR_902, 902.0f, 907.5f, 100, 30, false, false, PROFILE_STD, PRESET(LONG_FAST), 0),
-
-    /*
-        ITU Region 1 (Europe, Africa, Middle East, former USSR) amateur 2m allocation: 144.000 - 146.000 MHz.
-        Power limit is the regulatory ceiling (1 W / 30 dBm) — individual hardware will cap below this
-        via its own PA curve; the field here is just the legal upper bound.
-
-        Default slot: 26 (144.510 MHz)
-        https://www.iaru-r1.org/wp-content/uploads/2020/12/VHF-Bandplan.pdf
-    */
-    RDEF(ITU1_2M, 144.0f, 146.0f, 100, 30, false, false, PROFILE_HAM_20KHZ, PRESET(TINY_FAST), 26),
-
-    /*
-        ITU Region 2 (Americas) amateur 2m allocation: 144.000 - 148.000 MHz.
-        Typical admin rules (e.g. US FCC Part 97) allow well above 30 dBm for licensed operators.
-
-        Default slot: 51 (145.010 MHz)
-        https://www.arrl.org/band-plan
-    */
-    RDEF(ITU2_2M, 144.0f, 148.0f, 100, 30, false, false, PROFILE_HAM_20KHZ, PRESET(TINY_FAST), 51),
-
-    /*
-        ITU Region 3 (Asia/Pacific) amateur 2m allocation: 144.000 - 148.000 MHz.
-        Typical admin rules allow well above 30 dBm for licensed operators.
-
-        Default slot: 33 (144.650 MHz)
-        https://www.iaru.org/wp-content/uploads/2020/01/R3-004-IARU-Region-3-Bandplan-rev.2.pdf
-        https://www.wia.org.au/members/bandplans/data/documents/WIA%20Australian%20Band%20Plan%202026.pdf
-    */
-    RDEF(ITU3_2M, 144.0f, 148.0f, 100, 30, false, false, PROFILE_HAM_20KHZ, PRESET(TINY_FAST), 33),
-
-    /*
-        ITU Region 2 (Americas) amateur 1.25m '125cm' allocation: 220.000 - 225.000 MHz.
-        Typical admin rules (e.g. US FCC Part 97) allow well above 30 dBm for licensed operators.
-        Note: Some countries do not allocate 220-222 MHz (e.g. USA, Canada). Check local law!
-
-        Default slot: 37 (223.650 MHz)
-        https://www.arrl.org/band-plan
-    */
-    RDEF(ITU2_125CM, 220.0f, 225.0f, 100, 30, false, false, PROFILE_HAM_100KHZ, PRESET(NARROW_SLOW), 37),
+    RDEF(BR_902, 902.0f, 907.5f, 100, 30, false, false, PROFILE_STD, PRESET(LONG_FAST)),
 
     /*
        2.4 GHZ WLAN Band equivalent. Only for SX128x chips.
     */
-    RDEF(LORA_24, 2400.0f, 2483.5f, 100, 10, false, true, PROFILE_STD, PRESET(LONG_FAST), 0),
+    RDEF(LORA_24, 2400.0f, 2483.5f, 100, 10, false, true, PROFILE_STD, PRESET(LONG_FAST)),
+
+    /*
+        EU 866MHz band (Band no. 46b of 2006/771/EC and subsequent amendments) for Non-specific short-range devices (SRD)
+        Gives 4 channels at 865.7/866.3/866.9/867.5 MHz, 400 kHz gap plus 37.5 kHz padding between channels, 27 dBm,
+        duty cycle 2.5% (mobile) or 10% (fixed) https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX:02006D0771(01)-20250123
+    */
+    RDEF(EU_866, 865.6f, 867.6f, 2.5, 27, false, false, PROFILE_LITE, PRESET(LITE_FAST)),
+
+    /*
+        EU 868MHz band: 3 channels at 869.410/869.4625/869.577 MHz
+        Channel centres at 869.442/869.525/869.608 MHz,
+        10.4 kHz padding on channels, 27 dBm, duty cycle 10%
+    */
+    RDEF(EU_N_868, 869.4f, 869.65f, 10, 27, false, false, PROFILE_NARROW, PRESET(NARROW_SLOW)),
 
     /*
         This needs to be last. Same as US.
     */
-    RDEF(UNSET, 902.0f, 928.0f, 100, 30, false, false, PROFILE_UNDEF, PRESET(LONG_FAST), 0),
+    RDEF(UNSET, 902.0f, 928.0f, 100, 30, false, false, PROFILE_UNDEF, PRESET(LONG_FAST)),
 
 };
 
@@ -853,116 +811,43 @@ uint32_t RadioInterface::getChannelNum()
 }
 
 /**
- * Send a client notification (error level unless specified). Safe to call when service is null (e.g. in tests).
+ * Send an error-level client notification. Safe to call when service is null (e.g. in tests).
  */
-static void sendErrorNotification(const char *msg, meshtastic_LogRecord_Level level = meshtastic_LogRecord_Level_ERROR)
+static void sendErrorNotification(const char *msg)
 {
     if (!service)
         return;
     meshtastic_ClientNotification *cn = clientNotificationPool.allocZeroed();
     if (!cn)
         return;
-    cn->level = level;
+    cn->level = meshtastic_LogRecord_Level_ERROR;
     snprintf(cn->message, sizeof(cn->message), "%s", msg);
     service->sendClientNotification(cn);
 }
 
-// The EU_868/EU_866/EU_N_868 trio own mutually exclusive preset lists. Selecting a preset
-// locked to a sibling means the user wants that sibling region, not the default preset.
-static const meshtastic_Config_LoRaConfig_RegionCode SWAPPABLE_EU_REGIONS[] = {
-    meshtastic_Config_LoRaConfig_RegionCode_EU_868,
-    meshtastic_Config_LoRaConfig_RegionCode_EU_866,
-    meshtastic_Config_LoRaConfig_RegionCode_EU_N_868,
-};
-
 /**
- * If currentRegion is one of the swappable EU regions and preset belongs to a sibling in
- * that trio, return the sibling region that owns the preset. Returns nullptr otherwise.
- */
-const RegionInfo *RadioInterface::regionSwapForPreset(meshtastic_Config_LoRaConfig_RegionCode currentRegion,
-                                                      meshtastic_Config_LoRaConfig_ModemPreset preset)
-{
-    bool currentIsSwappable = false;
-    for (auto code : SWAPPABLE_EU_REGIONS) {
-        if (code == currentRegion)
-            currentIsSwappable = true;
-    }
-    if (!currentIsSwappable)
-        return nullptr;
-
-    for (auto code : SWAPPABLE_EU_REGIONS) {
-        if (code == currentRegion)
-            continue;
-        const RegionInfo *sibling = getRegion(code);
-        if (sibling->supportsPreset(preset))
-            return sibling;
-    }
-    return nullptr;
-}
-
-/**
- * Checks if a region is valid for the current settings, with no side effects.
- * Safe to call speculatively (e.g. from UI pickers). When errBuf is given, it
- * receives the human-readable failure reason.
+ * Checks if a region is valid for the current settings.
  * Returns false if not compatible.
  */
-bool RadioInterface::checkConfigRegion(const meshtastic_Config_LoRaConfig &loraConfig, char *errBuf, size_t errLen)
+bool RadioInterface::validateConfigRegion(const meshtastic_Config_LoRaConfig &loraConfig)
 {
     const RegionInfo *newRegion = getRegion(loraConfig.region);
 
-    // Reject unrecognized region codes (getRegion returns UNSET sentinel for unknown codes)
-    if (newRegion->code != loraConfig.region) {
-        if (errBuf)
-            snprintf(errBuf, errLen, "Region code %d is not recognized", loraConfig.region);
-        return false;
-    }
-
     // If you are not licensed, you can't use ham regions.
     if (newRegion->profile->licensedOnly && !devicestate.owner.is_licensed) {
-        if (errBuf)
-            snprintf(errBuf, errLen, "Region %s requires licensed mode", newRegion->name);
+        char err_string[160];
+        snprintf(err_string, sizeof(err_string), "Region %s requires licensed mode", newRegion->name);
+        LOG_ERROR("%s", err_string);
+        RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_INVALID_RADIO_SETTING);
+        sendErrorNotification(err_string);
         return false;
     }
 
-    // Hardware compatibility: wide-LoRa (2.4 GHz) regions need a wide-capable radio, and
-    // sub-GHz regions need a radio that can tune below 2.4 GHz (SX128x cannot). UNSET is
-    // always allowed since it is the "no region" state.
-    if (newRegion->code != meshtastic_Config_LoRaConfig_RegionCode_UNSET && RadioLibInterface::instance) {
-        const char *unsupported = nullptr;
-        if (newRegion->wideLora && !RadioLibInterface::instance->wideLora()) {
-            unsupported = "2.4 GHz";
-        } else if (!newRegion->wideLora && !RadioLibInterface::instance->supportsSubGhz()) {
-            unsupported = "sub-GHz";
-        }
-        if (unsupported) {
-            if (errBuf)
-                snprintf(errBuf, errLen, "Region %s needs %s, which this radio does not support", newRegion->name, unsupported);
-            return false;
-        }
-    }
-
     return true;
 }
 
 /**
- * Checks if a region is valid for the current settings. On failure, logs at ERROR,
- * records a critical error, and sends a client notification.
- * Returns false if not compatible.
- */
-bool RadioInterface::validateConfigRegion(const meshtastic_Config_LoRaConfig &loraConfig)
-{
-    char err_string[160];
-    if (checkConfigRegion(loraConfig, err_string, sizeof(err_string)))
-        return true;
-
-    LOG_ERROR("%s", err_string);
-    RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_INVALID_RADIO_SETTING);
-    sendErrorNotification(err_string);
-    return false;
-}
-
-/**
- * Internal helper: check or clamp a LoRa config against its region.
+ * Internal helper: validate or clamp a LoRa config against its region.
  * When clamp==false, returns false on first error (pure validation).
  * When clamp==true, fixes invalid settings in-place and returns true.
  */
@@ -979,29 +864,11 @@ bool RadioInterface::checkOrClampConfigLora(meshtastic_Config_LoRaConfig &loraCo
     if (loraConfig.use_preset) {
         check_bw = modemPresetToBwKHz(loraConfig.modem_preset, newRegion->wideLora);
 
-        bool preset_valid = newRegion->supportsPreset(loraConfig.modem_preset);
-        if (!preset_valid) {
-            // A preset locked to a sibling of the swappable EU regions swaps the region instead
-            // of clamping the preset, as long as the previous region was itself one of the trio.
-            const RegionInfo *swapRegion = regionSwapForPreset(loraConfig.region, loraConfig.modem_preset);
-            if (swapRegion) {
-                if (!clamp) {
-                    // Validation must still fail so callers route into the clamp, but quietly:
-                    // the clamp will accept this config by swapping regions, so don't record a
-                    // critical error or alarm the user over a change that is about to succeed.
-                    LOG_INFO("Preset %s implies region swap %s to %s, deferring to clamp", presetName, newRegion->name,
-                             swapRegion->name);
-                    return false;
-                }
-                snprintf(err_string, sizeof(err_string), "Preset %s swaps region %s to %s", presetName, newRegion->name,
-                         swapRegion->name);
-                LOG_INFO("%s", err_string);
-                sendErrorNotification(err_string, meshtastic_LogRecord_Level_INFO);
-
-                loraConfig.region = swapRegion->code;
-                newRegion = swapRegion;
-                check_bw = modemPresetToBwKHz(loraConfig.modem_preset, newRegion->wideLora);
+        bool preset_valid = false;
+        for (size_t i = 0; i < newRegion->getNumPresets(); i++) {
+            if (loraConfig.modem_preset == newRegion->getAvailablePresets()[i]) {
                 preset_valid = true;
+                break;
             }
         }
         if (!preset_valid) {
@@ -1065,11 +932,11 @@ bool RadioInterface::checkOrClampConfigLora(meshtastic_Config_LoRaConfig &loraCo
         // overrideSlot: 0 = channel hash, -1 = preset hash, >0 = explicit slot
         uses_default_frequency_slot =
             (loraConfig.channel_num == 0) || // user choice unset, no frequency override, so use default
-            (newRegion->overrideSlot > 0 &&
-             loraConfig.channel_num == newRegion->overrideSlot) || // user setting matches explicit override slot
-            ((newRegion->overrideSlot == OVERRIDE_SLOT_DEFAULT_CHANNEL_HASH) &&
+            (newRegion->profile->overrideSlot > 0 &&
+             loraConfig.channel_num == newRegion->profile->overrideSlot) || // user setting matches explicit override slot
+            ((newRegion->profile->overrideSlot == OVERRIDE_SLOT_DEFAULT_CHANNEL_HASH) &&
              ((uint32_t)(loraConfig.channel_num - 1) == channelNameHashSlot)) || // user setting matches channel name hash
-            ((newRegion->overrideSlot == OVERRIDE_SLOT_PRESET_HASH) &&
+            ((newRegion->profile->overrideSlot == OVERRIDE_SLOT_PRESET_HASH) &&
              ((uint32_t)(loraConfig.channel_num - 1) == presetNameHashSlot)); // user setting matches preset name hash
 
         // check if user setting different to preset name
@@ -1085,11 +952,12 @@ bool RadioInterface::checkOrClampConfigLora(meshtastic_Config_LoRaConfig &loraCo
             if (clamp) {
                 if (uses_custom_channel_name) { // clamp to channel name hash
                     loraConfig.channel_num =
-                        channelNameHashSlot + 1;          // channel_num is 1-based, but hash slot is 0-based, so add 1
-                } else if (newRegion->overrideSlot > 0) { // clamp to explicit override slot
-                    loraConfig.channel_num = newRegion->overrideSlot; // use the explicit override slot defined for this region
+                        channelNameHashSlot + 1;                   // channel_num is 1-based, but hash slot is 0-based, so add 1
+                } else if (newRegion->profile->overrideSlot > 0) { // clamp to explicit override slot
+                    loraConfig.channel_num =
+                        newRegion->profile->overrideSlot; // use the explicit override slot specified by the region profile
                     uses_default_frequency_slot = true;
-                } else if (newRegion->overrideSlot == OVERRIDE_SLOT_PRESET_HASH && loraConfig.use_preset) {
+                } else if (newRegion->profile->overrideSlot == OVERRIDE_SLOT_PRESET_HASH && loraConfig.use_preset) {
                     // clamp to preset name hash
                     loraConfig.channel_num = presetNameHashSlot + 1; // channel_num is 1-based, but hash slot is 0-based, so add 1
                     uses_default_frequency_slot = true;
@@ -1208,9 +1076,9 @@ void RadioInterface::applyModemConfig()
         // NB: channel_num is also know as frequency slot but it's too late to fix now.
         if (uses_default_frequency_slot) {
             // Handle three override slot cases: explicit slot (>0), preset hash (-1), or channel hash (0)
-            if (newRegion->overrideSlot > 0) {
-                channel_num = newRegion->overrideSlot - 1; // explicit override slot (1-based to 0-based)
-            } else if (newRegion->overrideSlot == OVERRIDE_SLOT_PRESET_HASH) {
+            if (newRegion->profile->overrideSlot > 0) {
+                channel_num = newRegion->profile->overrideSlot - 1; // explicit override slot (1-based to 0-based)
+            } else if (newRegion->profile->overrideSlot == OVERRIDE_SLOT_PRESET_HASH) {
                 channel_num = presetNameHashSlot; // use preset name hash
             } else {
                 channel_num = channelNameHashSlot; // use channel name hash (default case)
@@ -1243,9 +1111,9 @@ void RadioInterface::applyModemConfig()
     LOG_INFO("newRegion->freqStart -> newRegion->freqEnd: %f -> %f (%f MHz)", newRegion->freqStart, newRegion->freqEnd,
              newRegion->freqEnd - newRegion->freqStart);
     LOG_INFO("numFreqSlots: %u x %.3fkHz", numFreqSlots, bw);
-    if (newRegion->overrideSlot > 0) {
-        LOG_INFO("Using region explicit override slot: %d", newRegion->overrideSlot);
-    } else if (newRegion->overrideSlot == OVERRIDE_SLOT_PRESET_HASH) {
+    if (newRegion->profile->overrideSlot > 0) {
+        LOG_INFO("Using region explicit override slot: %d", newRegion->profile->overrideSlot);
+    } else if (newRegion->profile->overrideSlot == OVERRIDE_SLOT_PRESET_HASH) {
         LOG_INFO("Using region preset name hash for slot selection");
     }
     LOG_INFO("channel_num: %d", channel_num + 1);

src/mesh/RadioInterface.h

@@ -143,10 +143,6 @@ class RadioInterface
 
     virtual bool wideLora() { return false; }
 
-    /// Whether the radio can tune sub-GHz bands. False for 2.4 GHz-only chips (SX128x);
-    /// multiband chips like the LR1121 keep the default.
-    virtual bool supportsSubGhz() { return true; }
-
     /// Prepare hardware for sleep.  Call this _only_ for deep sleep, not needed for light sleep.
     virtual bool sleep() { return true; }
 
@@ -248,12 +244,7 @@ class RadioInterface
 
     static bool checkOrClampConfigLora(meshtastic_Config_LoRaConfig &loraConfig, bool clamp);
 
-    // Check if a candidate region is compatible and valid, with no side effects (safe for
-    // speculative UI checks). errBuf, if given, receives the failure reason.
-    static bool checkConfigRegion(const meshtastic_Config_LoRaConfig &loraConfig, char *errBuf = nullptr, size_t errLen = 0);
-
-    // Check if a candidate region is compatible and valid. On failure, logs at ERROR,
-    // records a critical error, and sends a client notification.
+    // Check if a candidate region is compatible and valid.
     static bool validateConfigRegion(const meshtastic_Config_LoRaConfig &loraConfig);
 
     // Check if a candidate radio configuration is valid.
@@ -262,11 +253,6 @@ class RadioInterface
     // Make a candidate radio configuration valid, even if it isn't.
     static void clampConfigLora(meshtastic_Config_LoRaConfig &loraConfig);
 
-    // If preset is locked to a sibling of currentRegion among the swappable EU regions
-    // (EU_868/EU_866/EU_N_868), return the sibling region owning the preset, else nullptr.
-    static const RegionInfo *regionSwapForPreset(meshtastic_Config_LoRaConfig_RegionCode currentRegion,
-                                                 meshtastic_Config_LoRaConfig_ModemPreset preset);
-
   protected:
     int8_t power = 17; // Set by applyModemConfig()
 

src/mesh/RadioLibInterface.h

@@ -210,6 +210,8 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified
     /** Attempt to find a packet in the TxQueue. Returns true if the packet was found. */
     virtual bool findInTxQueue(NodeNum from, PacketId id) override;
 
+    uint8_t packetsInTxQueue() { return txQueue.getMaxLen() - txQueue.getFree(); }
+
     /**
      * Update the noise floor measurement by sampling RSSI from a slow path.
      * This should not be called from radio interrupt or TX/RX critical paths.

src/mesh/Router.cpp

@@ -15,9 +15,6 @@
 #if HAS_TRAFFIC_MANAGEMENT
 #include "modules/TrafficManagementModule.h"
 #endif
-#if HAS_VARIABLE_HOPS
-#include "modules/HopScalingModule.h"
-#endif
 #if !MESHTASTIC_EXCLUDE_MQTT
 #include "mqtt/MQTT.h"
 #endif
@@ -25,6 +22,8 @@
 #if ARCH_PORTDUINO
 #include "Throttle.h"
 #include "platform/portduino/PortduinoGlue.h"
+#endif
+#if ENABLE_JSON_LOGGING || ARCH_PORTDUINO
 #include "serialization/MeshPacketSerializer.h"
 #endif
 
@@ -358,30 +357,6 @@ ErrorCode Router::send(meshtastic_MeshPacket *p)
     p->from = getFrom(p);
 
     p->relay_node = nodeDB->getLastByteOfNodeNum(getNodeNum()); // set the relayer to us
-
-#if HAS_VARIABLE_HOPS
-    // Apply HopScaling hop recommendation to routine outgoing broadcasts
-    if (isFromUs(p) && isBroadcast(p->to) && hopScalingModule && p->which_payload_variant == meshtastic_MeshPacket_decoded_tag) {
-        switch (p->decoded.portnum) {
-        case meshtastic_PortNum_POSITION_APP:
-        case meshtastic_PortNum_TELEMETRY_APP:
-        case meshtastic_PortNum_NODEINFO_APP:
-        case meshtastic_PortNum_NEIGHBORINFO_APP: {
-            uint8_t variableHopLimit = hopScalingModule->getLastRequiredHop();
-
-            // Never exceed user-configured hop_limit
-            if (variableHopLimit < p->hop_limit) {
-                LOG_DEBUG("[HOPSCALE] hop_limit %u -> %u for portnum %u", p->hop_limit, variableHopLimit, p->decoded.portnum);
-                p->hop_limit = variableHopLimit;
-            }
-            break;
-        }
-        default:
-            break;
-        }
-    }
-#endif
-
     // If we are the original transmitter, set the hop limit with which we start
     if (isFromUs(p))
         p->hop_start = p->hop_limit;
@@ -580,7 +555,9 @@ DecodeState perhapsDecode(meshtastic_MeshPacket *p)
         } */
 
         printPacket("decoded message", p);
-#if ARCH_PORTDUINO
+#if ENABLE_JSON_LOGGING
+        LOG_TRACE("%s", MeshPacketSerializer::JsonSerialize(p, false).c_str());
+#elif ARCH_PORTDUINO
         if (portduino_config.traceFilename != "" || portduino_config.logoutputlevel == level_trace) {
             LOG_TRACE("%s", MeshPacketSerializer::JsonSerialize(p, false).c_str());
         } else if (portduino_config.JSONFilename != "") {
@@ -875,7 +852,11 @@ void Router::handleReceived(meshtastic_MeshPacket *p, RxSource src)
 
 void Router::perhapsHandleReceived(meshtastic_MeshPacket *p)
 {
-#if ARCH_PORTDUINO
+#if ENABLE_JSON_LOGGING
+    // Even ignored packets get logged in the trace
+    p->rx_time = getValidTime(RTCQualityFromNet); // store the arrival timestamp for the phone
+    LOG_TRACE("%s", MeshPacketSerializer::JsonSerializeEncrypted(p).c_str());
+#elif ARCH_PORTDUINO
     // Even ignored packets get logged in the trace
     if (portduino_config.traceFilename != "" || portduino_config.logoutputlevel == level_trace) {
         p->rx_time = getValidTime(RTCQualityFromNet); // store the arrival timestamp for the phone

src/mesh/SX128xInterface.h

@@ -19,9 +19,6 @@ template <class T> class SX128xInterface : public RadioLibInterface
 
     virtual bool wideLora() override;
 
-    /// SX128x is a 2.4 GHz-only chip; it cannot tune sub-GHz regions
-    virtual bool supportsSubGhz() override { return false; }
-
     /// Apply any radio provisioning changes
     /// Make sure the Driver is properly configured before calling init().
     /// \return true if initialisation succeeded.

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

@@ -198,28 +198,6 @@ typedef struct _meshtastic_LockdownAuth {
  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;
-    /* Disable lockdown mode. Requires a valid passphrase in the same
- message (the device must prove the operator owns it before
- reverting at-rest encryption). On success the firmware decrypts
- every stored config / channel / nodedb file back to plaintext,
- removes the wrapped DEK, unlock token, monotonic-counter, and
- backoff files, and reboots out of lockdown.
-
- This is the inverse of the provision/unlock path: it is how the
- client app's "lockdown mode" toggle returns a device to normal
- operation.
-
- NOT reversed by this operation: APPROTECT. Once the debug port
- lockout has been burned (on silicon where it is effective) it is
- permanent — disabling lockdown decrypts your data and removes the
- access gates, but the SWD/JTAG port stays locked for the life of
- the device (recoverable only via a full chip erase over a debug
- probe, which destroys all data). Clients should make this
- irreversibility clear at the moment lockdown is first enabled.
-
- When true the passphrase field is still required; boots_remaining,
- valid_until_epoch, max_session_seconds, and lock_now are ignored. */
-    bool disable;
 } meshtastic_LockdownAuth;
 
 /* Parameters for setting up Meshtastic for ameteur radio usage */
@@ -543,7 +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, 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}
@@ -556,7 +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, 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}
@@ -579,7 +557,6 @@ extern "C" {
 #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_LockdownAuth_disable_tag      6
 #define meshtastic_HamParameters_call_sign_tag   1
 #define meshtastic_HamParameters_tx_power_tag    2
 #define meshtastic_HamParameters_frequency_tag   3
@@ -777,8 +754,7 @@ 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) \
-X(a, STATIC,   SINGULAR, BOOL,     disable,           6)
+X(a, STATIC,   SINGULAR, UINT32,   max_session_seconds,   5)
 #define meshtastic_LockdownAuth_CALLBACK NULL
 #define meshtastic_LockdownAuth_DEFAULT NULL
 
@@ -893,7 +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             56
+#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/config.pb.h

@@ -309,11 +309,7 @@ typedef enum _meshtastic_Config_LoRaConfig_RegionCode {
     meshtastic_Config_LoRaConfig_RegionCode_ITU2_70CM = 35,
     /* ITU Region 3 Amateur Radio 70cm band (430-450 MHz)
  Note: Some countries do not allocate 440-450 MHz. Check local law! */
-    meshtastic_Config_LoRaConfig_RegionCode_ITU3_70CM = 36,
-    /* ITU Region 2 Amateur Radio 1.25m '125cm' band (220-225 MHz)
- Note: Some countries do not allocate 220-222 MHz (Ex: USA/Canada).
- Check local law! */
-    meshtastic_Config_LoRaConfig_RegionCode_ITU2_125CM = 37
+    meshtastic_Config_LoRaConfig_RegionCode_ITU3_70CM = 36
 } meshtastic_Config_LoRaConfig_RegionCode;
 
 /* Standard predefined channel settings
@@ -360,21 +356,7 @@ typedef enum _meshtastic_Config_LoRaConfig_ModemPreset {
     /* Narrow Slow
  Moderate range preset optimized for EU 868MHz band with 62.5kHz bandwidth.
  Comparable link budget and data rate to LONG_FAST. */
-    meshtastic_Config_LoRaConfig_ModemPreset_NARROW_SLOW = 13,
-    /* Tiny Fast
- Preset optimized for compliance with Amateur Radio restrictions with 20kHz bandwidth.
- Many regions limit data transmission bandwidth in lower amateur bands (2 Meter).
- Note: TCXO with tight tolerances (±5 ppm or better) is *absolutely required* at these narrow bandwidths.
- Only compatible with SX127x and SX126x chipsets.
- Comparable link budget and data rate to LONG_FAST. */
-    meshtastic_Config_LoRaConfig_ModemPreset_TINY_FAST = 14,
-    /* Tiny Slow
- Preset optimized for compliance with Amateur Radio restrictions with 20kHz bandwidth.
- Many regions limit data transmission bandwidth in lower amateur bands (2 Meter).
- Note: TCXO with tight tolerances (±5 ppm or better) is *absolutely required* at these narrow bandwidths.
- Only compatible with SX127x and SX126x chipsets.
- Comparable link budget and data rate to LONG_MODERATE. */
-    meshtastic_Config_LoRaConfig_ModemPreset_TINY_SLOW = 15
+    meshtastic_Config_LoRaConfig_ModemPreset_NARROW_SLOW = 13
 } meshtastic_Config_LoRaConfig_ModemPreset;
 
 typedef enum _meshtastic_Config_LoRaConfig_FEM_LNA_Mode {
@@ -763,12 +745,12 @@ extern "C" {
 #define _meshtastic_Config_DisplayConfig_CompassOrientation_ARRAYSIZE ((meshtastic_Config_DisplayConfig_CompassOrientation)(meshtastic_Config_DisplayConfig_CompassOrientation_DEGREES_270_INVERTED+1))
 
 #define _meshtastic_Config_LoRaConfig_RegionCode_MIN meshtastic_Config_LoRaConfig_RegionCode_UNSET
-#define _meshtastic_Config_LoRaConfig_RegionCode_MAX meshtastic_Config_LoRaConfig_RegionCode_ITU2_125CM
-#define _meshtastic_Config_LoRaConfig_RegionCode_ARRAYSIZE ((meshtastic_Config_LoRaConfig_RegionCode)(meshtastic_Config_LoRaConfig_RegionCode_ITU2_125CM+1))
+#define _meshtastic_Config_LoRaConfig_RegionCode_MAX meshtastic_Config_LoRaConfig_RegionCode_ITU3_70CM
+#define _meshtastic_Config_LoRaConfig_RegionCode_ARRAYSIZE ((meshtastic_Config_LoRaConfig_RegionCode)(meshtastic_Config_LoRaConfig_RegionCode_ITU3_70CM+1))
 
 #define _meshtastic_Config_LoRaConfig_ModemPreset_MIN meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST
-#define _meshtastic_Config_LoRaConfig_ModemPreset_MAX meshtastic_Config_LoRaConfig_ModemPreset_TINY_SLOW
-#define _meshtastic_Config_LoRaConfig_ModemPreset_ARRAYSIZE ((meshtastic_Config_LoRaConfig_ModemPreset)(meshtastic_Config_LoRaConfig_ModemPreset_TINY_SLOW+1))
+#define _meshtastic_Config_LoRaConfig_ModemPreset_MAX meshtastic_Config_LoRaConfig_ModemPreset_NARROW_SLOW
+#define _meshtastic_Config_LoRaConfig_ModemPreset_ARRAYSIZE ((meshtastic_Config_LoRaConfig_ModemPreset)(meshtastic_Config_LoRaConfig_ModemPreset_NARROW_SLOW+1))
 
 #define _meshtastic_Config_LoRaConfig_FEM_LNA_Mode_MIN meshtastic_Config_LoRaConfig_FEM_LNA_Mode_DISABLED
 #define _meshtastic_Config_LoRaConfig_FEM_LNA_Mode_MAX meshtastic_Config_LoRaConfig_FEM_LNA_Mode_NOT_PRESENT

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

@@ -621,9 +621,7 @@ typedef enum _meshtastic_MeshPacket_TransportMechanism {
     /* Arrived via Multicast UDP */
     meshtastic_MeshPacket_TransportMechanism_TRANSPORT_MULTICAST_UDP = 6,
     /* Arrived via API connection */
-    meshtastic_MeshPacket_TransportMechanism_TRANSPORT_API = 7,
-    /* Arrived via Unicast UDP */
-    meshtastic_MeshPacket_TransportMechanism_TRANSPORT_UNICAST_UDP = 8
+    meshtastic_MeshPacket_TransportMechanism_TRANSPORT_API = 7
 } meshtastic_MeshPacket_TransportMechanism;
 
 /* Log levels, chosen to match python logging conventions. */
@@ -660,14 +658,7 @@ typedef enum _meshtastic_LockdownStatus_State {
  token's TTL. */
     meshtastic_LockdownStatus_State_UNLOCKED = 3,
     /* Passphrase rejected. backoff_seconds is non-zero when rate-limited. */
-    meshtastic_LockdownStatus_State_UNLOCK_FAILED = 4,
-    /* Lockdown is supported by this firmware but not currently active
- (no passphrase has been provisioned, or it was disabled via
- AdminMessage.lockdown_auth.disable). The device is operating in
- normal, non-encrypted mode. Clients render the lockdown-mode
- toggle as OFF on receiving this. Distinct from NEEDS_PROVISION,
- which is only used during an in-progress enable flow. */
-    meshtastic_LockdownStatus_State_DISABLED = 5
+    meshtastic_LockdownStatus_State_UNLOCK_FAILED = 4
 } meshtastic_LockdownStatus_State;
 
 /* Struct definitions */
@@ -1534,16 +1525,16 @@ extern "C" {
 #define _meshtastic_MeshPacket_Delayed_ARRAYSIZE ((meshtastic_MeshPacket_Delayed)(meshtastic_MeshPacket_Delayed_DELAYED_DIRECT+1))
 
 #define _meshtastic_MeshPacket_TransportMechanism_MIN meshtastic_MeshPacket_TransportMechanism_TRANSPORT_INTERNAL
-#define _meshtastic_MeshPacket_TransportMechanism_MAX meshtastic_MeshPacket_TransportMechanism_TRANSPORT_UNICAST_UDP
-#define _meshtastic_MeshPacket_TransportMechanism_ARRAYSIZE ((meshtastic_MeshPacket_TransportMechanism)(meshtastic_MeshPacket_TransportMechanism_TRANSPORT_UNICAST_UDP+1))
+#define _meshtastic_MeshPacket_TransportMechanism_MAX meshtastic_MeshPacket_TransportMechanism_TRANSPORT_API
+#define _meshtastic_MeshPacket_TransportMechanism_ARRAYSIZE ((meshtastic_MeshPacket_TransportMechanism)(meshtastic_MeshPacket_TransportMechanism_TRANSPORT_API+1))
 
 #define _meshtastic_LogRecord_Level_MIN meshtastic_LogRecord_Level_UNSET
 #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_DISABLED
-#define _meshtastic_LockdownStatus_State_ARRAYSIZE ((meshtastic_LockdownStatus_State)(meshtastic_LockdownStatus_State_DISABLED+1))
+#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

src/mesh/http/ContentHandler.cpp

@@ -11,12 +11,11 @@
 #endif
 #include "SPILock.h"
 #include "power.h"
+#include "serialization/JSON.h"
 #include <FSCommon.h>
 #include <HTTPBodyParser.hpp>
 #include <HTTPMultipartBodyParser.hpp>
 #include <HTTPURLEncodedBodyParser.hpp>
-#include <cmath>
-#include <sstream>
 
 #ifdef ARCH_ESP32
 #include "esp_task_wdt.h"
@@ -260,95 +259,40 @@ void htmlDeleteDir(const char *dirname)
     root.close();
 }
 
-// Escape a string into a JSON double-quoted literal. Matches the previous
-// SimpleJSON StringifyString behavior (0x00-0x1F and 0x7F -> \u00xx lowercase,
-// escapes " \ / \b \f \n \r \t, UTF-8 passes through unchanged).
-static std::string jsonEscape(const std::string &str)
-{
-    std::string out = "\"";
-    for (size_t i = 0; i < str.size(); ++i) {
-        char chr = str[i];
-        if (chr == '"' || chr == '\\' || chr == '/') {
-            out += '\\';
-            out += chr;
-        } else if (chr == '\b') {
-            out += "\\b";
-        } else if (chr == '\f') {
-            out += "\\f";
-        } else if (chr == '\n') {
-            out += "\\n";
-        } else if (chr == '\r') {
-            out += "\\r";
-        } else if (chr == '\t') {
-            out += "\\t";
-        } else if ((unsigned char)chr < 0x20 || chr == 0x7F) {
-            char buf[8];
-            snprintf(buf, sizeof(buf), "\\u%04x", (unsigned char)chr);
-            out += buf;
-        } else {
-            out += chr;
-        }
-    }
-    out += "\"";
-    return out;
-}
-
-// Format a numeric value the way the previous SimpleJSON serializer did
-// (std::stringstream with precision 15, NaN/Inf -> "null").
-static std::string jsonNum(double v)
-{
-    if (std::isinf(v) || std::isnan(v))
-        return "null";
-    std::ostringstream ss;
-    ss.precision(15);
-    ss << v;
-    return ss.str();
-}
-
-// Build a serialized JSON array string listing files in `dirname`.
-// Subdirectories recurse as nested arrays (up to `levels` deep).
-std::string htmlListDir(const char *dirname, uint8_t levels)
+JSONArray htmlListDir(const char *dirname, uint8_t levels)
 {
     File root = FSCom.open(dirname, FILE_O_READ);
-    std::string out = "[";
-    bool first = true;
+    JSONArray fileList;
     if (!root) {
-        out += "]";
-        return out;
+        return fileList;
     }
     if (!root.isDirectory()) {
-        out += "]";
-        return out;
+        return fileList;
     }
 
     // iterate over the file list
     File file = root.openNextFile();
     while (file) {
-        std::string element;
-        bool haveElement = false;
         if (file.isDirectory() && !String(file.name()).endsWith(".")) {
             if (levels) {
 #ifdef ARCH_ESP32
-                element = htmlListDir(file.path(), levels - 1);
+                fileList.push_back(new JSONValue(htmlListDir(file.path(), levels - 1)));
 #else
-                element = htmlListDir(file.name(), levels - 1);
+                fileList.push_back(new JSONValue(htmlListDir(file.name(), levels - 1)));
 #endif
-                haveElement = true;
                 file.close();
             }
         } else {
+            JSONObject thisFileMap;
+            thisFileMap["size"] = new JSONValue((int)file.size());
 #ifdef ARCH_ESP32
             String fileName = String(file.path()).substring(1);
+            thisFileMap["name"] = new JSONValue(fileName.c_str());
 #else
             String fileName = String(file.name()).substring(1);
+            thisFileMap["name"] = new JSONValue(fileName.c_str());
 #endif
             String tempName = String(file.name()).substring(1);
-            // Keys in the previous std::map<string,...> were emitted in
-            // alphabetical order: name, nameModified, size.
-            element = "{";
-            element += jsonEscape("name");
-            element += ":";
-            element += jsonEscape(fileName.c_str());
             if (tempName.endsWith(".gz")) {
 #ifdef ARCH_ESP32
                 String modifiedFile = String(file.path()).substring(1);
@@ -356,30 +300,15 @@ std::string htmlListDir(const char *dirname, uint8_t levels)
                 String modifiedFile = String(file.name()).substring(1);
 #endif
                 modifiedFile.remove((modifiedFile.length() - 3), 3);
-                element += ",";
-                element += jsonEscape("nameModified");
-                element += ":";
-                element += jsonEscape(modifiedFile.c_str());
+                thisFileMap["nameModified"] = new JSONValue(modifiedFile.c_str());
             }
-            element += ",";
-            element += jsonEscape("size");
-            element += ":";
-            element += jsonNum((int)file.size());
-            element += "}";
-            haveElement = true;
-        }
-        if (haveElement) {
-            if (!first)
-                out += ",";
-            out += element;
-            first = false;
+            fileList.push_back(new JSONValue(thisFileMap));
         }
         file.close();
         file = root.openNextFile();
     }
     root.close();
-    out += "]";
-    return out;
+    return fileList;
 }
 
 void handleFsBrowseStatic(HTTPRequest *req, HTTPResponse *res)
@@ -389,25 +318,28 @@ void handleFsBrowseStatic(HTTPRequest *req, HTTPResponse *res)
     res->setHeader("Access-Control-Allow-Methods", "GET");
 
     concurrency::LockGuard g(spiLock);
-    std::string fileList = htmlListDir("/static", 10);
+    auto fileList = htmlListDir("/static", 10);
 
-    uint64_t total = FSCom.totalBytes();
-    uint64_t used = FSCom.usedBytes();
+    // create json output structure
+    JSONObject filesystemObj;
+    filesystemObj["total"] = new JSONValue((int)FSCom.totalBytes());
+    filesystemObj["used"] = new JSONValue((int)FSCom.usedBytes());
+    filesystemObj["free"] = new JSONValue(int(FSCom.totalBytes() - FSCom.usedBytes()));
 
-    // Key order matches the previous std::map-based emission (alphabetical).
-    std::string out;
-    out.reserve(fileList.size() + 128);
-    out += "{\"data\":{\"files\":";
-    out += fileList;
-    out += ",\"filesystem\":{\"free\":";
-    out += jsonNum((int)(total - used));
-    out += ",\"total\":";
-    out += jsonNum((int)total);
-    out += ",\"used\":";
-    out += jsonNum((int)used);
-    out += "}},\"status\":\"ok\"}";
+    JSONObject jsonObjInner;
+    jsonObjInner["files"] = new JSONValue(fileList);
+    jsonObjInner["filesystem"] = new JSONValue(filesystemObj);
 
-    res->print(out.c_str());
+    JSONObject jsonObjOuter;
+    jsonObjOuter["data"] = new JSONValue(jsonObjInner);
+    jsonObjOuter["status"] = new JSONValue("ok");
+
+    JSONValue *value = new JSONValue(jsonObjOuter);
+
+    std::string jsonString = value->Stringify();
+    res->print(jsonString.c_str());
+
+    delete value;
 }
 
 void handleFsDeleteStatic(HTTPRequest *req, HTTPResponse *res)
@@ -422,13 +354,27 @@ void handleFsDeleteStatic(HTTPRequest *req, HTTPResponse *res)
     if (params->getQueryParameter("delete", paramValDelete)) {
         std::string pathDelete = "/" + paramValDelete;
         concurrency::LockGuard g(spiLock);
-        const char *status = FSCom.remove(pathDelete.c_str()) ? "ok" : "Error";
-        LOG_INFO("%s", pathDelete.c_str());
-        std::string out = "{\"status\":";
-        out += jsonEscape(status);
-        out += "}";
-        res->print(out.c_str());
-        return;
+        if (FSCom.remove(pathDelete.c_str())) {
+
+            LOG_INFO("%s", pathDelete.c_str());
+            JSONObject jsonObjOuter;
+            jsonObjOuter["status"] = new JSONValue("ok");
+            JSONValue *value = new JSONValue(jsonObjOuter);
+            std::string jsonString = value->Stringify();
+            res->print(jsonString.c_str());
+            delete value;
+            return;
+        } else {
+
+            LOG_INFO("%s", pathDelete.c_str());
+            JSONObject jsonObjOuter;
+            jsonObjOuter["status"] = new JSONValue("Error");
+            JSONValue *value = new JSONValue(jsonObjOuter);
+            std::string jsonString = value->Stringify();
+            res->print(jsonString.c_str());
+            delete value;
+            return;
+        }
     }
 }
 
@@ -669,113 +615,95 @@ void handleReport(HTTPRequest *req, HTTPResponse *res)
         res->println("<pre>");
     }
 
-    auto arrayFromLog = [](const uint32_t *logArray, int count) -> std::string {
-        std::string s = "[";
+    // Helper lambda to create JSON array and clean up memory properly
+    auto createJSONArrayFromLog = [](const uint32_t *logArray, int count) -> JSONValue * {
+        JSONArray tempArray;
         for (int i = 0; i < count; i++) {
-            if (i)
-                s += ",";
-            s += jsonNum((int)logArray[i]);
+            tempArray.push_back(new JSONValue((int)logArray[i]));
         }
-        s += "]";
-        return s;
+        JSONValue *result = new JSONValue(tempArray);
+        // Note: Don't delete tempArray elements here - JSONValue now owns them
+        return result;
     };
 
+    // data->airtime->tx_log
     uint32_t *logArray;
     logArray = airTime->airtimeReport(TX_LOG);
-    std::string txLog = arrayFromLog(logArray, airTime->getPeriodsToLog());
-    logArray = airTime->airtimeReport(RX_LOG);
-    std::string rxLog = arrayFromLog(logArray, airTime->getPeriodsToLog());
-    logArray = airTime->airtimeReport(RX_ALL_LOG);
-    std::string rxAllLog = arrayFromLog(logArray, airTime->getPeriodsToLog());
+    JSONValue *txLogJsonValue = createJSONArrayFromLog(logArray, airTime->getPeriodsToLog());
 
+    // data->airtime->rx_log
+    logArray = airTime->airtimeReport(RX_LOG);
+    JSONValue *rxLogJsonValue = createJSONArrayFromLog(logArray, airTime->getPeriodsToLog());
+
+    // data->airtime->rx_all_log
+    logArray = airTime->airtimeReport(RX_ALL_LOG);
+    JSONValue *rxAllLogJsonValue = createJSONArrayFromLog(logArray, airTime->getPeriodsToLog());
+
+    // data->airtime
+    JSONObject jsonObjAirtime;
+    jsonObjAirtime["tx_log"] = txLogJsonValue;
+    jsonObjAirtime["rx_log"] = rxLogJsonValue;
+    jsonObjAirtime["rx_all_log"] = rxAllLogJsonValue;
+    jsonObjAirtime["channel_utilization"] = new JSONValue(airTime->channelUtilizationPercent());
+    jsonObjAirtime["utilization_tx"] = new JSONValue(airTime->utilizationTXPercent());
+    jsonObjAirtime["seconds_since_boot"] = new JSONValue(int(airTime->getSecondsSinceBoot()));
+    jsonObjAirtime["seconds_per_period"] = new JSONValue(int(airTime->getSecondsPerPeriod()));
+    jsonObjAirtime["periods_to_log"] = new JSONValue(airTime->getPeriodsToLog());
+
+    // data->wifi
+    JSONObject jsonObjWifi;
+    jsonObjWifi["rssi"] = new JSONValue(WiFi.RSSI());
     String wifiIPString = WiFi.localIP().toString();
     std::string wifiIP = wifiIPString.c_str();
+    jsonObjWifi["ip"] = new JSONValue(wifiIP.c_str());
 
+    // data->memory
+    JSONObject jsonObjMemory;
+    jsonObjMemory["heap_total"] = new JSONValue((int)memGet.getHeapSize());
+    jsonObjMemory["heap_free"] = new JSONValue((int)memGet.getFreeHeap());
+    jsonObjMemory["psram_total"] = new JSONValue((int)memGet.getPsramSize());
+    jsonObjMemory["psram_free"] = new JSONValue((int)memGet.getFreePsram());
     spiLock->lock();
-    uint64_t fsTotal = FSCom.totalBytes();
-    uint64_t fsUsed = FSCom.usedBytes();
+    jsonObjMemory["fs_total"] = new JSONValue((int)FSCom.totalBytes());
+    jsonObjMemory["fs_used"] = new JSONValue((int)FSCom.usedBytes());
+    jsonObjMemory["fs_free"] = new JSONValue(int(FSCom.totalBytes() - FSCom.usedBytes()));
     spiLock->unlock();
 
-    // Emit keys in the same alphabetical order as the previous
-    // std::map-based JSON output to keep responses byte-compatible.
-    std::string out;
-    out.reserve(1024);
-    out += "{\"data\":{";
+    // data->power
+    JSONObject jsonObjPower;
+    jsonObjPower["battery_percent"] = new JSONValue(powerStatus->getBatteryChargePercent());
+    jsonObjPower["battery_voltage_mv"] = new JSONValue(powerStatus->getBatteryVoltageMv());
+    jsonObjPower["has_battery"] = new JSONValue(BoolToString(powerStatus->getHasBattery()));
+    jsonObjPower["has_usb"] = new JSONValue(BoolToString(powerStatus->getHasUSB()));
+    jsonObjPower["is_charging"] = new JSONValue(BoolToString(powerStatus->getIsCharging()));
 
-    // airtime
-    out += "\"airtime\":{";
-    out += "\"channel_utilization\":";
-    out += jsonNum(airTime->channelUtilizationPercent());
-    out += ",\"periods_to_log\":";
-    out += jsonNum(airTime->getPeriodsToLog());
-    out += ",\"rx_all_log\":";
-    out += rxAllLog;
-    out += ",\"rx_log\":";
-    out += rxLog;
-    out += ",\"seconds_per_period\":";
-    out += jsonNum((int)airTime->getSecondsPerPeriod());
-    out += ",\"seconds_since_boot\":";
-    out += jsonNum((int)airTime->getSecondsSinceBoot());
-    out += ",\"tx_log\":";
-    out += txLog;
-    out += ",\"utilization_tx\":";
-    out += jsonNum(airTime->utilizationTXPercent());
-    out += "}";
+    // data->device
+    JSONObject jsonObjDevice;
+    jsonObjDevice["reboot_counter"] = new JSONValue((int)myNodeInfo.reboot_count);
 
-    // device
-    out += ",\"device\":{\"reboot_counter\":";
-    out += jsonNum((int)myNodeInfo.reboot_count);
-    out += "}";
+    // data->radio
+    JSONObject jsonObjRadio;
+    jsonObjRadio["frequency"] = new JSONValue(RadioLibInterface::instance->getFreq());
+    jsonObjRadio["lora_channel"] = new JSONValue((int)RadioLibInterface::instance->getChannelNum() + 1);
 
-    // memory
-    out += ",\"memory\":{";
-    out += "\"fs_free\":";
-    out += jsonNum((int)(fsTotal - fsUsed));
-    out += ",\"fs_total\":";
-    out += jsonNum((int)fsTotal);
-    out += ",\"fs_used\":";
-    out += jsonNum((int)fsUsed);
-    out += ",\"heap_free\":";
-    out += jsonNum((int)memGet.getFreeHeap());
-    out += ",\"heap_total\":";
-    out += jsonNum((int)memGet.getHeapSize());
-    out += ",\"psram_free\":";
-    out += jsonNum((int)memGet.getFreePsram());
-    out += ",\"psram_total\":";
-    out += jsonNum((int)memGet.getPsramSize());
-    out += "}";
+    // collect data to inner data object
+    JSONObject jsonObjInner;
+    jsonObjInner["airtime"] = new JSONValue(jsonObjAirtime);
+    jsonObjInner["wifi"] = new JSONValue(jsonObjWifi);
+    jsonObjInner["memory"] = new JSONValue(jsonObjMemory);
+    jsonObjInner["power"] = new JSONValue(jsonObjPower);
+    jsonObjInner["device"] = new JSONValue(jsonObjDevice);
+    jsonObjInner["radio"] = new JSONValue(jsonObjRadio);
 
-    // power (has_* / is_charging were serialized as the strings "true"/"false")
-    out += ",\"power\":{";
-    out += "\"battery_percent\":";
-    out += jsonNum(powerStatus->getBatteryChargePercent());
-    out += ",\"battery_voltage_mv\":";
-    out += jsonNum(powerStatus->getBatteryVoltageMv());
-    out += ",\"has_battery\":";
-    out += jsonEscape(BoolToString(powerStatus->getHasBattery()));
-    out += ",\"has_usb\":";
-    out += jsonEscape(BoolToString(powerStatus->getHasUSB()));
-    out += ",\"is_charging\":";
-    out += jsonEscape(BoolToString(powerStatus->getIsCharging()));
-    out += "}";
-
-    // radio
-    out += ",\"radio\":{\"frequency\":";
-    out += jsonNum(RadioLibInterface::instance->getFreq());
-    out += ",\"lora_channel\":";
-    out += jsonNum((int)RadioLibInterface::instance->getChannelNum() + 1);
-    out += "}";
-
-    // wifi
-    out += ",\"wifi\":{\"ip\":";
-    out += jsonEscape(wifiIP);
-    out += ",\"rssi\":";
-    out += jsonNum(WiFi.RSSI());
-    out += "}";
-
-    out += "},\"status\":\"ok\"}";
-
-    res->print(out.c_str());
+    // create json output structure
+    JSONObject jsonObjOuter;
+    jsonObjOuter["data"] = new JSONValue(jsonObjInner);
+    jsonObjOuter["status"] = new JSONValue("ok");
+    // serialize and write it to the stream
+    JSONValue *value = new JSONValue(jsonObjOuter);
+    std::string jsonString = value->Stringify();
+    res->print(jsonString.c_str());
+    delete value;
 }
 
 void handleNodes(HTTPRequest *req, HTTPResponse *res)
@@ -796,66 +724,58 @@ void handleNodes(HTTPRequest *req, HTTPResponse *res)
         res->println("<pre>");
     }
 
-    std::string out;
-    out.reserve(2048);
-    out += "{\"data\":{\"nodes\":[";
+    JSONArray nodesArray;
 
-    bool firstNode = true;
     uint32_t readIndex = 0;
     const meshtastic_NodeInfoLite *tempNodeInfo = nodeDB->readNextMeshNode(readIndex);
     while (tempNodeInfo != NULL) {
         if (nodeInfoLiteHasUser(tempNodeInfo)) {
+            JSONObject node;
+
             char id[16];
             snprintf(id, sizeof(id), "!%08x", tempNodeInfo->num);
 
-            std::string position;
+            node["id"] = new JSONValue(id);
+            node["snr"] = new JSONValue(tempNodeInfo->snr);
+            node["via_mqtt"] = new JSONValue(BoolToString(nodeInfoLiteViaMqtt(tempNodeInfo)));
+            node["last_heard"] = new JSONValue((int)tempNodeInfo->last_heard);
+            node["position"] = new JSONValue();
+
             if (nodeDB->hasValidPosition(tempNodeInfo)) {
                 meshtastic_PositionLite posLite;
                 if (nodeDB->copyNodePosition(tempNodeInfo->num, posLite)) {
-                    position = "{\"altitude\":";
-                    position += jsonNum((int)posLite.altitude);
-                    position += ",\"latitude\":";
-                    position += jsonNum((float)posLite.latitude_i * 1e-7);
-                    position += ",\"longitude\":";
-                    position += jsonNum((float)posLite.longitude_i * 1e-7);
-                    position += "}";
-                } else {
-                    position = "null";
+                    JSONObject position;
+                    position["latitude"] = new JSONValue((float)posLite.latitude_i * 1e-7);
+                    position["longitude"] = new JSONValue((float)posLite.longitude_i * 1e-7);
+                    position["altitude"] = new JSONValue((int)posLite.altitude);
+                    node["position"] = new JSONValue(position);
                 }
-            } else {
-                position = "null";
             }
 
-            if (!firstNode)
-                out += ",";
-            firstNode = false;
+            node["long_name"] = new JSONValue(tempNodeInfo->long_name);
+            node["short_name"] = new JSONValue(tempNodeInfo->short_name);
+            // mac_address dropped from NodeInfoLite as part of the slim refactor; emit zeros.
+            node["mac_address"] = new JSONValue("00:00:00:00:00:00");
+            node["hw_model"] = new JSONValue(tempNodeInfo->hw_model);
 
-            // Alphabetical key order matches previous std::map-based output.
-            out += "{\"hw_model\":";
-            out += jsonNum(tempNodeInfo->hw_model);
-            out += ",\"id\":";
-            out += jsonEscape(id);
-            out += ",\"last_heard\":";
-            out += jsonNum((int)tempNodeInfo->last_heard);
-            out += ",\"long_name\":";
-            out += jsonEscape(tempNodeInfo->long_name);
-            out += ",\"mac_address\":";
-            out += jsonEscape("00:00:00:00:00:00");
-            out += ",\"position\":";
-            out += position;
-            out += ",\"short_name\":";
-            out += jsonEscape(tempNodeInfo->short_name);
-            out += ",\"snr\":";
-            out += jsonNum(tempNodeInfo->snr);
-            out += ",\"via_mqtt\":";
-            out += jsonEscape(BoolToString(nodeInfoLiteViaMqtt(tempNodeInfo)));
-            out += "}";
+            nodesArray.push_back(new JSONValue(node));
         }
         tempNodeInfo = nodeDB->readNextMeshNode(readIndex);
     }
 
-    out += "]},\"status\":\"ok\"}";
-    res->print(out.c_str());
+    // collect data to inner data object
+    JSONObject jsonObjInner;
+    jsonObjInner["nodes"] = new JSONValue(nodesArray);
+
+    // create json output structure
+    JSONObject jsonObjOuter;
+    jsonObjOuter["data"] = new JSONValue(jsonObjInner);
+    jsonObjOuter["status"] = new JSONValue("ok");
+    // serialize and write it to the stream
+    JSONValue *value = new JSONValue(jsonObjOuter);
+    std::string jsonString = value->Stringify();
+    res->print(jsonString.c_str());
+    delete value;
 }
 
 /*
@@ -977,28 +897,20 @@ void handleScanNetworks(HTTPRequest *req, HTTPResponse *res)
 
     int n = WiFi.scanNetworks();
 
-    std::string out = "{\"data\":[";
-    bool firstNet = true;
+    // build list of network objects
+    JSONArray networkObjs;
     if (n > 0) {
         for (int i = 0; i < n; ++i) {
             char ssidArray[50];
-            // The previous implementation pre-escaped quotes before handing
-            // the value to the JSON serializer; preserve that (byte-compatible
-            // even if it double-encodes a quote) so existing clients are not
-            // affected by this refactor.
             String ssidString = String(WiFi.SSID(i));
             ssidString.replace("\"", "\\\"");
             ssidString.toCharArray(ssidArray, 50);
 
             if (WiFi.encryptionType(i) != WIFI_AUTH_OPEN) {
-                if (!firstNet)
-                    out += ",";
-                firstNet = false;
-                out += "{\"rssi\":";
-                out += jsonNum((int)WiFi.RSSI(i));
-                out += ",\"ssid\":";
-                out += jsonEscape(ssidArray);
-                out += "}";
+                JSONObject thisNetwork;
+                thisNetwork["ssid"] = new JSONValue(ssidArray);
+                thisNetwork["rssi"] = new JSONValue(int(WiFi.RSSI(i)));
+                networkObjs.push_back(new JSONValue(thisNetwork));
             }
             // Yield some cpu cycles to IP stack.
             //   This is important in case the list is large and it takes us time to return
@@ -1006,7 +918,16 @@ void handleScanNetworks(HTTPRequest *req, HTTPResponse *res)
             yield();
         }
     }
-    out += "],\"status\":\"ok\"}";
-    res->print(out.c_str());
+
+    // build output structure
+    JSONObject jsonObjOuter;
+    jsonObjOuter["data"] = new JSONValue(networkObjs);
+    jsonObjOuter["status"] = new JSONValue("ok");
+
+    // serialize and write it to the stream
+    JSONValue *value = new JSONValue(jsonObjOuter);
+    std::string jsonString = value->Stringify();
+    res->print(jsonString.c_str());
+    delete value;
 }
 #endif

src/mesh/mesh-pb-constants.h

@@ -109,15 +109,6 @@ static inline int get_max_num_nodes()
 #define HAS_TRAFFIC_MANAGEMENT 0
 #endif
 
-// HopScalingModule - variable hop module: dynamically adjusts broadcast hop_limit based on mesh density
-// Enable per-variant by defining HAS_VARIABLE_HOPS=1 in variant.h
-#ifdef ARCH_STM32WL
-#define HAS_VARIABLE_HOPS 0
-#endif
-#ifndef HAS_VARIABLE_HOPS
-#define HAS_VARIABLE_HOPS 1
-#endif
-
 // Cache size for traffic management (number of nodes to track)
 // Can be overridden per-variant based on available memory
 #ifndef TRAFFIC_MANAGEMENT_CACHE_SIZE

src/meshUtils.h

@@ -66,10 +66,4 @@ inline uint32_t pow_of_2(uint32_t n)
     return 1 << n;
 }
 
-/// Returns true if n is a power of two (n >= 1).
-template <typename T> constexpr bool is_pow_of_2(T n)
-{
-    return n >= T(1) && (n & (n - T(1))) == T(0);
-}
-
 #define IS_ONE_OF(item, ...) isOneOf(item, sizeof((int[]){__VA_ARGS__}) / sizeof(int), __VA_ARGS__)

src/modules/AdminModule.cpp

@@ -829,7 +829,7 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c, bool fromOthers)
                 }
                 if (strncmp(moduleConfig.mqtt.root, default_mqtt_root, strlen(default_mqtt_root)) == 0) {
                     //  Default root is in use, so subscribe to the appropriate MQTT topic for this region
-                    snprintf(moduleConfig.mqtt.root, sizeof(moduleConfig.mqtt.root), "%s/%s", default_mqtt_root, myRegion->name);
+                    sprintf(moduleConfig.mqtt.root, "%s/%s", default_mqtt_root, myRegion->name);
                 }
                 changes = SEGMENT_CONFIG | SEGMENT_MODULECONFIG;
             } else {
@@ -840,39 +840,13 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c, bool fromOthers)
 
         if (!RadioInterface::validateConfigLora(validatedLora)) {
             if (fromOthers) {
-                // A preset locked to a sibling EU region still swaps the region for remote admin;
-                // any other invalid config is rejected outright.
-                const RegionInfo *swapRegion =
-                    validatedLora.use_preset
-                        ? RadioInterface::regionSwapForPreset(validatedLora.region, validatedLora.modem_preset)
-                        : NULL;
-                if (swapRegion) {
-                    validatedLora.region = swapRegion->code;
-                }
-                if (!swapRegion || !RadioInterface::validateConfigLora(validatedLora)) {
-                    LOG_WARN("Invalid LoRa config received from another node, rejecting changes");
-                    // Rejecting means rejecting everything: a partial restore of region/preset
-                    // could still apply other fields the validation already deemed invalid.
-                    validatedLora = oldLoraConfig;
-                }
+                LOG_WARN("Invalid LoRa config received from another node, rejecting changes");
+                //  modem_preset set to use the old setting if the check fails
+                validatedLora.modem_preset = oldLoraConfig.modem_preset;
             } else {
                 LOG_WARN("Invalid LoRa config received from client, using corrected values");
                 RadioInterface::clampConfigLora(validatedLora);
             }
-            // A preset locked to a sibling EU region swaps the region during the clamp;
-            // apply the same housekeeping as an explicit region change.
-            if (validatedLora.region != oldLoraConfig.region) {
-                config.lora.region = validatedLora.region;
-                initRegion();
-                if (getEffectiveDutyCycle() < 100) {
-                    validatedLora.ignore_mqtt = true; // Ignore MQTT by default if region has a duty cycle limit
-                }
-                if (strncmp(moduleConfig.mqtt.root, default_mqtt_root, strlen(default_mqtt_root)) == 0) {
-                    //  Default root is in use, so subscribe to the appropriate MQTT topic for this region
-                    snprintf(moduleConfig.mqtt.root, sizeof(moduleConfig.mqtt.root), "%s/%s", default_mqtt_root, myRegion->name);
-                }
-                changes = SEGMENT_CONFIG | SEGMENT_MODULECONFIG;
-            }
             //  use_preset and bandwidth are coerced into valid values by the check.
         }
 
@@ -1489,10 +1463,6 @@ void AdminModule::handleSetHamMode(const meshtastic_HamParameters &p)
     }
     channels.onConfigChanged();
 
-    if (strcmp(p.call_sign, "N0CALL") == 0) {
-        config.lora.tx_enabled = false;
-    }
-
     service->reloadOwner(false);
     saveChanges(SEGMENT_CONFIG | SEGMENT_NODEDATABASE | SEGMENT_DEVICESTATE | SEGMENT_CHANNELS);
 }

src/modules/AdminModule.h

@@ -67,11 +67,7 @@ class AdminModule : public ProtobufModule<meshtastic_AdminMessage>, public Obser
   private:
     bool handleSetModuleConfig(const meshtastic_ModuleConfig &c);
     void handleSetChannel();
-
-  public:
     void handleSetHamMode(const meshtastic_HamParameters &req);
-
-  private:
     void handleStoreDeviceUIConfig(const meshtastic_DeviceUIConfig &uicfg);
     void handleSendInputEvent(const meshtastic_AdminMessage_InputEvent &inputEvent);
     void reboot(int32_t seconds);

src/modules/DMShell.cpp

@@ -0,0 +1,804 @@
+#include "DMShell.h"
+
+#if defined(ARCH_PORTDUINO)
+
+#include "Channels.h"
+#include "MeshService.h"
+#include "NodeDB.h"
+#include "Throttle.h"
+#include "configuration.h"
+#include "mesh/generated/meshtastic/mesh.pb.h"
+#include "mesh/mesh-pb-constants.h"
+#include "pb_decode.h"
+#include "pb_encode.h"
+#include <errno.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <pty.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+DMShellModule *dmShellModule;
+
+namespace
+{
+constexpr uint16_t PTY_COLS_DEFAULT = 120;
+constexpr uint16_t PTY_ROWS_DEFAULT = 40;
+constexpr size_t MAX_MESSAGE_SIZE = 200;
+
+// --- Half-duplex turn-taking ("talking stick") protocol, carried in RemoteShell.flags ---
+// On a 2-party LoRa link, Meshtastic's CSMA-CA breaks down when both ends transmit at once
+// (synchronized same-slot collisions that CAD can't prevent). These flags let exactly one
+// side transmit at a time, eliminating those collisions. The client is the master/idle-owner.
+constexpr uint32_t TURN_FLAG_GRANT = 0x01; // I am handing you the turn; you may transmit now
+constexpr uint32_t TURN_FLAG_MORE = 0x02;  // I yielded under a budget but still have data queued
+constexpr uint32_t TURN_FLAG_RTS = 0x04;   // I have output but no turn; please grant me one
+constexpr size_t TURN_BUDGET_FRAMES = 8;   // max output frames per granted turn before yielding (bounds interrupt latency)
+constexpr uint32_t RTS_RETRY_MS = 250;     // min interval between request-to-send frames
+// After being granted the turn we keep it for a short "linger" window, continuing to drain shell
+// output as it appears, instead of yielding the instant the PTY drains. This lets a command's
+// output (and the next prompt) ride the same turn as the keystroke that triggered it, avoiding a
+// full RTS->grant round-trip per command. The turn still ends promptly once the PTY is idle this
+// long, or once TURN_BUDGET_FRAMES is hit (so the client can interject, e.g. Ctrl-C).
+constexpr uint32_t TURN_LINGER_MS = 120;
+} // namespace
+
+DMShellModule::DMShellModule()
+    : SinglePortModule("DMShellModule", meshtastic_PortNum_REMOTE_SHELL_APP), concurrency::OSThread("DMShell", 100)
+{
+    LOG_WARN("DMShell enabled on Portduino: remote shell access is dangerous and intended for trusted debugging only");
+}
+
+ProcessMessage DMShellModule::handleReceived(const meshtastic_MeshPacket &mp)
+{
+    meshtastic_RemoteShell frame = meshtastic_RemoteShell_init_zero;
+    if (!mp.pki_encrypted) {
+        LOG_WARN("DMShell: ignoring packet without PKI from 0x%x", mp.from);
+        return ProcessMessage::STOP;
+    }
+
+    if (!parseFrame(mp, frame)) {
+        LOG_WARN("DMShell: ignoring malformed frame");
+        return ProcessMessage::STOP;
+    }
+
+    if (frame.op == meshtastic_RemoteShell_OpCode_ACK) {
+        if (session.active && frame.session_id == session.sessionId && getFrom(&mp) == session.peer) {
+            LOG_WARN("DMShell: Received ack from 0x%x 0x%x", getFrom(&mp), session.peer);
+            applyTurnFlags(frame);
+            if (frame.last_rx_seq > 0) {
+                resendFramesFrom(frame.last_rx_seq + 1);
+            }
+            // A standalone grant (client re-granting for MORE, replying to our RTS, or a heartbeat
+            // poll) is our cue to flush any pending shell output during this turn.
+            serviceTurn();
+        }
+        return ProcessMessage::CONTINUE;
+    }
+
+    if (frame.op >= 64) {
+        LOG_WARN("DMShell: ignoring frame with op code %d, seq %d", frame.op, frame.seq);
+        return ProcessMessage::CONTINUE;
+    }
+
+    if (!isAuthorizedPacket(mp)) {
+        LOG_WARN("DMShell: unauthorized sender 0x%x, %u", mp.from, frame.op);
+        myReply = allocErrorResponse(meshtastic_Routing_Error_NOT_AUTHORIZED, &mp);
+        return ProcessMessage::STOP;
+    }
+
+    if (frame.op == meshtastic_RemoteShell_OpCode_OPEN) {
+        LOG_WARN("DMShell: received OPEN from 0x%x sessionId=0x%x", mp.from, frame.session_id);
+        if (!openSession(mp, frame)) {
+            sendError("open_failed", getFrom(&mp));
+        }
+        return ProcessMessage::STOP;
+    }
+
+    if (!session.active || frame.session_id != session.sessionId || getFrom(&mp) != session.peer) {
+        if (!session.active) {
+            LOG_WARN("DMShell: no active session, rejecting op %d from 0x%x", frame.op, mp.from);
+        } else {
+            LOG_WARN("DMShell: session ID mismatch (got 0x%x expected 0x%x) or peer mismatch (got 0x%x expected 0x%x), rejecting "
+                     "op %d",
+                     frame.session_id, session.sessionId, mp.from, session.peer, frame.op);
+        }
+        sendError("invalid_session", getFrom(&mp));
+        return ProcessMessage::STOP;
+    }
+
+    // Honor channel-access flags before ordering checks: a GRANT transfers the turn regardless of
+    // whether this frame's payload is in order.
+    applyTurnFlags(frame);
+
+    if (!shouldProcessIncomingFrame(frame)) {
+        // We won't process the payload (gap/duplicate), but we may now hold the turn, so flush
+        // output and/or hand it back rather than stalling the link.
+        serviceTurn();
+        return ProcessMessage::STOP;
+    }
+
+    session.lastActivityMs = millis();
+
+    switch (frame.op) {
+    case meshtastic_RemoteShell_OpCode_INPUT:
+        if (!writeSessionInput(frame)) {
+            sendError("input_write_failed");
+        } else if (!session.turnManaged) {
+            // Legacy peer (no turn-taking): echo immediately as before. In managed mode the
+            // serviceTurn() call at the end of handleReceived drains the echo and yields the turn.
+            uint8_t outBuf[MAX_MESSAGE_SIZE];
+            const ssize_t bytesRead = read(session.masterFd, outBuf, sizeof(outBuf));
+            if (bytesRead > 0) {
+                LOG_WARN("DMShell: read %zd bytes from PTY", bytesRead);
+                meshtastic_RemoteShell frame = {
+                    .op = meshtastic_RemoteShell_OpCode_OUTPUT,
+                    .session_id = session.sessionId,
+                    .seq = session.nextTxSeq++,
+                    .ack_seq = session.lastAckedRxSeq,
+                    .cols = 0,
+                    .rows = 0,
+                    .flags = 0,
+                };
+                assert(bytesRead <= sizeof(frame.payload.bytes));
+                memcpy(frame.payload.bytes, outBuf, bytesRead);
+                frame.payload.size = bytesRead;
+                sendFrameToPeer(session.peer, frame, true);
+                session.lastActivityMs = millis();
+            }
+        }
+        break;
+    case meshtastic_RemoteShell_OpCode_RESIZE:
+        if (frame.rows > 0 && frame.cols > 0) {
+            struct winsize ws = {};
+            ws.ws_row = frame.rows;
+            ws.ws_col = frame.cols;
+            if (session.masterFd >= 0) {
+                ioctl(session.masterFd, TIOCSWINSZ, &ws);
+            }
+        }
+        break;
+    case meshtastic_RemoteShell_OpCode_PING: {
+        uint32_t peerLastRxSeq = frame.ack_seq;
+        if (frame.last_rx_seq > 0) {
+            peerLastRxSeq = frame.last_rx_seq;
+        }
+
+        const uint32_t nextMissingForPeer = peerLastRxSeq + 1;
+        if (nextMissingForPeer > 0 && nextMissingForPeer < session.nextTxSeq) {
+            resendFramesFrom(nextMissingForPeer);
+        }
+
+        meshtastic_RemoteShell frame = {
+            .op = meshtastic_RemoteShell_OpCode_PONG,
+            .session_id = session.sessionId,
+            .seq = session.nextTxSeq++,
+            .ack_seq = session.lastAckedRxSeq,
+            .cols = 0,
+            .rows = 0,
+            .flags = 0,
+            .last_tx_seq = session.nextTxSeq > 0 ? session.nextTxSeq - 1 : 0,
+            .last_rx_seq = session.lastAckedRxSeq,
+        };
+        frame.payload.size = 0;
+        sendFrameToPeer(session.peer, frame, true);
+        break;
+    }
+    case meshtastic_RemoteShell_OpCode_CLOSE:
+        closeSession("peer_close", true);
+        break;
+    default:
+        sendError("unsupported_op");
+        break;
+    }
+
+    // If the peer granted us the turn, flush pending shell output and hand the turn back.
+    serviceTurn();
+
+    return ProcessMessage::STOP;
+}
+
+int32_t DMShellModule::runOnce()
+{
+    processPendingChildReap();
+
+    if (!session.active) {
+        return 100;
+    }
+
+    reapChildIfExited();
+    if (!session.active) {
+        return 100;
+    }
+
+    if (Throttle::isWithinTimespanMs(session.lastActivityMs, SESSION_IDLE_TIMEOUT_MS) == false) {
+        closeSession("idle_timeout", true);
+        return 100;
+    }
+
+    if (RadioLibInterface::instance->packetsInTxQueue() > 1) {
+        return 50;
+    }
+
+    if (session.turnManaged) {
+        if (session.hasToken) {
+            // We hold the turn: flush output and hand it back.
+            serviceTurn();
+        } else if (ptyHasOutput() && !Throttle::isWithinTimespanMs(session.lastRtsMs, RTS_RETRY_MS)) {
+            // Unsolicited shell output but no turn: ask the client to grant us one.
+            sendRts();
+            session.lastRtsMs = millis();
+        }
+        return 50;
+    }
+
+    // Legacy free-send path (peer is not using turn-taking).
+    uint8_t outBuf[MAX_MESSAGE_SIZE];
+    while (session.masterFd >= 0) {
+        const ssize_t bytesRead = read(session.masterFd, outBuf, sizeof(outBuf));
+        if (bytesRead > 0) {
+            LOG_WARN("DMShell: read %zd bytes from PTY", bytesRead);
+
+            meshtastic_RemoteShell frame = {
+                .op = meshtastic_RemoteShell_OpCode_OUTPUT,
+                .session_id = session.sessionId,
+                .seq = session.nextTxSeq++,
+                .ack_seq = session.lastAckedRxSeq,
+                .cols = 0,
+                .rows = 0,
+                .flags = 0,
+            };
+            assert(bytesRead <= sizeof(frame.payload.bytes));
+            memcpy(frame.payload.bytes, outBuf, bytesRead);
+            frame.payload.size = bytesRead;
+            sendFrameToPeer(session.peer, frame, true);
+
+            session.lastActivityMs = millis();
+            // continue;
+            // do we want to ack every data message, and only send the next on ack?
+            // would require some retry logic. Maybe re-use the wantAck bit
+            return 50;
+        }
+
+        if (bytesRead == 0) {
+            closeSession("pty_eof", true);
+            break;
+        }
+
+        if (errno == EAGAIN || errno == EWOULDBLOCK) {
+            break;
+        }
+
+        LOG_WARN("DMShell: PTY read error errno=%d", errno);
+        closeSession("pty_read_error", true);
+        break;
+    }
+
+    return 100;
+}
+
+bool DMShellModule::parseFrame(const meshtastic_MeshPacket &mp, meshtastic_RemoteShell &outFrame)
+{
+    if (mp.which_payload_variant != meshtastic_MeshPacket_decoded_tag) {
+        return false;
+    }
+
+    if (pb_decode_from_bytes(mp.decoded.payload.bytes, mp.decoded.payload.size, meshtastic_RemoteShell_fields, &outFrame)) {
+        LOG_INFO("Received a DMShell message");
+    } else {
+        LOG_ERROR("Error decoding DMShell message!");
+        return false;
+    }
+
+    return true;
+}
+
+bool DMShellModule::isAuthorizedPacket(const meshtastic_MeshPacket &mp) const
+{
+    if (mp.from == 0) {
+        return !config.security.is_managed;
+    }
+
+    const meshtastic_Channel *ch = &channels.getByIndex(mp.channel);
+    if (strcasecmp(ch->settings.name, Channels::adminChannel) == 0) {
+        return config.security.admin_channel_enabled;
+    }
+
+    if (mp.pki_encrypted) {
+        for (uint8_t i = 0; i < 3; ++i) {
+            if (config.security.admin_key[i].size == 32 &&
+                memcmp(mp.public_key.bytes, config.security.admin_key[i].bytes, 32) == 0) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+bool DMShellModule::openSession(const meshtastic_MeshPacket &mp, const meshtastic_RemoteShell &frame)
+{
+    if (session.active) {
+        closeSession("preempted", false);
+    }
+
+    int masterFd = -1;
+    struct winsize ws = {};
+    if (frame.rows > 0) {
+        ws.ws_row = frame.rows;
+    } else {
+        ws.ws_row = PTY_ROWS_DEFAULT;
+    }
+    if (frame.cols > 0) {
+        ws.ws_col = frame.cols;
+    } else {
+        ws.ws_col = PTY_COLS_DEFAULT;
+    }
+    const pid_t childPid = forkpty(&masterFd, nullptr, nullptr, &ws);
+    if (childPid < 0) {
+        LOG_ERROR("DMShell: forkpty failed errno=%d", errno);
+        return false;
+    }
+
+    if (childPid == 0) {
+        const char *shell = getenv("SHELL");
+        if (!shell || !*shell) {
+            shell = "/bin/sh";
+        }
+        execl(shell, shell, "-i", static_cast<char *>(nullptr));
+        _exit(127);
+    }
+
+    const int flags = fcntl(masterFd, F_GETFL, 0);
+    if (flags >= 0) {
+        fcntl(masterFd, F_SETFL, flags | O_NONBLOCK);
+    }
+
+    session.active = true;
+    session.sessionId = (frame.session_id != 0) ? frame.session_id : static_cast<uint32_t>(random(1, 0x7fffffff));
+    session.peer = getFrom(&mp);
+    session.channel = mp.channel;
+    session.masterFd = masterFd;
+    session.childPid = childPid;
+    session.nextTxSeq = 1;
+    session.lastAckedRxSeq = frame.seq;
+    session.nextExpectedRxSeq = frame.seq + 1;
+    session.highestSeenRxSeq = frame.seq;
+    session.lastActivityMs = millis();
+    session.turnManaged = true;
+    session.hasToken = false;
+    session.lastRtsMs = 0;
+
+    // Honor any GRANT the client put on OPEN (opts this session into turn-taking).
+    applyTurnFlags(frame);
+
+    meshtastic_RemoteShell newFrame = {
+        .op = meshtastic_RemoteShell_OpCode_OPEN_OK,
+        .session_id = session.sessionId,
+        .seq = session.nextTxSeq++,
+        .ack_seq = frame.seq,
+        .cols = ws.ws_col,
+        .rows = ws.ws_row,
+        .flags = session.turnManaged ? TURN_FLAG_GRANT : 0u,
+    };
+    newFrame.payload.size = 0;
+    sendFrameToPeer(session.peer, newFrame, true);
+    if (session.turnManaged) {
+        // OPEN_OK handed the turn back to the client; it is now the idle-owner.
+        session.hasToken = false;
+    }
+
+    LOG_INFO("DMShell: opened session=0x%x peer=0x%x pid=%d", session.sessionId, session.peer, session.childPid);
+    return true;
+}
+
+bool DMShellModule::writeSessionInput(const meshtastic_RemoteShell &frame)
+{
+    if (session.masterFd < 0) {
+        return false;
+    }
+    if (frame.payload.size == 0) {
+        return true;
+    }
+
+    const ssize_t bytesWritten = write(session.masterFd, frame.payload.bytes, frame.payload.size);
+    return bytesWritten >= 0;
+}
+
+void DMShellModule::closeSession(const char *reason, bool notifyPeer)
+{
+    if (!session.active) {
+        return;
+    }
+
+    if (notifyPeer) {
+        const size_t reasonLen = strnlen(reason, 256);
+        meshtastic_RemoteShell frame = {
+            .op = meshtastic_RemoteShell_OpCode_CLOSED,
+            .session_id = session.sessionId,
+            .seq = session.nextTxSeq++,
+            .ack_seq = session.lastAckedRxSeq,
+            .cols = 0,
+            .rows = 0,
+            .flags = 0,
+        };
+        assert(reasonLen <= sizeof(frame.payload.bytes));
+        memcpy(frame.payload.bytes, reason, reasonLen);
+        frame.payload.size = reasonLen;
+        sendFrameToPeer(session.peer, frame, true);
+    }
+
+    if (session.masterFd >= 0) {
+        close(session.masterFd);
+        session.masterFd = -1;
+    }
+
+    if (session.childPid > 0) {
+        // Run this to avoid forgetting a child
+        processPendingChildReap();
+
+        if (kill(session.childPid, SIGTERM) < 0 && errno != ESRCH) {
+            LOG_WARN("DMShell: failed to send SIGTERM to pid=%d errno=%d", session.childPid, errno);
+        }
+
+        pendingChildPid = session.childPid;
+        session.childPid = -1;
+    }
+
+    LOG_INFO("DMShell: closed session=0x%x reason=%s", session.sessionId, reason);
+    session = DMShellSession{};
+}
+
+void DMShellModule::reapChildIfExited()
+{
+    if (!session.active || session.childPid <= 0) {
+        return;
+    }
+
+    int status = 0;
+    const pid_t result = waitpid(session.childPid, &status, WNOHANG);
+    if (result == session.childPid) {
+        closeSession("shell_exited", true);
+    }
+}
+
+void DMShellModule::processPendingChildReap()
+{
+    if (pendingChildPid <= 0) {
+        return;
+    }
+
+    int status = 0;
+    const pid_t result = waitpid(pendingChildPid, &status, WNOHANG);
+
+    if (result == pendingChildPid || (result < 0 && errno == ECHILD)) {
+        pendingChildPid = -1;
+        return;
+    }
+
+    if (result < 0) {
+        LOG_WARN("DMShell: waitpid failed for pid=%d errno=%d", pendingChildPid, errno);
+        pendingChildPid = -1;
+        return;
+    }
+
+    if (pendingChildPid > 0) {
+        if (kill(pendingChildPid, SIGKILL) < 0 && errno != ESRCH) {
+            LOG_WARN("DMShell: failed to send SIGKILL to pid=%d errno=%d", pendingChildPid, errno);
+        }
+        pendingChildPid = -1;
+    }
+}
+
+void DMShellModule::rememberSentFrame(meshtastic_RemoteShell frame)
+{
+    if (frame.seq == 0 || frame.op == meshtastic_RemoteShell_OpCode_ACK) {
+        return;
+    }
+
+    auto &entry = session.txHistory[session.txHistoryNext];
+    entry.valid = true;
+    entry.op = frame.op;
+    entry.sessionId = frame.session_id;
+    entry.seq = frame.seq;
+    entry.ackSeq = frame.ack_seq;
+    entry.cols = frame.cols;
+    entry.rows = frame.rows;
+    entry.flags = frame.flags;
+    entry.payloadLen = frame.payload.size;
+    if (frame.payload.size > 0) {
+        memcpy(entry.payload, frame.payload.bytes, frame.payload.size);
+    }
+
+    session.txHistoryNext = (session.txHistoryNext + 1) % session.txHistory.size();
+}
+
+void DMShellModule::resendFramesFrom(uint32_t startSeq)
+{
+    if (startSeq == 0) {
+        return;
+    }
+
+    DMShellSession::SentFrame *match = nullptr;
+    for (auto &entry : session.txHistory) {
+        if (!entry.valid || entry.seq != startSeq) {
+            continue;
+        }
+        match = &entry;
+        break;
+    }
+
+    if (!match) {
+        LOG_WARN("DMShell: replay request for seq=%u not found in history", startSeq);
+        return;
+    }
+
+    LOG_INFO("DMShell: replaying frame seq=%u op=%d", match->seq, match->op);
+    meshtastic_RemoteShell frame = {
+        .op = match->op,
+        .session_id = match->sessionId,
+        .seq = match->seq,
+        .ack_seq = match->ackSeq,
+        .cols = match->cols,
+        .rows = match->rows,
+        .flags = match->flags,
+    };
+    assert(match->payloadLen <= sizeof(frame.payload.bytes));
+    memcpy(frame.payload.bytes, match->payload, match->payloadLen);
+    frame.payload.size = match->payloadLen;
+    sendFrameToPeer(session.peer, frame, false);
+}
+
+void DMShellModule::sendAck(uint32_t replayFromSeq)
+{
+    if (replayFromSeq > 0) {
+        LOG_WARN("DMShell: requesting replay from seq=%u", replayFromSeq);
+    }
+    meshtastic_RemoteShell frame = {
+        .op = meshtastic_RemoteShell_OpCode_ACK,
+        .session_id = session.sessionId,
+        .seq = 0,
+        .ack_seq = session.lastAckedRxSeq,
+        .cols = 0,
+        .rows = 0,
+        .flags = 0,
+        .last_rx_seq = replayFromSeq - 1,
+    };
+    frame.payload.size = 0;
+    sendFrameToPeer(session.peer, frame, false);
+}
+
+bool DMShellModule::shouldProcessIncomingFrame(const meshtastic_RemoteShell &frame)
+{
+    if (frame.seq == 0) {
+        return true;
+    }
+
+    if (frame.seq < session.nextExpectedRxSeq) {
+        if (session.highestSeenRxSeq >= session.nextExpectedRxSeq) {
+            sendAck(session.nextExpectedRxSeq);
+        } else {
+            sendAck();
+        }
+        return false;
+    }
+
+    if (frame.seq > session.nextExpectedRxSeq) {
+        if (frame.seq > session.highestSeenRxSeq) {
+            session.highestSeenRxSeq = frame.seq;
+        }
+        sendAck(session.nextExpectedRxSeq);
+        return false;
+    }
+
+    session.lastAckedRxSeq = frame.seq;
+    session.nextExpectedRxSeq = frame.seq + 1;
+    if (frame.seq > session.highestSeenRxSeq) {
+        session.highestSeenRxSeq = frame.seq;
+    }
+    if (session.highestSeenRxSeq >= session.nextExpectedRxSeq) {
+        sendAck(session.nextExpectedRxSeq);
+    } else {
+        session.highestSeenRxSeq = 0;
+    }
+    return true;
+}
+
+void DMShellModule::sendFrameToPeer(NodeNum peer, meshtastic_RemoteShell frame, bool remember)
+{
+    meshtastic_MeshPacket *packet = allocDataPacket();
+    if (!packet) {
+        return;
+    }
+    LOG_WARN("DMShell: building packet op=%u session=0x%x seq=%u payloadLen=%zu", frame.op, frame.session_id, frame.seq,
+             frame.payload.size);
+    const size_t encoded = pb_encode_to_bytes(packet->decoded.payload.bytes, sizeof(packet->decoded.payload.bytes),
+                                              meshtastic_RemoteShell_fields, &frame);
+    if (encoded == 0) {
+        return;
+    }
+    packet->decoded.payload.size = encoded;
+
+    if (remember) {
+        rememberSentFrame(frame);
+    }
+
+    packet->to = peer;
+    packet->hop_limit = 0;
+    packet->hop_start = 0;
+    packet->channel = 0;
+    packet->want_ack = false;
+    packet->pki_encrypted = true;
+    packet->priority = meshtastic_MeshPacket_Priority_RELIABLE;
+    service->sendToMesh(packet);
+}
+
+void DMShellModule::applyTurnFlags(const meshtastic_RemoteShell &frame)
+{
+    if (frame.flags & (TURN_FLAG_GRANT | TURN_FLAG_MORE | TURN_FLAG_RTS)) {
+        session.turnManaged = true; // peer speaks turn-taking; enable gating for this session
+    }
+    if (frame.flags & TURN_FLAG_GRANT) {
+        if (!session.hasToken) {
+            // Fresh turn: start the linger window and reset the per-turn budget.
+            session.turnDeadlineMs = millis() + TURN_LINGER_MS;
+            session.turnFramesSent = 0;
+        }
+        session.hasToken = true;
+    }
+}
+
+bool DMShellModule::ptyHasOutput()
+{
+    if (session.masterFd < 0) {
+        return false;
+    }
+    struct pollfd pfd = {};
+    pfd.fd = session.masterFd;
+    pfd.events = POLLIN;
+    return poll(&pfd, 1, 0) > 0 && (pfd.revents & POLLIN);
+}
+
+void DMShellModule::sendOutputFrame(const uint8_t *data, size_t len, uint32_t extraFlags)
+{
+    meshtastic_RemoteShell frame = {
+        .op = meshtastic_RemoteShell_OpCode_OUTPUT,
+        .session_id = session.sessionId,
+        .seq = session.nextTxSeq++,
+        .ack_seq = session.lastAckedRxSeq,
+        .cols = 0,
+        .rows = 0,
+        .flags = extraFlags,
+    };
+    assert(len <= sizeof(frame.payload.bytes));
+    memcpy(frame.payload.bytes, data, len);
+    frame.payload.size = len;
+    sendFrameToPeer(session.peer, frame, true);
+}
+
+void DMShellModule::sendTurnGrant(bool more)
+{
+    meshtastic_RemoteShell frame = {
+        .op = meshtastic_RemoteShell_OpCode_ACK,
+        .session_id = session.sessionId,
+        .seq = 0,
+        .ack_seq = session.lastAckedRxSeq,
+        .cols = 0,
+        .rows = 0,
+        .flags = TURN_FLAG_GRANT | (more ? TURN_FLAG_MORE : 0u),
+        .last_rx_seq = 0,
+    };
+    frame.payload.size = 0;
+    sendFrameToPeer(session.peer, frame, false);
+}
+
+void DMShellModule::sendRts()
+{
+    meshtastic_RemoteShell frame = {
+        .op = meshtastic_RemoteShell_OpCode_ACK,
+        .session_id = session.sessionId,
+        .seq = 0,
+        .ack_seq = session.lastAckedRxSeq,
+        .cols = 0,
+        .rows = 0,
+        .flags = TURN_FLAG_RTS,
+        .last_rx_seq = 0,
+    };
+    frame.payload.size = 0;
+    sendFrameToPeer(session.peer, frame, false);
+}
+
+// Called (every tick) while we hold the turn. Drains available shell output and sends it
+// immediately, then decides whether to keep the turn (linger, to catch output that is about to
+// appear) or hand it back. The turn is yielded once the per-turn budget is hit (so the client can
+// interject, e.g. Ctrl-C) or once the PTY has been idle past the linger window. Output frames go
+// out as soon as they are read (no extra delay); the grant is a trailing ACK.
+void DMShellModule::serviceTurn()
+{
+    if (!session.active || !session.turnManaged || !session.hasToken) {
+        return;
+    }
+
+    uint8_t buf[MAX_MESSAGE_SIZE];
+    bool eof = false;
+    bool readError = false;
+
+    // Drain whatever is available right now, up to the remaining per-turn budget.
+    while (session.turnFramesSent < TURN_BUDGET_FRAMES && session.masterFd >= 0) {
+        const ssize_t n = read(session.masterFd, buf, sizeof(buf));
+        if (n > 0) {
+            sendOutputFrame(buf, (size_t)n, 0u);
+            session.turnFramesSent++;
+            session.lastActivityMs = millis();
+            session.turnDeadlineMs = millis() + TURN_LINGER_MS; // extend the linger while output flows
+        } else if (n == 0) {
+            eof = true;
+            break;
+        } else {
+            if (errno != EAGAIN && errno != EWOULDBLOCK) {
+                readError = true;
+            }
+            break;
+        }
+    }
+
+    if (eof || readError) {
+        session.hasToken = false;
+        sendTurnGrant(false);
+        if (eof) {
+            closeSession("pty_eof", true);
+        } else {
+            LOG_WARN("DMShell: PTY read error errno=%d", errno);
+            closeSession("pty_read_error", true);
+        }
+        return;
+    }
+
+    const bool morePending = ptyHasOutput();
+
+    if (session.turnFramesSent >= TURN_BUDGET_FRAMES) {
+        // Hit the per-turn budget: yield so the client gets a chance to interject (e.g. Ctrl-C).
+        session.hasToken = false;
+        sendTurnGrant(morePending);
+        return;
+    }
+
+    if (!morePending && (int32_t)(millis() - session.turnDeadlineMs) >= 0) {
+        // PTY has been idle past the linger window: hand the turn back.
+        session.hasToken = false;
+        sendTurnGrant(false);
+        return;
+    }
+
+    // Otherwise keep holding the turn: there is more to drain next pass, or we are lingering for
+    // output that may be about to appear. runOnce re-enters serviceTurn on the next tick.
+}
+
+void DMShellModule::sendError(const char *message, NodeNum peer)
+{
+    const size_t len = strnlen(message, MAX_MESSAGE_SIZE);
+    meshtastic_RemoteShell frame = {
+        .op = meshtastic_RemoteShell_OpCode_ERROR,
+        .session_id = session.sessionId,
+        .seq = session.nextTxSeq++,
+        .ack_seq = session.lastAckedRxSeq,
+        .cols = 0,
+        .rows = 0,
+        .flags = 0,
+    };
+    if (message && len > 0) {
+        assert(len <= sizeof(frame.payload.bytes));
+        memcpy(frame.payload.bytes, message, len);
+        frame.payload.size = len;
+    }
+    if (peer == 0) {
+        peer = session.peer;
+    }
+    sendFrameToPeer(peer, frame, true);
+}
+#endif

src/modules/DMShell.h

@@ -0,0 +1,91 @@
+#pragma once
+
+#include "MeshModule.h"
+#include "Router.h"
+#include "SinglePortModule.h"
+#include "concurrency/OSThread.h"
+#include "configuration.h"
+#include "mesh/generated/meshtastic/mesh.pb.h"
+#include <Arduino.h>
+#include <array>
+#include <functional>
+
+#if defined(ARCH_PORTDUINO)
+
+struct DMShellSession {
+    bool active = false;
+    uint32_t sessionId = 0;
+    NodeNum peer = 0;
+    uint8_t channel = 0;
+    int masterFd = -1;
+    int childPid = -1;
+    uint32_t nextTxSeq = 1;
+    uint32_t lastAckedRxSeq = 0;
+    uint32_t nextExpectedRxSeq = 1;
+    uint32_t highestSeenRxSeq = 0;
+    uint32_t lastActivityMs = 0;
+    // --- Half-duplex turn-taking ("talking stick") state ---
+    bool turnManaged = false;    // becomes true once the peer uses turn-taking flags; enables gating
+    bool hasToken = false;       // do we currently hold the right to transmit?
+    uint32_t lastRtsMs = 0;      // last time we asked the client for a turn (rate-limit)
+    uint32_t turnDeadlineMs = 0; // while holding the turn, keep it until this time (extended on output)
+    uint32_t turnFramesSent = 0; // output frames sent in the current held turn (vs TURN_BUDGET_FRAMES)
+    struct SentFrame {
+        bool valid = false;
+        meshtastic_RemoteShell_OpCode op = meshtastic_RemoteShell_OpCode_ERROR;
+        uint32_t sessionId = 0;
+        uint32_t seq = 0;
+        uint32_t ackSeq = 0;
+        uint32_t cols = 0;
+        uint32_t rows = 0;
+        uint32_t flags = 0;
+        uint8_t payload[meshtastic_Constants_DATA_PAYLOAD_LEN] = {0};
+        size_t payloadLen = 0;
+    };
+    std::array<SentFrame, 50> txHistory = {};
+    size_t txHistoryNext = 0;
+};
+
+class DMShellModule : private concurrency::OSThread, public SinglePortModule
+{
+
+  public:
+    DMShellModule();
+
+  protected:
+    virtual ProcessMessage handleReceived(const meshtastic_MeshPacket &mp) override;
+    virtual int32_t runOnce() override;
+
+  private:
+    static constexpr uint32_t SESSION_IDLE_TIMEOUT_MS = 5 * 60 * 1000;
+
+    DMShellSession session;
+    pid_t pendingChildPid = -1;
+
+    bool parseFrame(const meshtastic_MeshPacket &mp, meshtastic_RemoteShell &outFrame);
+    bool isAuthorizedPacket(const meshtastic_MeshPacket &mp) const;
+    bool openSession(const meshtastic_MeshPacket &mp, const meshtastic_RemoteShell &frame);
+    bool shouldProcessIncomingFrame(const meshtastic_RemoteShell &frame);
+    bool writeSessionInput(const meshtastic_RemoteShell &frame);
+    void closeSession(const char *reason, bool notifyPeer);
+    void reapChildIfExited();
+    void processPendingChildReap();
+
+    void rememberSentFrame(meshtastic_RemoteShell frame);
+    void resendFramesFrom(uint32_t startSeq);
+    void sendAck(uint32_t replayFromSeq = 0);
+    void sendFrameToPeer(NodeNum peer, meshtastic_RemoteShell frame, bool remember = true);
+    void sendError(const char *message, NodeNum peer = 0);
+
+    // --- Turn-taking helpers ---
+    void applyTurnFlags(const meshtastic_RemoteShell &frame);
+    bool ptyHasOutput();
+    void serviceTurn();
+    void sendOutputFrame(const uint8_t *data, size_t len, uint32_t extraFlags);
+    void sendTurnGrant(bool more);
+    void sendRts();
+};
+
+extern DMShellModule *dmShellModule;
+
+#endif

src/modules/HopScalingModule.cpp

@@ -1,493 +0,0 @@
-#include "HopScalingModule.h"
-#include "SafeFile.h"
-#include "meshUtils.h"
-
-#if HAS_VARIABLE_HOPS
-
-#include "FSCommon.h"
-#include "NodeDB.h"
-#include "SPILock.h"
-#include "concurrency/LockGuard.h"
-#include "mesh-pb-constants.h"
-#include <algorithm>
-#include <cmath>
-#include <cstring>
-
-namespace
-{
-// Module scheduling
-constexpr uint32_t INITIAL_DELAY_MS = 30 * 1000UL;    // Startup grace period before first run
-constexpr uint32_t RUN_INTERVAL_MS = 5 * 60 * 1000UL; // Emit micro-summary every 5 minutes
-// RUNS_PER_HOUR is a public class constant in HopScalingModule.h
-
-// Persistence
-// Note: this only needs incrementing if the published arrangement changes. For testing purposes, or prior to widespread release,
-// it can stay the same even if the internal layout changes.
-constexpr uint32_t HISTOGRAM_STATE_MAGIC = 0x48535432; // 'HST2' — layout v2
-constexpr uint8_t HISTOGRAM_STATE_VERSION = 1;
-constexpr const char *HISTOGRAM_STATE_FILE = "/prefs/hopScalingState.bin";
-
-#pragma pack(push, 1)
-struct PersistedHistogram {
-    uint32_t magic;
-    uint8_t version;
-    uint8_t samplingDenominator;
-    uint8_t filteringDenominator;
-    uint8_t filterDenomHoldRollsRemaining; // rollHour() calls remaining in the hold; 0 when expired/not active
-    uint16_t hashSeed;
-    Record entries[HopScalingModule::CAPACITY]; // full 512-byte array; count derived on load
-};
-#pragma pack(pop)
-
-} // namespace
-
-HopScalingModule *hopScalingModule;
-
-// ---------------------------------------------------------------------------
-// Lifecycle
-// ---------------------------------------------------------------------------
-
-HopScalingModule::HopScalingModule() : concurrency::OSThread("HopScaling")
-{
-    clear();
-    loadFromDisk();
-    setIntervalFromNow(INITIAL_DELAY_MS);
-}
-
-void HopScalingModule::clear()
-{
-    memset(entries, 0, sizeof(entries));
-    count = 0;
-    samplingDenominator = DENOM_MIN;
-    filteringDenominator = DENOM_MIN;
-    filteringDenomHoldRollsRemaining = 0;
-    lastPerHopCounts = {};
-    lastSuggestedHop = MAX_HOP;
-    lastPoliteNumer = POLITENESS_DEFAULT;
-    lastTrendStats = {};
-    memset(denominatorHistory, DENOM_MIN, sizeof(denominatorHistory));
-#ifndef PIO_UNIT_TESTING
-    hashSeed = static_cast<uint16_t>(random());
-#else
-    hashSeed = 0; // deterministic in unit tests
-#endif
-}
-
-// ---------------------------------------------------------------------------
-// Persistence
-// ---------------------------------------------------------------------------
-
-void HopScalingModule::saveToDisk() const
-{
-#ifdef FSCom
-    FSCom.mkdir("/prefs");
-    PersistedHistogram state{};
-    state.magic = HISTOGRAM_STATE_MAGIC;
-    state.version = HISTOGRAM_STATE_VERSION;
-    state.samplingDenominator = samplingDenominator;
-    state.filteringDenominator = filteringDenominator;
-    state.filterDenomHoldRollsRemaining = filteringDenomHoldRollsRemaining;
-    state.hashSeed = hashSeed;
-    // Save all CAPACITY slots; count is reconstructed on load by scanning seenHoursAgo.
-    memcpy(state.entries, entries, sizeof(state.entries));
-    auto file = SafeFile(HISTOGRAM_STATE_FILE, true);
-    const size_t written = file.write(reinterpret_cast<const uint8_t *>(&state), sizeof(state));
-    if (file.close() && written == sizeof(state)) {
-        LOG_DEBUG("[HOPSCALE] Saved: count=%u samp=1/%u filt=1/%u holdRollsRemaining=%u", count, samplingDenominator,
-                  filteringDenominator, state.filterDenomHoldRollsRemaining);
-    } else {
-        LOG_WARN("[HOPSCALE] Failed to write %s (%u of %u bytes)", HISTOGRAM_STATE_FILE, static_cast<unsigned>(written),
-                 static_cast<unsigned>(sizeof(state)));
-    }
-#endif
-}
-
-void HopScalingModule::loadFromDisk()
-{
-#ifdef FSCom
-    concurrency::LockGuard g(spiLock);
-    auto file = FSCom.open(HISTOGRAM_STATE_FILE, FILE_O_READ);
-    if (!file)
-        return;
-    PersistedHistogram state{};
-    const bool readOk = (file.read(reinterpret_cast<uint8_t *>(&state), sizeof(state)) == sizeof(state));
-    file.close();
-    // Validate magic, version, denom range, denom power-of-two invariant, and hold counter.
-    if (!readOk || state.magic != HISTOGRAM_STATE_MAGIC || state.version != HISTOGRAM_STATE_VERSION ||
-        state.samplingDenominator < DENOM_MIN || state.samplingDenominator > DENOM_MAX ||
-        state.filteringDenominator < state.samplingDenominator || state.filteringDenominator > DENOM_MAX ||
-        !is_pow_of_2(state.samplingDenominator) || !is_pow_of_2(state.filteringDenominator) ||
-        state.filterDenomHoldRollsRemaining > FILTER_DENOM_HOLD_ROLLS) {
-        LOG_DEBUG("[HOPSCALE] No valid persisted state (magic=%08x ver=%u samp=%u filt=%u hold=%u), starting fresh", state.magic,
-                  state.version, state.samplingDenominator, state.filteringDenominator, state.filterDenomHoldRollsRemaining);
-        return;
-    }
-    // Derive count by scanning: active entries have seenHoursAgo != 0; pack them to the front.
-
-    uint8_t restored = 0;
-    for (uint8_t i = 0; i < CAPACITY && restored < CAPACITY; i++) {
-        if (state.entries[i].seenHoursAgo != 0u) {
-            entries[restored++] = state.entries[i];
-        }
-    }
-    count = restored;
-    samplingDenominator = state.samplingDenominator;
-    filteringDenominator = state.filteringDenominator;
-    filteringDenomHoldRollsRemaining = state.filterDenomHoldRollsRemaining;
-    // denominatorHistory can't be recovered; initialise all slots to filteringDenominator so
-    // the first few post-reboot scaledPerHour values use a safe (slightly conservative) multiplier.
-    memset(denominatorHistory, filteringDenominator, sizeof(denominatorHistory));
-    hashSeed = state.hashSeed;
-    LOG_INFO("[HOPSCALE] Restored: count=%u samp=1/%u filt=1/%u holdRollsRemaining=%u", count, samplingDenominator,
-             filteringDenominator, state.filterDenomHoldRollsRemaining);
-#endif
-}
-
-// ---------------------------------------------------------------------------
-// Core API
-// ---------------------------------------------------------------------------
-
-void HopScalingModule::samplePacketForHistogram(uint32_t nodeId, uint8_t hopCount)
-{
-    const uint16_t hash = hashNodeId(nodeId);
-
-    if (!passesFilter(hash, samplingDenominator))
-        return;
-
-    hopCount = std::min(hopCount, MAX_HOP);
-
-    // Update an existing entry
-    Record *entry = nullptr;
-    for (uint8_t i = 0; i < count; i++) {
-        if (entries[i].nodeHash == hash) {
-            entry = &entries[i];
-            break;
-        }
-    }
-    if (entry) {
-        entry->hops_away = hopCount;
-        markCurrentHour(*entry);
-        return;
-    }
-
-    // New node: trim if necessary before allocating a slot
-    if (getFillPercentage() >= FILL_HIGH_PCT) {
-        trimIfNeeded();
-    }
-
-    if (count < CAPACITY) {
-        entries[count].nodeHash = hash;
-        entries[count].hops_away = hopCount;
-        entries[count].seenHoursAgo = 1u; // mark current hour
-        count++;
-    } else {
-        LOG_WARN("[HOPSCALE] Histogram full at samp=1/%u (DENOM_MAX=%u); dropping node hash=0x%04x; hop recommendation may be "
-                 "skewed!!!",
-                 samplingDenominator, DENOM_MAX, hash);
-    }
-}
-
-void HopScalingModule::rollHour()
-{
-    // Advance denominatorHistory before the tally so each slot h holds the filteringDenominator
-    // that was active when seenHoursAgo bit h was set.  hourlyRaw[h] is then gated per-slot by
-    // denominatorHistory[h], giving a correct population estimate for each historical hour even
-    // when filteringDenominator changes between rolls.  Scale-up backfills the entire array so
-    // the invariant holds retroactively (see trimIfNeeded()).
-    for (uint8_t h = 12; h > 0; h--)
-        denominatorHistory[h] = denominatorHistory[h - 1];
-    denominatorHistory[0] = filteringDenominator;
-
-    // 1. Tally per-hop counts and per-slot hourly activity in one pass.
-    //    hourlyRaw[h]: gated per-slot by denominatorHistory[h] so the raw count and its
-    //      multiplier are always consistent, even across filteringDenominator transitions.
-    //    counts.*: gated uniformly by the current filteringDenominator for a consistent
-    //      population estimate used by the hop-walk recommendation (step 2).
-    PerHopCounts counts{};
-    uint16_t hourlyRaw[13] = {};
-    uint16_t trendNewThisHour = 0;
-    uint16_t trendReturning = 0;
-    uint16_t trendLapsed = 0;
-    uint16_t trendOlderThan4h = 0;
-    uint16_t trendAgingOut = 0;
-    for (uint8_t i = 0; i < count; i++) {
-        const uint16_t hash = entries[i].nodeHash;
-        const uint32_t seen = entries[i].seenHoursAgo;
-
-        // Per-slot hourly activity: gate each slot by its own denominator.
-        for (uint8_t h = 0; h < 13; h++) {
-            if ((seen & (1u << h)) && passesFilter(hash, denominatorHistory[h]))
-                hourlyRaw[h]++;
-        }
-
-        // Hop counts and trend stats: uniform current-denominator gate.
-        if (!passesFilter(hash, filteringDenominator))
-            continue;
-
-        if (seenInLast13h(entries[i])) {
-            counts.perHop[entries[i].hops_away]++;
-            counts.total++;
-        }
-        const bool heardThisHour = (seen & 1u) != 0u;
-        const bool heardLastHour = (seen & 2u) != 0u;
-        const bool hasOlderHistory = (seen >> 1u) != 0u;
-        const bool recentlySilent = (seen & 0xFu) == 0u;
-        if (heardThisHour && !hasOlderHistory)
-            trendNewThisHour++;
-        else if (heardThisHour && hasOlderHistory)
-            trendReturning++;
-        if (!heardThisHour && heardLastHour)
-            trendLapsed++;
-        if (recentlySilent && (seen & 0x1FF0u) != 0u)
-            trendOlderThan4h++;
-        if (seen == (1u << 12u))
-            trendAgingOut++;
-    }
-    lastPerHopCounts = counts;
-
-    // 1b. Compute politeness factor from the 0-2 h vs 1-3 h activity ratio.
-    {
-        const uint32_t recent = static_cast<uint32_t>(hourlyRaw[0]) + hourlyRaw[1];
-        const uint32_t older = static_cast<uint32_t>(hourlyRaw[1]) + hourlyRaw[2];
-        if (older > 1 && recent > 1) {
-            const uint32_t r = static_cast<uint32_t>(recent) * ACTIVITY_WEIGHT_SCALE;
-            const uint32_t o = static_cast<uint32_t>(older);
-            if (r < o * ACTIVITY_WEIGHT_GENEROUS_MAX_NUMER)
-                lastPoliteNumer = POLITENESS_GENEROUS;
-            else if (r > o * ACTIVITY_WEIGHT_STRICT_MIN_NUMER)
-                lastPoliteNumer = POLITENESS_STRICT;
-            else
-                lastPoliteNumer = POLITENESS_DEFAULT;
-        } else {
-            lastPoliteNumer = POLITENESS_DEFAULT;
-        }
-    }
-
-    // 1c. Scale and cache trend stats (denominatorHistory already advanced above).
-    {
-        MeshTrendStats t{};
-        for (uint8_t h = 0; h < 13; h++) {
-            const uint32_t s = static_cast<uint32_t>(hourlyRaw[h]) * denominatorHistory[h];
-            t.scaledPerHour[h] = static_cast<uint16_t>(std::min<uint32_t>(s, UINT16_MAX));
-        }
-        auto scale = [&](uint16_t raw) -> uint16_t {
-            return static_cast<uint16_t>(std::min<uint32_t>(static_cast<uint32_t>(raw) * filteringDenominator, UINT16_MAX));
-        };
-        t.newThisHour = scale(trendNewThisHour);
-        t.returningThisHour = scale(trendReturning);
-        t.lapsedSinceLastHour = scale(trendLapsed);
-        t.olderThan4h = scale(trendOlderThan4h);
-        t.agingOut = scale(trendAgingOut);
-        lastTrendStats = t;
-    }
-
-    // 2. Walk scaled hop buckets to produce a hop-limit recommendation.
-    //     effectiveMin: walk threshold — first hop whose cumulative count reaches this.
-    //     effectiveMax: ceiling on the one-hop extension check with GENEROUS politeness.
-    const uint16_t effectiveMin = TARGET_AFFECTED_NODES;
-    const uint16_t effectiveMax = MAX_TARGET_NODES;
-    uint8_t suggested = MAX_HOP;
-    if (counts.total > 0) {
-        uint32_t cumulative = 0;
-        for (uint8_t hop = 0; hop <= MAX_HOP; hop++) {
-            cumulative += static_cast<uint32_t>(counts.perHop[hop]) * filteringDenominator;
-            if (cumulative >= effectiveMin) {
-                suggested = hop;
-                break;
-            }
-        }
-        if (suggested < MAX_HOP) {
-            const uint32_t atNext = static_cast<uint32_t>(counts.perHop[suggested + 1]) * filteringDenominator;
-            // politeLimit = effectiveMin + gap * politeNumer / POLITENESS_DENOM
-            // Multiply both sides by POLITENESS_DENOM to stay in integers.
-            const uint32_t gap = static_cast<uint32_t>(effectiveMax) - static_cast<uint32_t>(effectiveMin);
-            if ((cumulative + atNext) * POLITENESS_DENOM <=
-                static_cast<uint32_t>(effectiveMin) * POLITENESS_DENOM + gap * lastPoliteNumer) {
-                suggested++;
-            }
-        }
-    }
-    lastSuggestedHop = suggested;
-
-    // 3. Log scaled per-hop counts and recommendation.
-    {
-        uint16_t scaled[MAX_HOP + 1];
-        for (uint8_t h = 0; h <= MAX_HOP; h++) {
-            const uint32_t s = static_cast<uint32_t>(counts.perHop[h]) * filteringDenominator;
-            scaled[h] = static_cast<uint16_t>(std::min<uint32_t>(s, UINT16_MAX));
-        }
-        const uint32_t scaledTotal = static_cast<uint32_t>(counts.total) * filteringDenominator;
-        memcpy(lastScaledPerHop, scaled, sizeof(lastScaledPerHop));
-        LOG_INFO("[HOPSCALE] rollHour: entries=%u/128 samp=1/%u filt=1/%u counted=%u est=%u suggestedHop=%u polite=%u/4", count,
-                 samplingDenominator, filteringDenominator, counts.total, static_cast<unsigned>(scaledTotal), suggested,
-                 lastPoliteNumer);
-
-        const auto &ts = lastTrendStats;
-        LOG_INFO("[HOPSCALE] scaledSeenPerHour (h0=now): [%u %u %u %u %u %u %u %u %u %u %u %u %u]", ts.scaledPerHour[0],
-                 ts.scaledPerHour[1], ts.scaledPerHour[2], ts.scaledPerHour[3], ts.scaledPerHour[4], ts.scaledPerHour[5],
-                 ts.scaledPerHour[6], ts.scaledPerHour[7], ts.scaledPerHour[8], ts.scaledPerHour[9], ts.scaledPerHour[10],
-                 ts.scaledPerHour[11], ts.scaledPerHour[12]);
-        LOG_INFO("[HOPSCALE] trend: new=%u returning=%u lapsed=%u olderThan4h=%u agingOut=%u", ts.newThisHour,
-                 ts.returningThisHour, ts.lapsedSinceLastHour, ts.olderThan4h, ts.agingOut);
-    }
-
-    // 4. Scale-down check: if fewer than FILL_LOW_PCT% of capacity pass the filteringDenominator
-    //    gate and are active, halve samplingDenominator to admit more nodes.
-    //    Note: during a filteringDenominator hold period, lowering samplingDenominator does not
-    //    immediately improve counts.total (new admissions don't pass the elevated
-    //    filteringDenominator).  On a genuinely quieting mesh this check can therefore fire on
-    //    consecutive hours, cascading samplingDenominator toward DENOM_MIN.  This is intentional:
-    //    rapid re-admission allows quick recovery if the mesh returns.  The hop recommendation
-    //    stays conservative (MAX_HOP) throughout because filteringDenominator remains elevated;
-    //    step 5 below re-synchronises the denominators once the hold expires.
-    if (counts.total * 100u < static_cast<uint32_t>(CAPACITY) * FILL_LOW_PCT) {
-        if (samplingDenominator > DENOM_MIN) {
-            samplingDenominator = static_cast<uint8_t>(samplingDenominator / 2u);
-            LOG_INFO("[HOPSCALE] Scale-down: sampling denom halved to %u (filter denom=%u)", samplingDenominator,
-                     filteringDenominator);
-        }
-    }
-
-    // 5. Tick down the hold counter; once it reaches zero, halve filteringDenominator toward
-    //    samplingDenominator once per rollHour() (= once per hour) rather than a single jump:
-    //    avoids a sudden large change in the hop-walk count when samplingDenominator cascaded
-    //    down significantly during the hold period.  No new hold is placed on each step — the
-    //    13-roll hold already guaranteed that re-admitted nodes have full seenHoursAgo history;
-    //    further pacing is provided naturally by the 1-step-per-hour rate.  denominatorHistory
-    //    is updated automatically by the shift at the top of rollHour(), so no backfill here.
-    if (filteringDenominator > samplingDenominator) {
-        if (filteringDenomHoldRollsRemaining > 0)
-            filteringDenomHoldRollsRemaining--;
-        if (filteringDenomHoldRollsRemaining == 0) {
-            const uint8_t stepped = static_cast<uint8_t>(filteringDenominator / 2u);
-            filteringDenominator = (stepped > samplingDenominator) ? stepped : samplingDenominator;
-            LOG_INFO("[HOPSCALE] Filter denom stepped to %u (samp=1/%u)", filteringDenominator, samplingDenominator);
-        }
-    }
-
-    // 6. Shift all seen bitmaps left by one slot (opens a fresh slot for the new hour).
-    for (uint8_t i = 0; i < count; i++) {
-        rollSeenBits(entries[i]);
-    }
-
-    if (histogramRollCount < 255)
-        histogramRollCount++;
-
-    saveToDisk();
-}
-
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-
-void HopScalingModule::trimIfNeeded()
-{
-    // Step 1: evict stale entries (not seen in any of the past 13 hours).
-    uint8_t newCount = 0;
-    for (uint8_t i = 0; i < count; i++) {
-        if (seenInLast13h(entries[i])) {
-            if (i != newCount) {
-                entries[newCount] = entries[i];
-            }
-            newCount++;
-        }
-    }
-    count = newCount;
-
-    // Step 2: if still too full, double the sampling denominator and remove non-matching entries.
-    if (getFillPercentage() >= FILL_HIGH_PCT && samplingDenominator < DENOM_MAX) {
-        samplingDenominator = static_cast<uint8_t>(
-            std::min<uint16_t>(static_cast<uint16_t>(samplingDenominator) * 2u, static_cast<uint16_t>(DENOM_MAX)));
-        filteringDenominator = std::max(filteringDenominator, samplingDenominator);
-        filteringDenomHoldRollsRemaining = FILTER_DENOM_HOLD_ROLLS;
-        // Raise any denominatorHistory slot that is below the new filteringDenominator.
-        // Slots already above it (recorded during a prior scale-up that hasn't fully stepped
-        // down yet) are left untouched: eviction at samplingDenominator retains exactly those
-        // entries, so the old higher gate remains accurate for those historical hours.
-        // Slots below the new value must be raised because the eviction removed entries that
-        // had been admitted at the looser old gate — the remaining entries represent a 1/N
-        // subsample where N is the new filteringDenominator, not the old smaller value.
-        for (uint8_t h = 0; h < 13; h++)
-            denominatorHistory[h] = std::max(denominatorHistory[h], filteringDenominator);
-        LOG_INFO("[HOPSCALE] Scale-up: samp denom doubled to %u (filt=%u)", samplingDenominator, filteringDenominator);
-
-        newCount = 0;
-        for (uint8_t i = 0; i < count; i++) {
-            if (passesFilter(entries[i].nodeHash, samplingDenominator)) {
-                if (i != newCount) {
-                    entries[newCount] = entries[i];
-                }
-                newCount++;
-            }
-        }
-        count = newCount;
-    }
-}
-
-void HopScalingModule::logStatusReport(bool didHourlyUpdate) const
-{
-    const bool histActive = (histogramRollCount > 0 && count > 0);
-    const auto &histCounts = lastPerHopCounts;
-    const uint8_t runsRemaining = didHourlyUpdate ? RUNS_PER_HOUR : (RUNS_PER_HOUR - runsSinceLastHourlyUpdate);
-    const uint8_t minsUntilRollover = runsRemaining * (RUN_INTERVAL_MS / (60 * 1000UL));
-
-    LOG_INFO("[HOPSCALE] hop=%u histActive=%u fill=%u%% samp=1/%u filt=1/%u entries=%u lastCounted=%u polite=%u/4 "
-             "nextRoll=%umin",
-             lastRequiredHop, histActive ? 1u : 0u, getFillPercentage(), samplingDenominator, filteringDenominator, count,
-             histCounts.total, lastPoliteNumer, minsUntilRollover);
-
-    LOG_INFO("[HOPSCALE] nodes perHop: [%u %u %u %u %u %u %u %u]", histCounts.perHop[0], histCounts.perHop[1],
-             histCounts.perHop[2], histCounts.perHop[3], histCounts.perHop[4], histCounts.perHop[5], histCounts.perHop[6],
-             histCounts.perHop[7]);
-    LOG_INFO("[HOPSCALE] last scaled perHop: [%u %u %u %u %u %u %u %u]", lastScaledPerHop[0], lastScaledPerHop[1],
-             lastScaledPerHop[2], lastScaledPerHop[3], lastScaledPerHop[4], lastScaledPerHop[5], lastScaledPerHop[6],
-             lastScaledPerHop[7]);
-}
-
-int32_t HopScalingModule::runOnce()
-{
-    const bool isFirstRun = !hasCompletedInitialRun;
-    bool didHourlyUpdate = false;
-
-    if (isFirstRun) {
-        hasCompletedInitialRun = true;
-        runsSinceLastHourlyUpdate = 0;
-        didHourlyUpdate = true;
-    } else {
-        runsSinceLastHourlyUpdate++;
-        if (runsSinceLastHourlyUpdate >= RUNS_PER_HOUR) {
-            runsSinceLastHourlyUpdate = 0;
-            didHourlyUpdate = true;
-        }
-    }
-
-    if (didHourlyUpdate && !isFirstRun) {
-        rollHour();
-    }
-
-    if (didHourlyUpdate) {
-        uint8_t suggested = (histogramRollCount > 0 && count > 0) ? lastSuggestedHop : HOP_MAX;
-        // Role-based hop floor: TRACKER/TAK_TRACKER always reach at least 2 hops,
-        // SENSOR reaches at least 1, so these reporting roles remain reachable even
-        // on a dense mesh where the histogram recommends a lower hop count.
-        uint8_t roleFloor = 0;
-        switch (config.device.role) {
-        case meshtastic_Config_DeviceConfig_Role_TRACKER:
-        case meshtastic_Config_DeviceConfig_Role_TAK_TRACKER:
-            roleFloor = 2;
-            break;
-        case meshtastic_Config_DeviceConfig_Role_SENSOR:
-            roleFloor = 1;
-            break;
-        default:
-            break;
-        }
-        lastRequiredHop = std::max(suggested, roleFloor);
-    }
-
-    logStatusReport(didHourlyUpdate);
-
-    return RUN_INTERVAL_MS;
-}
-
-#endif

src/modules/HopScalingModule.h

@@ -1,351 +0,0 @@
-#pragma once
-
-#include "MeshTypes.h"
-#include "concurrency/OSThread.h"
-#include "configuration.h"
-#include "mesh/Default.h"
-#include "mesh/mesh-pb-constants.h"
-#include <algorithm>
-#include <cstdint>
-#include <cstring>
-
-#if HAS_VARIABLE_HOPS
-
-/**
- * HopScalingModule: Sampled hop-distance histogram for mesh-aware hop limit recommendations.
- *
- * Memory layout: 512 bytes total (128 entries × 4 bytes/entry, no padding)
- *   - 16-bit XOR-fold hash of node ID
- *   - 3-bit hops away (0–7)
- *   - 13-bit hourly seen bitmap
- *   All three fields are packed into a single 32-bit Record; sizeof(Record) == 4.
- *
- * Sampling:
- *   - A node is added only when passesFilter(hashNodeId(nodeId), samplingDenominator),
- *     i.e. (hash16(nodeId) & (samplingDenominator – 1)) == 0  (hash-space subsample, not raw ID)
- *   - samplingDenominator starts at 1 (sample all), doubles when the list exceeds FILL_HIGH_PCT
- *   - filteringDenominator tracks samplingDenominator upward immediately but does not drop back
- *     down until FILTER_DENOM_HOLD_MS (13 h) have elapsed since the last scale-up
- *
- * Hourly rollover (rollHour()):
- *   - Summarises per-hop node counts for entries matching filteringDenominator and seen in the
- *     last 13 hours
- *   - Scales each hop bucket by filteringDenominator and walks the buckets to recommend a hop
- *     limit, matching the same algorithm used in HopScalingModule
- *   - Shifts the 13-bit seen bitmap left by one slot to open a fresh slot for the new hour;
- *     nodes not seen in 13 consecutive hours have all seen bits cleared (stale)
- *   - Checks for scale-down: if fewer than FILL_LOW_PCT of capacity pass filteringDenominator,
- *     samplingDenominator is halved (filteringDenominator is held until the 13-h lock expires)
- *
- * Thread-safety: all access is single-threaded via the main loop cooperative scheduler.
- */
-
-struct Record {
-    uint32_t nodeHash : 16;
-    uint32_t hops_away : 3;
-    uint32_t seenHoursAgo : 13;
-};
-static_assert(sizeof(Record) == 4);
-
-class HopScalingModule : private concurrency::OSThread
-{
-  public:
-    // -----------------------------------------------------------------------
-    // Capacity and memory layout
-    // -----------------------------------------------------------------------
-    static constexpr size_t CAPACITY = 128;
-    static constexpr size_t ENTRY_BYTES = sizeof(Record);
-    static constexpr size_t TOTAL_BYTES = CAPACITY * ENTRY_BYTES;
-
-    // Denominator limits (must be powers of 2)
-    static constexpr uint8_t DENOM_MIN = 1;
-    static constexpr uint8_t DENOM_MAX = 128;
-
-    static constexpr uint8_t MAX_HOP = 7;
-
-    // Fill-level thresholds (percent of CAPACITY)
-    static constexpr uint8_t FILL_HIGH_PCT = 80;
-    static constexpr uint8_t FILL_LOW_PCT = 20;
-
-    // How long filteringDenominator is held at an elevated level before it may drop.
-    //
-    // This value is deliberately equal to the seenHoursAgo window (13 hours / 13 bits).
-    // Invariant: every entry that existed when a scale-up fired had seenHoursAgo != 0 at
-    // that moment (trimIfNeeded() evicts stale entries before doubling the denominator),
-    // so it remains seenInLast13h for at most 13 more rollHour() calls — exactly the
-    // hold duration.  That means entries from the scale-up event keep counts.total above
-    // the scale-down threshold for the entire hold period under normal (active) mesh
-    // conditions.  On a genuinely quieting mesh the scale-down CAN fire before the hold
-    // expires — each firing halves samplingDenominator but filteringDenominator stays
-    // elevated, so the hop recommendation correctly stays conservative (MAX_HOP) while
-    // the cascade runs.  The cascade is bounded at DENOM_MIN (7 halvings from DENOM_MAX);
-    //    when the hold finally expires, step 5 of rollHour() halves filteringDenominator
-    //    once per hour (rather than jumping directly to samplingDenominator) until the two
-    //    converge, giving the hop-walk a gradual, 1-step-per-hour descent.
-    static constexpr uint32_t FILTER_DENOM_HOLD_MS = 13UL * 60UL * 60UL * 1000UL; // 13 h (documentation only)
-    // Number of rollHour() calls the hold spans — equals the seenHoursAgo window width.
-    // filteringDenomHoldRollsRemaining is initialised to this value on scale-up and
-    // decremented once per rollHour(); step-down begins when it reaches zero.
-    static constexpr uint8_t FILTER_DENOM_HOLD_ROLLS = 13u;
-
-    // Hop-walk: target cumulative affected-node count when choosing a hop limit
-    static constexpr uint16_t TARGET_AFFECTED_NODES = default_hop_scaling_min_target_nodes;
-
-    // Clamp bounds enforced on min_target_nodes / max_target_nodes
-    static constexpr uint16_t MIN_TARGET_NODES_FLOOR = default_hop_scaling_min_target_nodes_floor;
-    static constexpr uint16_t MAX_TARGET_NODES_CEILING = default_hop_scaling_max_target_nodes_ceiling;
-    static constexpr uint16_t MAX_TARGET_NODES = default_hop_scaling_max_target_nodes;
-
-    // Politeness factors for the one-hop extension check in the hop walk.
-    // Stored as integer numerators over POLITENESS_DENOM (4):
-    //   politeLimit = min + gap * politeNumer / POLITENESS_DENOM
-    // STRICT  → min + 25% of gap;  DEFAULT → midpoint;  GENEROUS → max
-    static constexpr uint8_t POLITENESS_DENOM = 4u;
-    static constexpr uint8_t POLITENESS_GENEROUS = 4u; // 4/4 = 1.00
-    static constexpr uint8_t POLITENESS_DEFAULT = 2u;  // 2/4 = 0.50
-    static constexpr uint8_t POLITENESS_STRICT = 1u;   // 1/4 = 0.25
-
-    // Activity weight thresholds (ratio of 0-2 h window vs 1-3 h window).
-    // Cross-multiply form: recent * ACTIVITY_WEIGHT_SCALE vs older * threshold_numer.
-    // GENEROUS if recent*10 < older*9 (ratio < 0.9); STRICT if recent*10 > older*12 (ratio > 1.2)
-    static constexpr uint8_t ACTIVITY_WEIGHT_SCALE = 10u;
-    static constexpr uint8_t ACTIVITY_WEIGHT_GENEROUS_MAX_NUMER = 9u;
-    static constexpr uint8_t ACTIVITY_WEIGHT_STRICT_MIN_NUMER = 12u;
-
-    // Scheduling: number of 5-minute runOnce() ticks that make up one hourly rollover
-    static constexpr uint8_t RUNS_PER_HOUR = 12;
-
-    // -----------------------------------------------------------------------
-    // Types
-    // -----------------------------------------------------------------------
-
-    /// Per-hop node counts produced at each hourly rollover.
-    struct PerHopCounts {
-        uint16_t perHop[MAX_HOP + 1] = {};
-        uint16_t total = 0;
-    };
-
-    /// Mesh activity trend stats produced at each hourly rollover.
-    /// All counts are scaled by filteringDenominator (i.e. estimated full-mesh population).
-    ///
-    /// Bitmap interpretation (before the hourly shift): bit 0 = just-completed hour, bit 12 = 12 h ago.
-    struct MeshTrendStats {
-        /// Estimated node count per hour slot (h=0 is the just-completed hour, h=12 is 12 h ago).
-        uint16_t scaledPerHour[13] = {};
-        /// Nodes heard only this hour with no prior bitmap history — indicates new arrivals.
-        uint16_t newThisHour = 0;
-        /// Nodes heard this hour that also appeared in at least one older hour — stable regulars.
-        uint16_t returningThisHour = 0;
-        /// Nodes heard last hour but silent this hour — potential departures.
-        uint16_t lapsedSinceLastHour = 0;
-        /// Nodes absent from the last 4 hours but still present in some older hour (5–13 h) — quieting down.
-        uint16_t olderThan4h = 0;
-        /// Nodes whose only remaining history is the 13th hour (bit 12 only) — about to age out entirely.
-        uint16_t agingOut = 0;
-    };
-
-    // -----------------------------------------------------------------------
-    // Lifecycle
-    // -----------------------------------------------------------------------
-
-    HopScalingModule();
-    ~HopScalingModule() = default;
-
-    /// Reset all entries and state.
-    void clear();
-
-    // -----------------------------------------------------------------------
-    // Core API
-    // -----------------------------------------------------------------------
-
-    /// Record a received packet.
-    /// Adds or updates an entry when passesFilter(hashNodeId(nodeId), samplingDenominator),
-    /// i.e. when the 16-bit XOR-fold hash of the node ID falls in the 1/samplingDenominator
-    /// subsample of the hash space.  This is NOT a raw nodeId modulo check.
-    /// Marks the current hour as seen and updates the stored hop count to the last observed value.
-    /// Triggers a trim pass if the list exceeds FILL_HIGH_PCT after the insertion.
-    void samplePacketForHistogram(uint32_t nodeId, uint8_t hopCount);
-
-    // -----------------------------------------------------------------------
-    // Accessors
-    // -----------------------------------------------------------------------
-
-    uint8_t getLastRequiredHop() const { return lastRequiredHop; }
-    uint8_t getEntryCount() const { return count; }
-    uint8_t getFillPercentage() const { return static_cast<uint8_t>((static_cast<uint16_t>(count) * 100u) / CAPACITY); }
-    uint8_t getSamplingDenominator() const { return samplingDenominator; }
-    uint8_t getFilteringDenominator() const { return filteringDenominator; }
-    float getPoliteness() const { return lastPoliteNumer / static_cast<float>(POLITENESS_DENOM); }
-    const PerHopCounts &getLastPerHopCounts() const { return lastPerHopCounts; }
-    uint8_t getLastSuggestedHop() const { return lastSuggestedHop; }
-    const MeshTrendStats &getLastTrendStats() const { return lastTrendStats; }
-
-    // Compatibility accessors used by tests
-    uint8_t getCompactHistogramEntryCount() const { return getEntryCount(); }
-    uint8_t getCompactHistogramDenominator() const { return getSamplingDenominator(); }
-    uint8_t getCompactHistogramFilterDenominator() const { return getFilteringDenominator(); }
-    uint8_t getCompactHistogramSuggestedHop() const { return getLastSuggestedHop(); }
-    size_t getCompactHistogramAllSampleCount() const { return getEntryCount(); }
-
-    /// Force both sampling and filtering denominators to a specific value.
-    /// Intended for unit tests that need a deterministic starting denominator.
-    void setSamplingDenominator(uint8_t d)
-    {
-        samplingDenominator = (d < DENOM_MIN) ? DENOM_MIN : (d > DENOM_MAX ? DENOM_MAX : d);
-        filteringDenominator = samplingDenominator;
-        filteringDenomHoldRollsRemaining = 0;
-    }
-
-#ifdef PIO_UNIT_TESTING
-    // Writable from tests as HopScalingModule::s_testNowMs; drives nowMs() in PIO_UNIT_TESTING builds.
-    inline static uint32_t s_testNowMs = 0;
-    /// Override the per-session hash seed. Use in tests that need a specific sampling distribution.
-    void setHashSeed(uint16_t seed) { hashSeed = seed; }
-    uint16_t getHashSeed() const { return hashSeed; }
-    /// Expose hashNodeId for tests that need to compute which node IDs pass a given denominator.
-    uint16_t hashNodeIdPublic(uint32_t nodeId) const { return hashNodeId(nodeId); }
-#endif
-
-  protected:
-    int32_t runOnce() override;
-
-  private:
-#ifdef PIO_UNIT_TESTING
-    friend class HopScalingTestShim;
-#endif
-
-    /// Perform hourly rollover.
-    /// 1. Tallies per-hop counts for entries matching filteringDenominator and seen in 13 h.
-    /// 2. Walks the scaled hop buckets and returns the recommended hop limit.
-    /// 3. Logs scaled per-hop counts and recommendation.
-    /// 4. Checks for scale-down (< FILL_LOW_PCT of capacity pass filteringDenominator).
-    /// 5. Decrements filteringDenomHoldRollsRemaining (if > 0); once it reaches zero, halves
-    ///    filteringDenominator once toward samplingDenominator per rollHour() call.
-    /// 6. Shifts all seen bitmaps left by one hour slot.
-    void rollHour();
-    // -----------------------------------------------------------------------
-    // Persistence
-    // -----------------------------------------------------------------------
-
-    /// Persist the histogram state (entries, denominators, hold-timer) to flash.
-    /// No-op on platforms without a filesystem.  Performs a full delete-and-rewrite of
-    /// the state file on each call; avoid calling more frequently than once per rollHour().
-    void saveToDisk() const;
-
-    /// Restore histogram state from flash.  Safe to call even when no file exists.
-    /// Call once after construction, before the first rollHour(), to warm-start the
-    /// histogram across reboots without waiting 13 hours for data to re-accumulate.
-    /// The restored entries are available immediately for sampling, but the first
-    /// rollHour() (triggered by the second runOnce() tick) is needed before a warm-start
-    /// recommendation replaces the HOP_MAX boot default.
-    void loadFromDisk();
-
-    /// Remove stale entries (seen-bits all zero) and, if the list is still crowded,
-    /// double samplingDenominator and filteringDenominator and remove non-matching entries.
-    void trimIfNeeded();
-
-    void logStatusReport(bool didHourlyUpdate) const;
-
-    // -----------------------------------------------------------------------
-    // Histogram storage
-    // -----------------------------------------------------------------------
-    Record entries[CAPACITY] = {};
-    uint8_t count = 0;
-
-    // -----------------------------------------------------------------------
-    // Denominator state
-    //
-    // Two separate denominators control two distinct gates:
-    //
-    //   samplingDenominator  — admission gate.  A node is added/updated only when
-    //     passesFilter(hash, samplingDenominator).  Lower value = more permissive =
-    //     more nodes enter = represents recent mesh state.
-    //
-    //   filteringDenominator — counting gate.  The hop-walk tally in rollHour() only
-    //     counts entries that pass passesFilter(hash, filteringDenominator).  It moves
-    //     up with samplingDenominator immediately (scale-up) but is held at the
-    //     elevated value for FILTER_DENOM_HOLD_MS (13 h) after any scale-up before it
-    //     may drop back down (scale-down).
-    //
-    // Why the estimate is invariant: passesFilter uses a hash-based uniform subsample.
-    // For any two powers-of-two denominators D ≤ F, the fraction of D-sampled entries
-    // that also pass F is exactly D/F.  Therefore:
-    //   raw_count × F  =  (total × D/F) × F  =  total × D
-    // The population estimate is the same whether we count with D or with F.
-    // The hold period is not about accuracy — it is about stability: it prevents the
-    // hop recommendation from reacting to recently-admitted nodes that have not yet
-    // accumulated enough seenHoursAgo history to be statistically reliable.
-    //
-    //   denominatorHistory[h]  — the filteringDenominator used to both gate and scale
-    //     hourlyRaw[h].  Invariant: denominatorHistory[h] always equals the
-    //     filteringDenominator that was active when seenHoursAgo bit h was set.
-    //     rollHour() advances the array at the very start (before the tally loop), then
-    //     gates hourlyRaw[h] per-slot by denominatorHistory[h] — each slot's raw count
-    //     and multiplier are therefore always consistent, even when filteringDenominator
-    //     changes between rolls (e.g. hold expiry).  On scale-up (trimIfNeeded()), the
-    //     entire array is backfilled uniformly with the new filteringDenominator to
-    //     preserve the invariant retroactively for all 13 slots.  Initialised to
-    //     DENOM_MIN (1); scaledPerHour slots that draw from a 1 entry are unscaled —
-    //     correct for a fresh instance with no prior history.
-    // -----------------------------------------------------------------------
-    uint8_t samplingDenominator = DENOM_MIN;
-    uint8_t filteringDenominator = DENOM_MIN;
-    uint8_t filteringDenomHoldRollsRemaining = 0; // counts down from FILTER_DENOM_HOLD_ROLLS to 0; step-down fires at 0
-    uint8_t denominatorHistory[13] = {};
-    uint16_t hashSeed = 0;
-
-    // -----------------------------------------------------------------------
-    // Cached hourly results
-    // -----------------------------------------------------------------------
-    PerHopCounts lastPerHopCounts = {};
-    uint16_t lastScaledPerHop[MAX_HOP + 1] = {};
-    uint8_t lastSuggestedHop = MAX_HOP;
-    uint8_t lastPoliteNumer = POLITENESS_DEFAULT;
-    MeshTrendStats lastTrendStats = {};
-
-    // -----------------------------------------------------------------------
-    // Hop recommendation state
-    // -----------------------------------------------------------------------
-    uint8_t lastRequiredHop = HOP_MAX;
-    uint8_t histogramRollCount = 0;
-
-    // -----------------------------------------------------------------------
-    // Scheduler state
-    // -----------------------------------------------------------------------
-    bool hasCompletedInitialRun = false;
-    uint8_t runsSinceLastHourlyUpdate = 0;
-
-    // -----------------------------------------------------------------------
-    // Inline record helpers
-    // -----------------------------------------------------------------------
-
-    // Record field semantics:
-    //   nodeHash     → XOR-fold of full 32-bit node ID to 16 bits
-    //   hops_away    → hop distance (0–7)
-    //   seenHoursAgo → 13-bit per-hour seen bitmap
-    //                  bit 0  = seen in the current / most-recent hour
-    //                  bit 12 = seen 12 hours ago
-    //                  Shifts left on each rollHour(); 0 means not seen in 13 h.
-
-    /// XOR-fold + golden-ratio hash of a 32-bit node ID to 16 bits, mixed with the session seed.
-    /// Multiplying by floor(2^32 / φ) gives uniform avalanche; XORing the seed ensures different
-    /// devices (or the same device after a clear()) sample a different subset of node IDs.
-    /// For seed=0 the function is deterministic, which is used in PIO_UNIT_TESTING builds.
-    uint16_t hashNodeId(uint32_t nodeId) const { return static_cast<uint16_t>((nodeId * 2654435761u) >> 16) ^ hashSeed; }
-    static bool seenInLast13h(const Record &r) { return r.seenHoursAgo != 0u; }
-    static void markCurrentHour(Record &r) { r.seenHoursAgo |= 1u; }
-    static void rollSeenBits(Record &r) { r.seenHoursAgo = (r.seenHoursAgo << 1u) & 0x1FFFu; }
-    static bool passesFilter(uint16_t nodeHash, uint8_t denom) { return (nodeHash & static_cast<uint16_t>(denom - 1u)) == 0u; }
-
-  public:
-    // Clock — public so tests can share the same timebase via HopScalingModule::s_testNowMs
-#ifdef PIO_UNIT_TESTING
-    static uint32_t nowMs() { return s_testNowMs; }
-#else
-    static uint32_t nowMs() { return millis(); }
-#endif
-};
-
-extern HopScalingModule *hopScalingModule;
-
-#endif

src/modules/Modules.cpp

@@ -41,9 +41,6 @@
 #if HAS_TRAFFIC_MANAGEMENT && !MESHTASTIC_EXCLUDE_TRAFFIC_MANAGEMENT
 #include "modules/TrafficManagementModule.h"
 #endif
-#if HAS_VARIABLE_HOPS
-#include "modules/HopScalingModule.h"
-#endif
 #include "modules/TextMessageModule.h"
 #if !MESHTASTIC_EXCLUDE_TRACEROUTE
 #include "modules/TraceRouteModule.h"
@@ -52,6 +49,7 @@
 #include "modules/WaypointModule.h"
 #endif
 #if ARCH_PORTDUINO
+#include "modules/DMShell.h"
 #include "modules/Telemetry/HostMetrics.h"
 #if !MESHTASTIC_EXCLUDE_STOREFORWARD
 #include "modules/StoreForwardModule.h"
@@ -134,10 +132,6 @@ void setupModules()
     }
 #endif
 
-#if HAS_VARIABLE_HOPS
-    hopScalingModule = new HopScalingModule();
-#endif
-
 #if !MESHTASTIC_EXCLUDE_ADMIN
     adminModule = new AdminModule();
 #endif
@@ -202,6 +196,7 @@ void setupModules()
 #endif
 #if ARCH_PORTDUINO
     new HostMetricsModule();
+    dmShellModule = new DMShellModule();
 #endif
 #if HAS_TELEMETRY
     new DeviceTelemetryModule();

src/modules/NodeInfoModule.cpp

@@ -158,8 +158,8 @@ meshtastic_MeshPacket *NodeInfoModule::allocReply()
         ignoreRequest = true;
         return NULL;
     } else {
-        ignoreRequest = false;     // Don't ignore requests anymore
-        meshtastic_User u = owner; // deliberate copy: the licensed strip below must not clobber the global owner state
+        ignoreRequest = false; // Don't ignore requests anymore
+        meshtastic_User &u = owner;
 
         // Strip the public key if the user is licensed
         if (u.is_licensed && u.public_key.size > 0) {

src/modules/PositionModule.cpp

@@ -339,9 +339,6 @@ meshtastic_MeshPacket *PositionModule::allocAtakPli()
     strncpy(takPacket.device_callsign, owner.long_name, sizeof(takPacket.device_callsign) - 1);
     takPacket.device_callsign[sizeof(takPacket.device_callsign) - 1] = '\0';
 
-    // CoT uid — ATAK drops PLI entities with empty uid; derive stable "!<nodenum>" id.
-    snprintf(takPacket.uid, sizeof(takPacket.uid), "!%08x", nodeDB->getNodeNum());
-
     // Encode TAKPacketV2 protobuf, leaving room for flags byte prefix
     uint8_t protobuf_bytes[sizeof(mp->decoded.payload.bytes) - 1];
     size_t proto_size = pb_encode_to_bytes(protobuf_bytes, sizeof(protobuf_bytes), &meshtastic_TAKPacketV2_msg, &takPacket);

src/modules/SerialModule.cpp

@@ -94,7 +94,7 @@ bool SerialModule::isValidConfig(const meshtastic_ModuleConfig_SerialConfig &con
         const char *warning =
             "Invalid Serial config: override console serial port is only supported in NMEA and CalTopo output-only modes.";
         LOG_ERROR(warning);
-#ifndef PIO_UNIT_TESTING
+#if !IS_RUNNING_TESTS
         meshtastic_ClientNotification *cn = clientNotificationPool.allocZeroed();
         cn->level = meshtastic_LogRecord_Level_ERROR;
         cn->time = getValidTime(RTCQualityFromNet);

src/motion/ICM42607PSensor.cpp

@@ -71,6 +71,9 @@ int32_t ICM42607PSensor::runOnce()
     }
     return MOTION_SENSOR_CHECK_INTERVAL_MS;
 #else
+    int16_t x = 0;
+    int16_t y = 0;
+    int16_t z = 0;
     inv_imu_sensor_event_t event = {};
 
     if (sensor == nullptr || sensor->getDataFromRegisters(event) != 0) {
@@ -82,8 +85,11 @@ int32_t ICM42607PSensor::runOnce()
         return MOTION_SENSOR_CHECK_INTERVAL_MS;
     }
 
-    // LOG_DEBUG("ICM-42607-P accel read x=%.3fg y=%.3fg z=%.3fg", (float)event.accel[0] / ICM42607P_COUNTS_PER_G,
-    //           (float)event.accel[1] / ICM42607P_COUNTS_PER_G, (float)event.accel[2] / ICM42607P_COUNTS_PER_G);
+    x = event.accel[0];
+    y = event.accel[1];
+    z = event.accel[2];
+    // LOG_DEBUG("ICM-42607-P accel read x=%.3fg y=%.3fg z=%.3fg", (float)x / ICM42607P_COUNTS_PER_G,
+    //           (float)y / ICM42607P_COUNTS_PER_G, (float)z / ICM42607P_COUNTS_PER_G);
 
     return MOTION_SENSOR_CHECK_INTERVAL_MS;
 #endif

src/mqtt/MQTT.cpp

@@ -23,6 +23,10 @@
 #include <ETH.h>
 #endif // HAS_ETHERNET
 #include "Default.h"
+#if !defined(ARCH_NRF52) || NRF52_USE_JSON
+#include "serialization/JSON.h"
+#include "serialization/MeshPacketSerializer.h"
+#endif
 #include <Throttle.h>
 #include <assert.h>
 #include <utility>
@@ -143,6 +147,96 @@ inline void onReceiveProto(char *topic, byte *payload, size_t length)
         router->enqueueReceivedMessage(p.release());
 }
 
+#if !defined(ARCH_NRF52) || NRF52_USE_JSON
+// returns true if this is a valid JSON envelope which we accept on downlink
+inline bool isValidJsonEnvelope(JSONObject &json)
+{
+    // Generate node ID from nodenum for comparison
+    std::string nodeId = nodeDB->getNodeId();
+    // if "sender" is provided, avoid processing packets we uplinked
+    return (json.find("sender") != json.end() ? (json["sender"]->AsString().compare(nodeId) != 0) : true) &&
+           (json.find("hopLimit") != json.end() ? json["hopLimit"]->IsNumber() : true) && // hop limit should be a number
+           (json.find("from") != json.end()) && json["from"]->IsNumber() &&
+           (json["from"]->AsNumber() == nodeDB->getNodeNum()) &&            // only accept message if the "from" is us
+           (json.find("type") != json.end()) && json["type"]->IsString() && // should specify a type
+           (json.find("payload") != json.end());                            // should have a payload
+}
+
+inline void onReceiveJson(byte *payload, size_t length)
+{
+    char payloadStr[length + 1];
+    memcpy(payloadStr, payload, length);
+    payloadStr[length] = 0; // null terminated string
+    std::unique_ptr<JSONValue> json_value(JSON::Parse(payloadStr));
+    if (json_value == nullptr) {
+        LOG_ERROR("JSON received payload on MQTT but not a valid JSON");
+        return;
+    }
+
+    JSONObject json;
+    json = json_value->AsObject();
+
+    if (!isValidJsonEnvelope(json)) {
+        LOG_ERROR("JSON received payload on MQTT but not a valid envelope");
+        return;
+    }
+
+    // this is a valid envelope
+    if (json["type"]->AsString().compare("sendtext") == 0 && json["payload"]->IsString()) {
+        std::string jsonPayloadStr = json["payload"]->AsString();
+        LOG_INFO("JSON payload %s, length %u", jsonPayloadStr.c_str(), jsonPayloadStr.length());
+
+        // construct protobuf data packet using TEXT_MESSAGE, send it to the mesh
+        meshtastic_MeshPacket *p = router->allocForSending();
+        p->decoded.portnum = meshtastic_PortNum_TEXT_MESSAGE_APP;
+        if (json.find("channel") != json.end() && json["channel"]->IsNumber() &&
+            (json["channel"]->AsNumber() < channels.getNumChannels()))
+            p->channel = json["channel"]->AsNumber();
+        if (json.find("to") != json.end() && json["to"]->IsNumber())
+            p->to = json["to"]->AsNumber();
+        if (json.find("hopLimit") != json.end() && json["hopLimit"]->IsNumber())
+            p->hop_limit = json["hopLimit"]->AsNumber();
+        if (jsonPayloadStr.length() <= sizeof(p->decoded.payload.bytes)) {
+            memcpy(p->decoded.payload.bytes, jsonPayloadStr.c_str(), jsonPayloadStr.length());
+            p->decoded.payload.size = jsonPayloadStr.length();
+            service->sendToMesh(p, RX_SRC_LOCAL);
+        } else {
+            LOG_WARN("Received MQTT json payload too long, drop");
+        }
+    } else if (json["type"]->AsString().compare("sendposition") == 0 && json["payload"]->IsObject()) {
+        // invent the "sendposition" type for a valid envelope
+        JSONObject posit;
+        posit = json["payload"]->AsObject(); // get nested JSON Position
+        meshtastic_Position pos = meshtastic_Position_init_default;
+        if (posit.find("latitude_i") != posit.end() && posit["latitude_i"]->IsNumber())
+            pos.latitude_i = posit["latitude_i"]->AsNumber();
+        if (posit.find("longitude_i") != posit.end() && posit["longitude_i"]->IsNumber())
+            pos.longitude_i = posit["longitude_i"]->AsNumber();
+        if (posit.find("altitude") != posit.end() && posit["altitude"]->IsNumber())
+            pos.altitude = posit["altitude"]->AsNumber();
+        if (posit.find("time") != posit.end() && posit["time"]->IsNumber())
+            pos.time = posit["time"]->AsNumber();
+
+        // construct protobuf data packet using POSITION, send it to the mesh
+        meshtastic_MeshPacket *p = router->allocForSending();
+        p->decoded.portnum = meshtastic_PortNum_POSITION_APP;
+        if (json.find("channel") != json.end() && json["channel"]->IsNumber() &&
+            (json["channel"]->AsNumber() < channels.getNumChannels()))
+            p->channel = json["channel"]->AsNumber();
+        if (json.find("to") != json.end() && json["to"]->IsNumber())
+            p->to = json["to"]->AsNumber();
+        if (json.find("hopLimit") != json.end() && json["hopLimit"]->IsNumber())
+            p->hop_limit = json["hopLimit"]->AsNumber();
+        p->decoded.payload.size =
+            pb_encode_to_bytes(p->decoded.payload.bytes, sizeof(p->decoded.payload.bytes), &meshtastic_Position_msg,
+                               &pos); // make the Data protobuf from position
+        service->sendToMesh(p, RX_SRC_LOCAL);
+    } else {
+        LOG_DEBUG("JSON ignore downlink message with unsupported type");
+    }
+}
+#endif
+
 /// Determines if the given IPAddress is a private IPv4 address, i.e. not routable on the public internet.
 bool isPrivateIpAddress(const IPAddress &ip)
 {
@@ -292,6 +386,26 @@ void MQTT::onReceive(char *topic, byte *payload, size_t length)
         return;
     }
 
+    // check if this is a json payload message by comparing the topic start
+    if (moduleConfig.mqtt.json_enabled && (strncmp(topic, jsonTopic.c_str(), jsonTopic.length()) == 0)) {
+#if !defined(ARCH_NRF52) || NRF52_USE_JSON
+        // parse the channel name from the topic string
+        // the topic has been checked above for having jsonTopic prefix, so just move past it
+        char *channelName = topic + jsonTopic.length();
+        // if another "/" was added, parse string up to that character
+        channelName = strtok(channelName, "/") ? strtok(channelName, "/") : channelName;
+        // We allow downlink JSON packets only on a channel named "mqtt"
+        const meshtastic_Channel &sendChannel = channels.getByName(channelName);
+        if (!(strncasecmp(channels.getGlobalId(sendChannel.index), Channels::mqttChannel, strlen(Channels::mqttChannel)) == 0 &&
+              sendChannel.settings.downlink_enabled)) {
+            LOG_WARN("JSON downlink received on channel not called 'mqtt' or without downlink enabled");
+            return;
+        }
+        onReceiveJson(payload, length);
+#endif
+        return;
+    }
+
     onReceiveProto(topic, payload, length);
 }
 
@@ -319,10 +433,12 @@ MQTT::MQTT() : concurrency::OSThread("mqtt"), mqttQueue(MAX_MQTT_QUEUE)
 
         if (*moduleConfig.mqtt.root) {
             cryptTopic = moduleConfig.mqtt.root + cryptTopic;
+            jsonTopic = moduleConfig.mqtt.root + jsonTopic;
             mapTopic = moduleConfig.mqtt.root + mapTopic;
             isConfiguredForDefaultRootTopic = isDefaultRootTopic(moduleConfig.mqtt.root);
         } else {
             cryptTopic = "msh" + cryptTopic;
+            jsonTopic = "msh" + jsonTopic;
             mapTopic = "msh" + mapTopic;
             isConfiguredForDefaultRootTopic = true;
         }
@@ -350,7 +466,7 @@ MQTT::MQTT() : concurrency::OSThread("mqtt"), mqttQueue(MAX_MQTT_QUEUE)
             enabled = true;
             runASAP = true;
             reconnectCount = 0;
-#ifndef PIO_UNIT_TESTING
+#if !IS_RUNNING_TESTS
             publishNodeInfo();
 #endif
         }
@@ -473,6 +589,14 @@ void MQTT::sendSubscriptions()
             std::string topic = cryptTopic + channels.getGlobalId(i) + "/+";
             LOG_INFO("Subscribe to %s", topic.c_str());
             pubSub.subscribe(topic.c_str(), 1); // FIXME, is QOS 1 right?
+#if !defined(ARCH_NRF52) ||                                                                                                      \
+    defined(NRF52_USE_JSON) // JSON is not supported on nRF52, see issue #2804 ### Fixed by using ArduinoJSON ###
+            if (moduleConfig.mqtt.json_enabled == true) {
+                std::string topicDecoded = jsonTopic + channels.getGlobalId(i) + "/+";
+                LOG_INFO("Subscribe to %s", topicDecoded.c_str());
+                pubSub.subscribe(topicDecoded.c_str(), 1); // FIXME, is QOS 1 right?
+            }
+#endif // ARCH_NRF52 NRF52_USE_JSON
         }
     }
 #if !MESHTASTIC_EXCLUDE_PKI
@@ -550,7 +674,7 @@ bool MQTT::isValidConfig(const meshtastic_ModuleConfig_MQTTConfig &config, MQTTC
                 const char *warning = "Could not reach the MQTT server. Settings will be saved, but please verify the server "
                                       "address and credentials.";
                 LOG_WARN(warning);
-#ifndef PIO_UNIT_TESTING
+#if !IS_RUNNING_TESTS
                 meshtastic_ClientNotification *cn = clientNotificationPool.allocZeroed();
                 if (cn) {
                     cn->level = meshtastic_LogRecord_Level_WARNING;
@@ -566,7 +690,7 @@ bool MQTT::isValidConfig(const meshtastic_ModuleConfig_MQTTConfig &config, MQTTC
 #else
         const char *warning = "Invalid MQTT config: proxy_to_client_enabled must be enabled on nodes that do not have a network";
         LOG_ERROR(warning);
-#ifndef PIO_UNIT_TESTING
+#if !IS_RUNNING_TESTS
         meshtastic_ClientNotification *cn = clientNotificationPool.allocZeroed();
         cn->level = meshtastic_LogRecord_Level_ERROR;
         cn->time = getValidTime(RTCQualityFromNet);
@@ -582,7 +706,7 @@ bool MQTT::isValidConfig(const meshtastic_ModuleConfig_MQTTConfig &config, MQTTC
     if (defaultServer && !IS_ONE_OF(parsed.serverPort, PubSubConfig::defaultPort, PubSubConfig::defaultPortTls)) {
         const char *warning = "Invalid MQTT config: default server address must not have a port specified";
         LOG_ERROR(warning);
-#ifndef PIO_UNIT_TESTING
+#if !IS_RUNNING_TESTS
         meshtastic_ClientNotification *cn = clientNotificationPool.allocZeroed();
         cn->level = meshtastic_LogRecord_Level_ERROR;
         cn->time = getValidTime(RTCQualityFromNet);
@@ -611,6 +735,33 @@ void MQTT::publishQueuedMessages()
     const std::unique_ptr<QueueEntry> entry(mqttQueue.dequeuePtr(0));
     LOG_INFO("publish %s, %u bytes from queue", entry->topic.c_str(), entry->envBytes.size());
     publish(entry->topic.c_str(), entry->envBytes.data(), entry->envBytes.size(), false);
+
+#if !defined(ARCH_NRF52) ||                                                                                                      \
+    defined(NRF52_USE_JSON) // JSON is not supported on nRF52, see issue #2804 ### Fixed by using ArduinoJson ###
+    if (!moduleConfig.mqtt.json_enabled)
+        return;
+
+    // handle json topic
+    const DecodedServiceEnvelope env(entry->envBytes.data(), entry->envBytes.size());
+    if (!env.validDecode || env.packet == NULL || env.channel_id == NULL)
+        return;
+
+    auto jsonString = MeshPacketSerializer::JsonSerialize(env.packet);
+    if (jsonString.length() == 0)
+        return;
+
+    // Generate node ID from nodenum for topic
+    std::string nodeId = nodeDB->getNodeId();
+
+    std::string topicJson;
+    if (env.packet->pki_encrypted) {
+        topicJson = jsonTopic + "PKI/" + nodeId;
+    } else {
+        topicJson = jsonTopic + env.channel_id + "/" + nodeId;
+    }
+    LOG_INFO("JSON publish message to %s, %u bytes: %s", topicJson.c_str(), jsonString.length(), jsonString.c_str());
+    publish(topicJson.c_str(), jsonString.c_str(), false);
+#endif // ARCH_NRF52 NRF52_USE_JSON
 }
 
 void MQTT::onSend(const meshtastic_MeshPacket &mp_encrypted, const meshtastic_MeshPacket &mp_decoded, ChannelIndex chIndex)
@@ -674,6 +825,21 @@ void MQTT::onSend(const meshtastic_MeshPacket &mp_encrypted, const meshtastic_Me
     if (moduleConfig.mqtt.proxy_to_client_enabled || this->isConnectedDirectly()) {
         LOG_DEBUG("MQTT Publish %s, %u bytes", topic.c_str(), numBytes);
         publish(topic.c_str(), bytes, numBytes, false);
+
+#if !defined(ARCH_NRF52) ||                                                                                                      \
+    defined(NRF52_USE_JSON) // JSON is not supported on nRF52, see issue #2804 ### Fixed by using ArduinoJson ###
+        if (!moduleConfig.mqtt.json_enabled)
+            return;
+        // handle json topic
+        auto jsonString = MeshPacketSerializer::JsonSerialize(&mp_decoded);
+        if (jsonString.length() == 0)
+            return;
+        // Generate node ID from nodenum for JSON topic
+        std::string nodeIdForJson = nodeDB->getNodeId();
+        std::string topicJson = jsonTopic + channelId + "/" + nodeIdForJson;
+        LOG_INFO("JSON publish message to %s, %u bytes: %s", topicJson.c_str(), jsonString.length(), jsonString.c_str());
+        publish(topicJson.c_str(), jsonString.c_str(), false);
+#endif // ARCH_NRF52 NRF52_USE_JSON
     } else {
         LOG_INFO("MQTT not connected, queue packet");
         QueueEntry *entry;

src/mqtt/MQTT.h

@@ -6,6 +6,9 @@
 #include "concurrency/OSThread.h"
 #include "mesh/Channels.h"
 #include "mesh/generated/meshtastic/mqtt.pb.h"
+#if !defined(ARCH_NRF52) || NRF52_USE_JSON
+#include "serialization/JSON.h"
+#endif
 #if HAS_WIFI
 #include <WiFiClient.h>
 #if __has_include(<WiFiClientSecure.h>)
@@ -98,8 +101,9 @@ class MQTT : private concurrency::OSThread
     explicit MQTT(std::unique_ptr<MQTTClient> mqttClient);
 #endif
 
-    std::string cryptTopic = "/2/e/"; // msh/2/e/CHANNELID/NODEID
-    std::string mapTopic = "/2/map/"; // For protobuf-encoded MapReport messages
+    std::string cryptTopic = "/2/e/";   // msh/2/e/CHANNELID/NODEID
+    std::string jsonTopic = "/2/json/"; // msh/2/json/CHANNELID/NODEID
+    std::string mapTopic = "/2/map/";   // For protobuf-encoded MapReport messages
 
     // For map reporting (only applies when enabled)
     const uint32_t default_map_position_precision = 14; // defaults to max. offset of ~1459m

src/mqtt/ServiceEnvelope.h

@@ -5,8 +5,7 @@
 // meshtastic_ServiceEnvelope that automatically releases dynamically allocated memory when it goes out of scope.
 struct DecodedServiceEnvelope : public meshtastic_ServiceEnvelope {
     DecodedServiceEnvelope(const uint8_t *payload, size_t length);
-    // const-qualified so std::variant instantiation works on Apple libc++ (copying stays ill-formed either way)
-    DecodedServiceEnvelope(const DecodedServiceEnvelope &) = delete;
+    DecodedServiceEnvelope(DecodedServiceEnvelope &) = delete;
     DecodedServiceEnvelope(DecodedServiceEnvelope &&);
     ~DecodedServiceEnvelope();
     // Clients must check that this is true before using.

src/nimble/NimbleBluetooth.cpp

@@ -21,7 +21,6 @@
 #include "PowerStatus.h"
 
 #include "host/ble_gap.h"
-#include "host/ble_hs.h"
 #include "host/ble_store.h"
 
 namespace
@@ -41,19 +40,12 @@ constexpr uint16_t kPreferredBleTxTimeUs = (kPreferredBleTxOctets + 14) * 8;
 
 BLECharacteristic *fromNumCharacteristic;
 BLECharacteristic *BatteryCharacteristic;
-static int lastBatteryLevel = -1; // last value written to 0x2A19, to skip redundant writes/notifies
 BLECharacteristic *logRadioCharacteristic;
 BLEServer *bleServer;
 
 static bool passkeyShowing;
 static std::atomic<uint16_t> nimbleBluetoothConnHandle{BLE_HS_CONN_HANDLE_NONE}; // BLE_HS_CONN_HANDLE_NONE means "no connection"
 
-// Set by onDisconnect (NimBLE task) to ask the main task to (re)start advertising. We must
-// not call NimBLE GAP APIs directly from the disconnect callback: a phone reconnecting with a
-// stale bond (e.g. after the device's NVS was wiped) triggers a MIC failure and a NimBLE host
-// reset, and re-entering ble_gap_adv_* while the host is mid-reset crashes (LoadProhibited).
-static std::atomic<bool> pendingStartAdvertising{false};
-
 static void clearPairingDisplay()
 {
     if (!passkeyShowing) {
@@ -162,23 +154,6 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
   protected:
     virtual int32_t runOnce() override
     {
-        // Restart advertising here (main task) if a disconnect asked us to. We defer this out
-        // of the NimBLE onDisconnect callback and gate it on ble_hs_synced() so we never
-        // re-enter the GAP API while the host is mid-reset -- the crash that happens when a
-        // phone reconnects with a stale bond to a freshly-wiped device.
-        if (pendingStartAdvertising) {
-            if (checkIsConnected()) {
-                pendingStartAdvertising = false; // a new physical connection beat us to it; nothing to do
-            } else if (ble_hs_synced()) {
-                pendingStartAdvertising = false;
-                if (nimbleBluetooth) {
-                    nimbleBluetooth->startAdvertising();
-                }
-            } else {
-                return 200; // host still re-syncing after a reset; retry shortly
-            }
-        }
-
         while (runOnceHasWorkToDo()) {
             /*
               PROCESS fromPhoneQueue BEFORE toPhoneQueue:
@@ -616,16 +591,6 @@ class NimbleBluetoothSecurityCallback : public BLESecurityCallbacks
     }
     void onAuthenticationComplete(ble_gap_conn_desc *desc) override
     {
-        // The library calls this on every BLE_GAP_EVENT_ENC_CHANGE, whether encryption
-        // succeeded or failed. A phone reconnecting with a stale bond (e.g. after the device's
-        // NVS was wiped) produces a *failed* encryption change here. Don't latch a
-        // connected/authenticated state in that case, or the notify/RSSI/battery paths will
-        // operate on a link that is actually being torn down.
-        if (desc == nullptr || !desc->sec_state.encrypted) {
-            LOG_WARN("BLE encryption change without an encrypted link; ignoring");
-            return;
-        }
-
         LOG_INFO("BLE authentication complete");
 
         meshtastic::BluetoothStatus newStatus(meshtastic::BluetoothStatus::ConnectionState::CONNECTED);
@@ -701,15 +666,7 @@ class NimbleBluetoothServerCallback : public BLEServerCallbacks
 
         nimbleBluetoothConnHandle = BLE_HS_CONN_HANDLE_NONE;
 
-        // Defer advertising restart to the main task (runOnce). Do NOT call startAdvertising()
-        // from here: if this disconnect was caused by a host reset (a phone reconnecting with a
-        // stale bond after an NVS wipe triggers a MIC failure -> host reset), re-entering the
-        // NimBLE GAP API now crashes. runOnce restarts once ble_hs_synced() is true again.
-        pendingStartAdvertising = true;
-        if (bluetoothPhoneAPI) {
-            bluetoothPhoneAPI->setIntervalFromNow(0);
-        }
-        concurrency::mainDelay.interrupt(); // wake the main loop to service the restart
+        ble->startAdvertising();
     }
 };
 
@@ -761,8 +718,6 @@ void NimbleBluetooth::deinit()
 #endif
 
     BLEDevice::deinit(true);
-    BatteryCharacteristic = nullptr; // freed by deinit; clear so updateBatteryLevel() won't touch it
-    lastBatteryLevel = -1;
 #endif
 }
 
@@ -901,31 +856,16 @@ void NimbleBluetooth::setupService()
     BatteryCharacteristic = batteryService->createCharacteristic( // 0x2A19 is the Battery Level characteristic)
         (uint16_t)0x2a19, BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_NOTIFY);
     BatteryCharacteristic->addDescriptor(batteryLevelDescriptor);
-    // Seed an initial 0-100 level so an early read of 0x2A19 returns a valid value.
-    uint8_t initialLevel = (powerStatus && powerStatus->getHasBattery()) ? powerStatus->getBatteryChargePercent() : 0;
-    if (initialLevel > 100)
-        initialLevel = 100;
-    BatteryCharacteristic->setValue(&initialLevel, 1);
-    lastBatteryLevel = initialLevel;
     batteryService->start();
 }
 
 /// Given a level between 0-100, update the BLE attribute
 void updateBatteryLevel(uint8_t level)
 {
-    if (!config.bluetooth.enabled || !BatteryCharacteristic)
-        return;
-
-    if (level > 100) // 0x2A19 must stay within the BAS 0-100 range
-        level = 100;
-    if (level == lastBatteryLevel)
-        return;
-    lastBatteryLevel = level;
-
-    // Cache the value so a READ works without a subscriber; notify only when connected.
-    BatteryCharacteristic->setValue(&level, 1);
-    if (nimbleBluetooth && nimbleBluetooth->isConnected())
+    if ((config.bluetooth.enabled == true) && nimbleBluetooth->isConnected()) {
+        BatteryCharacteristic->setValue(&level, 1);
         BatteryCharacteristic->notify();
+    }
 }
 
 void NimbleBluetooth::clearBonds()

src/platform/esp32/esp_eth_driver.h

@@ -1,7 +0,0 @@
-#pragma once
-
-#if __has_include_next("esp_eth_driver.h")
-#include_next "esp_eth_driver.h"
-#elif __has_include("esp_eth.h")
-#include "esp_eth.h"
-#endif

src/platform/nrf52/NRF52Bluetooth.cpp

@@ -15,9 +15,8 @@ static BLECharacteristic fromRadio = BLECharacteristic(BLEUuid(FROMRADIO_UUID_16
 static BLECharacteristic toRadio = BLECharacteristic(BLEUuid(TORADIO_UUID_16));
 static BLECharacteristic logRadio = BLECharacteristic(BLEUuid(LOGRADIO_UUID_16));
 
-static BLEDis bledis;             // DIS (Device Information Service) helper class instance
-static BLEBas blebas;             // BAS (Battery Service) helper class instance
-static int lastBatteryLevel = -1; // last value written to BAS, to skip redundant writes/notifies
+static BLEDis bledis; // DIS (Device Information Service) helper class instance
+static BLEBas blebas; // BAS (Battery Service) helper class instance
 #ifndef BLE_DFU_SECURE
 static BLEDfu bledfu; // DFU software update helper service
 #else
@@ -337,7 +336,6 @@ void NRF52Bluetooth::setup()
     LOG_INFO("Init the Battery Service");
     blebas.begin();
     blebas.write(0); // Unknown battery level for now
-    lastBatteryLevel = 0;
     // Setup the Heart Rate Monitor service using
     // BLEService and BLECharacteristic classes
     LOG_INFO("Init the Mesh bluetooth service");
@@ -357,14 +355,6 @@ void NRF52Bluetooth::resumeAdvertising()
 /// Given a level between 0-100, update the BLE attribute
 void updateBatteryLevel(uint8_t level)
 {
-    if (!nrf52Bluetooth) // skip until the Battery Service has been begun in setup()
-        return;
-
-    if (level > 100) // BAS battery level must stay within 0-100
-        level = 100;
-    if (level == lastBatteryLevel)
-        return;
-    lastBatteryLevel = level;
     blebas.write(level);
 }
 void NRF52Bluetooth::clearBonds()

src/platform/nrf52/architecture.h

@@ -85,8 +85,6 @@
 #define HW_VENDOR meshtastic_HardwareModel_T_ECHO
 #elif defined(T_ECHO_LITE)
 #define HW_VENDOR meshtastic_HardwareModel_T_ECHO_LITE
-#elif defined(T_ECHO_CARD)
-#define HW_VENDOR meshtastic_HardwareModel_T_ECHO_CARD
 #elif defined(TTGO_T_ECHO_PLUS)
 #define HW_VENDOR meshtastic_HardwareModel_T_ECHO_PLUS
 #elif defined(ELECROW_ThinkNode_M1)