Enhance congestion scaling coefficient for online nodes with power-law scaling

2026-10-08 13:10:03 +10:00 · 2026-01-28 06:34:47 -06:00
516 changed files with 4733 additions and 11340 deletions
@@ -20,7 +20,7 @@ ENV PIP_ROOT_USER_ACTION=ignore
 RUN apt-get update && apt-get install --no-install-recommends -y \
        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 && \
+        libusb-1.0-0-dev libssl-dev pkg-config libsqlite3-dev && \
    apt-get clean && rm -rf /var/lib/apt/lists/* && \
    pip install --no-cache-dir -U \
        platformio==6.1.16 \
@@ -1 +0,0 @@
-use nix
@@ -96,7 +96,6 @@ jobs:
          pio_platform: ${{ matrix.check.platform }}
          pio_env: ${{ matrix.check.board }}
          pio_target: check
-          pio_opts: --fail-on-defect=low

  build:
    needs: [setup, version]
@@ -1,213 +0,0 @@
-name: Issue Triage (Models)
-
-on:
-  issues:
-    types: [opened]
-
-permissions:
-  issues: write
-  models: read
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.issue.number }}
-  cancel-in-progress: true
-
-jobs:
-  triage:
-    if: ${{ github.repository == 'meshtastic/firmware' && github.event.issue.user.type != 'Bot' }}
-    runs-on: ubuntu-latest
-    steps:
-      # ─────────────────────────────────────────────────────────────────────────
-      # Step 1: Quality check (spam/AI-slop detection) - runs first, exits early if spam
-      # ─────────────────────────────────────────────────────────────────────────
-      - name: Detect spam or low-quality content
-        uses: actions/ai-inference@v2
-        id: quality
-        continue-on-error: true
-        with:
-          max-tokens: 20
-          prompt: |
-            Is this GitHub issue spam, AI-generated slop, or low quality?
-
-            Title: ${{ github.event.issue.title }}
-            Body: ${{ github.event.issue.body }}
-
-            Respond with exactly one of: spam, ai-generated, needs-review, ok
-          system-prompt: You detect spam and low-quality contributions. Be conservative - only flag obvious spam or AI slop.
-          model: openai/gpt-4o-mini
-
-      - name: Apply quality label if needed
-        if: steps.quality.outputs.response != '' && steps.quality.outputs.response != 'ok'
-        uses: actions/github-script@v8
-        env:
-          QUALITY_LABEL: ${{ steps.quality.outputs.response }}
-        with:
-          script: |
-            const label = (process.env.QUALITY_LABEL || '').trim().toLowerCase();
-            const labelMeta = {
-              'spam': { color: 'd73a4a', description: 'Possible spam' },
-              'ai-generated': { color: 'fbca04', description: 'Possible AI-generated low-quality content' },
-              'needs-review': { color: 'f9d0c4', description: 'Needs human review' },
-            };
-            const meta = labelMeta[label];
-            if (!meta) return;
-
-            // Ensure label exists
-            try {
-              await github.rest.issues.getLabel({ owner: context.repo.owner, repo: context.repo.repo, name: label });
-            } catch (e) {
-              if (e.status !== 404) throw e;
-              await github.rest.issues.createLabel({ owner: context.repo.owner, repo: context.repo.repo, name: label, color: meta.color, description: meta.description });
-            }
-
-            // Apply label
-            await github.rest.issues.addLabels({ owner: context.repo.owner, repo: context.repo.repo, issue_number: context.payload.issue.number, labels: [label] });
-
-            // Set output to skip remaining steps
-            core.setOutput('is_spam', 'true');
-
-      # ─────────────────────────────────────────────────────────────────────────
-      # Step 2: Duplicate detection - only if not spam
-      # ─────────────────────────────────────────────────────────────────────────
-      - name: Detect duplicate issues
-        if: steps.quality.outputs.response == 'ok' || steps.quality.outputs.response == ''
-        uses: pelikhan/action-genai-issue-dedup@bdb3b5d9451c1090ffcdf123d7447a5e7c7a2528 # v0.0.19
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-
-      # ─────────────────────────────────────────────────────────────────────────
-      # Step 3: Completeness check + auto-labeling (combined into one AI call)
-      # ─────────────────────────────────────────────────────────────────────────
-      - name: Determine if completeness check should be skipped
-        if: steps.quality.outputs.response == 'ok' || steps.quality.outputs.response == ''
-        uses: actions/github-script@v8
-        id: check-skip
-        with:
-          script: |
-            const title = (context.payload.issue.title || '').toLowerCase();
-            const labels = (context.payload.issue.labels || []).map(label => label.name);
-            const hasFeatureRequest = title.includes('feature request');
-            const hasEnhancement = labels.includes('enhancement');
-            const shouldSkip = hasFeatureRequest && hasEnhancement;
-            core.setOutput('should_skip', shouldSkip ? 'true' : 'false');
-
-      - name: Analyze issue completeness and determine labels
-        if: (steps.quality.outputs.response == 'ok' || steps.quality.outputs.response == '') && steps.check-skip.outputs.should_skip != 'true'
-        uses: actions/ai-inference@v2
-        id: analysis
-        continue-on-error: true
-        with:
-          prompt: |
-            Analyze this GitHub issue for completeness and determine if it needs labels.
-
-            IMPORTANT: Distinguish between:
-            - Device/firmware bugs (crashes, reboots, lockups, radio/GPS/display/power issues) - these need device logs
-            - Build/release/packaging issues (missing files, CI failures, download problems) - these do NOT need device logs
-            - Documentation or website issues - these do NOT need device logs
-
-            If this is a device/firmware bug, request device logs and explain how to get them:
-
-            Web Flasher logs:
-            - Go to https://flasher.meshtastic.org
-            - Connect the device via USB and click Connect
-            - Open the device console/log output, reproduce the problem, then copy/download and attach/paste the logs
-
-            Meshtastic CLI logs:
-            - Run: meshtastic --port <serial-port> --noproto
-            - Reproduce the problem, then copy/paste the terminal output
-
-            Also request key context if missing: device model/variant, firmware version, region, steps to reproduce, expected vs actual.
-
-            Respond ONLY with valid JSON (no markdown, no code fences):
-            {"complete": true, "comment": "", "label": "none"}
-            OR
-            {"complete": false, "comment": "Your helpful comment", "label": "needs-logs"}
-
-            Use "needs-logs" ONLY if this is a device/firmware bug AND no logs are attached.
-            Use "needs-info" if basic info like firmware version or steps to reproduce are missing.
-            Use "none" if the issue is complete, is a feature request, or is a build/CI/packaging issue.
-
-            Title: ${{ github.event.issue.title }}
-            Body: ${{ github.event.issue.body }}
-          system-prompt: You are a helpful assistant that triages GitHub issues. Be conservative with labels. Only request device logs for actual device/firmware bugs, not for build/release/CI issues.
-          model: openai/gpt-4o-mini
-
-      - name: Process analysis result
-        if: (steps.quality.outputs.response == 'ok' || steps.quality.outputs.response == '') && steps.check-skip.outputs.should_skip != 'true' && steps.analysis.outputs.response != ''
-        uses: actions/github-script@v8
-        id: process
-        env:
-          AI_RESPONSE: ${{ steps.analysis.outputs.response }}
-        with:
-          script: |
-            let raw = (process.env.AI_RESPONSE || '').trim();
-
-            // Strip markdown code fences if present
-            raw = raw.replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/i, '').trim();
-
-            let complete = true;
-            let comment = '';
-            let label = 'none';
-
-            try {
-              const parsed = JSON.parse(raw);
-              complete = !!parsed.complete;
-              comment = (parsed.comment ?? '').toString().trim();
-              label = (parsed.label ?? 'none').toString().trim().toLowerCase();
-            } catch {
-              // If JSON parse fails, log warning and don't comment (avoid posting raw JSON)
-              console.log('Failed to parse AI response as JSON:', raw);
-              complete = true;
-              comment = '';
-              label = 'none';
-            }
-
-            // Validate label
-            const allowedLabels = new Set(['needs-logs', 'needs-info', 'none']);
-            if (!allowedLabels.has(label)) label = 'none';
-
-            // Only comment if we have a valid parsed comment (not raw JSON)
-            const shouldComment = !complete && comment.length > 0 && !comment.startsWith('{');
-            core.setOutput('should_comment', shouldComment ? 'true' : 'false');
-            core.setOutput('comment_body', comment);
-            core.setOutput('label', label);
-
-      - name: Apply triage label
-        if: steps.process.outputs.label != '' && steps.process.outputs.label != 'none'
-        uses: actions/github-script@v8
-        env:
-          LABEL_NAME: ${{ steps.process.outputs.label }}
-        with:
-          script: |
-            const label = process.env.LABEL_NAME;
-            const labelMeta = {
-              'needs-logs': { color: 'cfd3d7', description: 'Device logs requested for triage' },
-              'needs-info': { color: 'f9d0c4', description: 'More information requested for triage' },
-            };
-            const meta = labelMeta[label];
-            if (!meta) return;
-
-            // Ensure label exists
-            try {
-              await github.rest.issues.getLabel({ owner: context.repo.owner, repo: context.repo.repo, name: label });
-            } catch (e) {
-              if (e.status !== 404) throw e;
-              await github.rest.issues.createLabel({ owner: context.repo.owner, repo: context.repo.repo, name: label, color: meta.color, description: meta.description });
-            }
-
-            // Apply label
-            await github.rest.issues.addLabels({ owner: context.repo.owner, repo: context.repo.repo, issue_number: context.payload.issue.number, labels: [label] });
-
-      - name: Comment on issue
-        if: steps.process.outputs.should_comment == 'true'
-        uses: actions/github-script@v8
-        env:
-          COMMENT_BODY: ${{ steps.process.outputs.comment_body }}
-        with:
-          script: |
-            await github.rest.issues.createComment({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: context.payload.issue.number,
-              body: process.env.COMMENT_BODY
-            });
@@ -1,139 +0,0 @@
-name: PR Triage (Models)
-
-on:
-  pull_request_target:
-    types: [opened]
-
-permissions:
-  pull-requests: write
-  issues: write
-  models: read
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number }}
-  cancel-in-progress: true
-
-jobs:
-  triage:
-    if: ${{ github.repository == 'meshtastic/firmware' && github.event.pull_request.user.type != 'Bot' }}
-    runs-on: ubuntu-latest
-    steps:
-      # ─────────────────────────────────────────────────────────────────────────
-      # Step 1: Check if PR already has automation/type labels (skip if so)
-      # ─────────────────────────────────────────────────────────────────────────
-      - name: Check existing labels
-        uses: actions/github-script@v8
-        id: check-labels
-        with:
-          script: |
-            const skipLabels = new Set(['automation']);
-            const typeLabels = new Set(['bugfix', 'hardware-support', 'enhancement', 'dependencies', 'submodules', 'github_actions', 'trunk', 'cleanup']);
-            const prLabels = context.payload.pull_request.labels.map(l => l.name);
-
-            const shouldSkipAll = prLabels.some(l => skipLabels.has(l));
-            const hasTypeLabel = prLabels.some(l => typeLabels.has(l));
-
-            core.setOutput('skip_all', shouldSkipAll ? 'true' : 'false');
-            core.setOutput('has_type_label', hasTypeLabel ? 'true' : 'false');
-
-      # ─────────────────────────────────────────────────────────────────────────
-      # Step 2: Quality check (spam/AI-slop detection)
-      # ─────────────────────────────────────────────────────────────────────────
-      - name: Detect spam or low-quality content
-        if: steps.check-labels.outputs.skip_all != 'true'
-        uses: actions/ai-inference@v2
-        id: quality
-        continue-on-error: true
-        with:
-          max-tokens: 20
-          prompt: |
-            Is this GitHub pull request spam, AI-generated slop, or low quality?
-
-            Title: ${{ github.event.pull_request.title }}
-            Body: ${{ github.event.pull_request.body }}
-
-            Respond with exactly one of: spam, ai-generated, needs-review, ok
-          system-prompt: You detect spam and low-quality contributions. Be conservative - only flag obvious spam or AI slop.
-          model: openai/gpt-4o-mini
-
-      - name: Apply quality label if needed
-        if: steps.check-labels.outputs.skip_all != 'true' && steps.quality.outputs.response != '' && steps.quality.outputs.response != 'ok'
-        uses: actions/github-script@v8
-        id: quality-label
-        env:
-          QUALITY_LABEL: ${{ steps.quality.outputs.response }}
-        with:
-          script: |
-            const label = (process.env.QUALITY_LABEL || '').trim().toLowerCase();
-            const labelMeta = {
-              'spam': { color: 'd73a4a', description: 'Possible spam' },
-              'ai-generated': { color: 'fbca04', description: 'Possible AI-generated low-quality content' },
-              'needs-review': { color: 'f9d0c4', description: 'Needs human review' },
-            };
-            const meta = labelMeta[label];
-            if (!meta) return;
-
-            // Ensure label exists
-            try {
-              await github.rest.issues.getLabel({ owner: context.repo.owner, repo: context.repo.repo, name: label });
-            } catch (e) {
-              if (e.status !== 404) throw e;
-              await github.rest.issues.createLabel({ owner: context.repo.owner, repo: context.repo.repo, name: label, color: meta.color, description: meta.description });
-            }
-
-            // Apply label
-            await github.rest.issues.addLabels({ owner: context.repo.owner, repo: context.repo.repo, issue_number: context.payload.pull_request.number, labels: [label] });
-
-            core.setOutput('is_spam', 'true');
-
-      # ─────────────────────────────────────────────────────────────────────────
-      # Step 3: Auto-label PR type (bugfix/hardware-support/enhancement)
-      # Only skip for spam/ai-generated; still classify needs-review PRs
-      # ─────────────────────────────────────────────────────────────────────────
-      - name: Classify PR for labeling
-        if: steps.check-labels.outputs.skip_all != 'true' && steps.check-labels.outputs.has_type_label != 'true' && steps.quality.outputs.response != 'spam' && steps.quality.outputs.response != 'ai-generated'
-        uses: actions/ai-inference@v2
-        id: classify
-        continue-on-error: true
-        with:
-          max-tokens: 30
-          prompt: |
-            Classify this pull request into exactly one category.
-
-            Return exactly one of: bugfix, hardware-support, enhancement
-
-            Use bugfix if it fixes a bug, crash, or incorrect behavior.
-            Use hardware-support if it adds or improves support for a specific hardware device/variant.
-            Use enhancement if it adds a new feature, improves performance, or refactors code.
-
-            Title: ${{ github.event.pull_request.title }}
-            Body: ${{ github.event.pull_request.body }}
-          system-prompt: You classify pull requests into categories. Be conservative and pick the most appropriate single label.
-          model: openai/gpt-4o-mini
-
-      - name: Apply type label
-        if: steps.check-labels.outputs.skip_all != 'true' && steps.check-labels.outputs.has_type_label != 'true' && steps.classify.outputs.response != ''
-        uses: actions/github-script@v8
-        env:
-          TYPE_LABEL: ${{ steps.classify.outputs.response }}
-        with:
-          script: |
-            const label = (process.env.TYPE_LABEL || '').trim().toLowerCase();
-            const labelMeta = {
-              'bugfix': { color: 'd73a4a', description: 'Bug fix' },
-              'hardware-support': { color: '0e8a16', description: 'Hardware support addition or improvement' },
-              'enhancement': { color: 'a2eeef', description: 'New feature or enhancement' },
-            };
-            const meta = labelMeta[label];
-            if (!meta) return;
-
-            // Ensure label exists
-            try {
-              await github.rest.issues.getLabel({ owner: context.repo.owner, repo: context.repo.repo, name: label });
-            } catch (e) {
-              if (e.status !== 404) throw e;
-              await github.rest.issues.createLabel({ owner: context.repo.owner, repo: context.repo.repo, name: label, color: meta.color, description: meta.description });
-            }
-
-            // Apply label
-            await github.rest.issues.addLabels({ owner: context.repo.owner, repo: context.repo.repo, issue_number: context.payload.pull_request.number, labels: [label] });
@@ -33,7 +33,6 @@ __pycache__
 *~

 venv/
-.venv/
 release/
 .vscode/extensions.json
 /compile_commands.json
@@ -51,6 +50,3 @@ idf_component.yml
 CMakeLists.txt
 /sdkconfig.*
 .dummy/*
-
-# PYTHONPATH used by the Nix shell
-.python3
@@ -8,18 +8,18 @@ plugins:
      uri: https://github.com/trunk-io/plugins
 lint:
  enabled:
-    - checkov@3.2.501
-    - renovate@43.10.3
-    - prettier@3.8.1
-    - trufflehog@3.93.3
+    - checkov@3.2.497
+    - renovate@42.84.2
+    - prettier@3.8.0
+    - trufflehog@3.92.5
    - yamllint@1.38.0
    - bandit@1.9.3
-    - trivy@0.69.1
+    - trivy@0.68.2
    - taplo@0.10.0
-    - ruff@0.15.1
+    - ruff@0.14.13
    - isort@7.0.0
    - markdownlint@0.47.0
-    - oxipng@10.1.0
+    - oxipng@10.0.0
    - svgo@4.0.0
    - actionlint@1.7.10
    - flake8@7.3.0
@@ -14,7 +14,7 @@ RUN apt-get update && apt-get install --no-install-recommends -y \
        curl wget g++ zip git ca-certificates pkg-config \
        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 \
+        libx11-dev libinput-dev libxkbcommon-x11-dev libsqlite3-dev \
    && apt-get clean && rm -rf /var/lib/apt/lists/* \
    && pip install --no-cache-dir -U platformio \
    && mkdir /tmp/firmware
@@ -53,7 +53,7 @@ USER root
 RUN apt-get update && apt-get --no-install-recommends -y install \
        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 \
+        libx11-6 libinput10 libxkbcommon-x11-0 \
    && apt-get clean && rm -rf /var/lib/apt/lists/* \
    && mkdir -p /var/lib/meshtasticd \
    && mkdir -p /etc/meshtasticd/config.d \
@@ -11,7 +11,7 @@ RUN apk --no-cache add \
        bash g++ libstdc++-dev linux-headers zip git ca-certificates libbsd-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 \
+        libx11-dev libinput-dev libxkbcommon-dev sqlite-dev \
    && rm -rf /var/cache/apk/* \
    && pip install --no-cache-dir -U platformio \
    && mkdir /tmp/firmware
@@ -42,7 +42,7 @@ USER root

 RUN apk --no-cache add \
        shadow libstdc++ libbsd libgpiod yaml-cpp libusb \
-        i2c-tools libuv libx11 libinput libxkbcommon sdl2 \
+        i2c-tools libuv libx11 libinput libxkbcommon \
    && rm -rf /var/cache/apk/* \
    && mkdir -p /var/lib/meshtasticd \
    && mkdir -p /etc/meshtasticd/config.d \
@@ -156,8 +156,16 @@ IF %BPS_RESET% EQU 1 (
 SET "PROGNAME=!FILENAME:.factory.bin=!"
 CALL :LOG_MESSAGE DEBUG "Computed PROGNAME: !PROGNAME!"

-@REM Determine OTA filename based on MCU type (unified OTA format)
-SET "OTA_FILENAME=mt-!MCU!-ota.bin"
+IF "__!MCU!__" == "__esp32s3__" (
+    @REM We are working with ESP32-S3
+    SET "OTA_FILENAME=bleota-s3.bin"
+) ELSE IF "__!MCU!__" == "__esp32c3__" (
+    @REM We are working with ESP32-C3
+    SET "OTA_FILENAME=bleota-c3.bin"
+) ELSE (
+    @REM Everything else
+    SET "OTA_FILENAME=bleota.bin"
+)
 CALL :LOG_MESSAGE DEBUG "Set OTA_FILENAME to: !OTA_FILENAME!"

@REM Set SPIFFS filename with "littlefs-" prefix.
@@ -131,8 +131,14 @@ if [[ -f "$FILENAME" && "$FILENAME" == *.factory.bin ]]; then
        exit 1
    fi

-    # Determine OTA filename based on MCU type (unified OTA format)
-    OTAFILE="mt-${MCU}-ota.bin"
+    # Determine OTA filename based on MCU type
+    if [ "$MCU" == "esp32s3" ]; then
+        OTAFILE=bleota-s3.bin
+    elif [ "$MCU" == "esp32c3" ]; then
+        OTAFILE=bleota-c3.bin
+    else
+        OTAFILE=bleota.bin
+    fi

    # Set SPIFFS filename with "littlefs-" prefix.
    SPIFFSFILE="littlefs-${PROGNAME/firmware-/}.bin"
@@ -87,9 +87,6 @@
  </screenshots>

  <releases>
-    <release version="2.7.20" date="2026-02-11">
-      <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.20</url>
-    </release>
    <release version="2.7.19" date="2026-01-22">
      <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.19</url>
    </release>
@@ -32,8 +32,7 @@
  "connectivity": ["bluetooth"],
  "debug": {
    "jlink_device": "nRF52840_xxAA",
-    "svd_path": "nrf52840.svd",
-    "openocd_target": "nrf52840-mdk-rs"
+    "svd_path": "nrf52840.svd"
  },
  "frameworks": ["arduino"],
  "name": "Minesemi ME25LS01",
@@ -33,8 +33,7 @@
  "connectivity": ["bluetooth"],
  "debug": {
    "jlink_device": "nRF52840_xxAA",
-    "svd_path": "nrf52840.svd",
-    "openocd_target": "nrf52840-mdk-rs"
+    "svd_path": "nrf52840.svd"
  },
  "frameworks": ["arduino"],
  "name": "MeshLink",
@@ -31,8 +31,7 @@
  "connectivity": ["bluetooth"],
  "debug": {
    "jlink_device": "nRF52840_xxAA",
-    "svd_path": "nrf52840.svd",
-    "openocd_target": "nrf52840-mdk-rs"
+    "svd_path": "nrf52840.svd"
  },
  "frameworks": ["arduino"],
  "name": "Minimesh Lite",
@@ -32,8 +32,7 @@
  "connectivity": ["bluetooth"],
  "debug": {
    "jlink_device": "nRF52840_xxAA",
-    "svd_path": "nrf52840.svd",
-    "openocd_target": "nrf52840-mdk-rs"
+    "svd_path": "nrf52840.svd"
  },
  "frameworks": ["arduino"],
  "name": "MINEWSEMI_MS24SF1_SX1262",
@@ -32,8 +32,7 @@
  "connectivity": ["bluetooth"],
  "debug": {
    "jlink_device": "nRF52840_xxAA",
-    "svd_path": "nrf52840.svd",
-    "openocd_target": "nrf52840-mdk-rs"
+    "svd_path": "nrf52840.svd"
  },
  "frameworks": ["arduino"],
  "name": "BQ nRF52840",
@@ -33,8 +33,7 @@
  "connectivity": ["bluetooth"],
  "debug": {
    "jlink_device": "nRF52840_xxAA",
-    "svd_path": "nrf52840.svd",
-    "openocd_target": "nrf52840-mdk-rs"
+    "svd_path": "nrf52840.svd"
  },
  "frameworks": ["arduino"],
  "name": "ProMicro compatible nRF52840",
@@ -8,7 +8,7 @@
    "extra_flags": [
      "-DBOARD_HAS_PSRAM",
      "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_MODE=0",
      "-DARDUINO_RUNNING_CORE=1",
      "-DARDUINO_EVENT_RUNNING_CORE=0"
    ],
@@ -33,8 +33,7 @@
  "connectivity": ["bluetooth"],
  "debug": {
    "jlink_device": "nRF52840_xxAA",
-    "svd_path": "nrf52840.svd",
-    "openocd_target": "nrf52840-mdk-rs"
+    "svd_path": "nrf52840.svd"
  },
  "frameworks": ["arduino"],
  "name": "Seeed T1000-E",
@@ -25,8 +25,7 @@
  "connectivity": ["bluetooth"],
  "debug": {
    "jlink_device": "nRF52840_xxAA",
-    "svd_path": "nrf52840.svd",
-    "openocd_target": "nrf52840-mdk-rs"
+    "svd_path": "nrf52840.svd"
  },
  "frameworks": ["arduino", "freertos"],
  "name": "Seeed WIO WM1110",
@@ -32,8 +32,7 @@
  "connectivity": ["bluetooth"],
  "debug": {
    "jlink_device": "nRF52840_xxAA",
-    "svd_path": "nrf52840.svd",
-    "openocd_target": "nrf52840-mdk-rs"
+    "svd_path": "nrf52840.svd"
  },
  "frameworks": ["arduino"],
  "name": "Seeed WIO WM1110",
@@ -32,8 +32,7 @@
  "connectivity": ["bluetooth"],
  "debug": {
    "jlink_device": "nRF52840_xxAA",
-    "svd_path": "nrf52840.svd",
-    "openocd_target": "nrf52840-mdk-rs"
+    "svd_path": "nrf52840.svd"
  },
  "frameworks": ["arduino"],
  "name": "Seeed WIO WM1110",
@@ -1,9 +1,3 @@
-meshtasticd (2.7.20.0) unstable; urgency=medium
-
-  * Version 2.7.20
-
- -- GitHub Actions <github-actions[bot]@users.noreply.github.com>  Wed, 11 Feb 2026 12:19:54 +0000
-
 meshtasticd (2.7.19.0) unstable; urgency=medium

  * Version 2.7.19
@@ -26,8 +26,7 @@ Build-Depends: debhelper-compat (= 13),
               libx11-dev,
               libinput-dev,
               libxkbcommon-x11-dev,
-               libsqlite3-dev,
-               libsdl2-dev
+               libsqlite3-dev
 Standards-Version: 4.6.2
 Homepage: https://github.com/meshtastic/firmware
 Rules-Requires-Root: no
@@ -1,44 +0,0 @@
-{
-  "nodes": {
-    "flake-compat": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1767039857,
-        "narHash": "sha256-vNpUSpF5Nuw8xvDLj2KCwwksIbjua2LZCqhV1LNRDns=",
-        "owner": "NixOS",
-        "repo": "flake-compat",
-        "rev": "5edf11c44bc78a0d334f6334cdaf7d60d732daab",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "repo": "flake-compat",
-        "type": "github"
-      }
-    },
-    "nixpkgs": {
-      "locked": {
-        "lastModified": 1766314097,
-        "narHash": "sha256-laJftWbghBehazn/zxVJ8NdENVgjccsWAdAqKXhErrM=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "306ea70f9eb0fb4e040f8540e2deab32ed7e2055",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "ref": "nixpkgs-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "root": {
-      "inputs": {
-        "flake-compat": "flake-compat",
-        "nixpkgs": "nixpkgs"
-      }
-    }
-  },
-  "root": "root",
-  "version": 7
-}
@@ -1,66 +0,0 @@
-{
-  description = "Nix flake to compile Meshtastic firmware";
-
-  inputs = {
-    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
-
-    # Shim to make flake.nix work with stable Nix.
-    flake-compat = {
-      url = "github:NixOS/flake-compat";
-      flake = false;
-    };
-  };
-
-  outputs =
-    inputs:
-    let
-      lib = inputs.nixpkgs.lib;
-
-      forAllSystems =
-        fn:
-        lib.genAttrs lib.systems.flakeExposed (
-          system:
-          fn {
-            pkgs = import inputs.nixpkgs {
-              inherit system;
-            };
-            inherit system;
-          }
-        );
-    in
-    {
-      devShells = forAllSystems (
-        { pkgs, ... }:
-        let
-          python3 = pkgs.python312.withPackages (
-            ps: with ps; [
-              google
-            ]
-          );
-        in
-        {
-          default = pkgs.mkShell {
-            buildInputs = with pkgs; [
-              python3
-              platformio
-            ];
-
-            shellHook = ''
-              # Set up PlatformIO to use a local core directory.
-              export PLATFORMIO_CORE_DIR=$PWD/.platformio
-              # Tell pip to put packages into $PIP_PREFIX instead of the usual
-              # location. This is especially necessary under NixOS to avoid having
-              # pip trying to write to the read-only Nix store. For more info,
-              # see https://wiki.nixos.org/wiki/Python
-              export PIP_PREFIX=$PWD/.python3
-              export PYTHONPATH="$PIP_PREFIX/${python3.sitePackages}"
-              export PATH="$PIP_PREFIX/bin:$PATH"
-              # Avoids reproducibility issues with some Python packages
-              # See https://nixos.org/manual/nixpkgs/stable/#python-setup.py-bdist_wheel-cannot-create-.whl
-              unset SOURCE_DATE_EPOCH
-            '';
-          };
-        }
-      );
-    };
-}
@@ -49,7 +49,6 @@ BuildRequires: pkgconfig(libulfius)
 BuildRequires: pkgconfig(x11)
 BuildRequires: pkgconfig(libinput)
 BuildRequires: pkgconfig(xkbcommon-x11)
-BuildRequires: pkgconfig(sdl2)

 # libbsd is needed on older Fedora/RHEL to provide 'strlcpy'
 %if 0%{?fedora} >= 39 || 0%{?rhel} >= 10
@@ -60,14 +59,8 @@ BuildRequires: pkgconfig(libbsd-overlay)

 Requires:      systemd-udev

-# Declare that this package provides the user/group it creates in %pre
-# Required for Fedora 43+ which tracks users/groups as RPM dependencies
-Provides:      user(%{meshtasticd_user})
-Provides:      group(%{meshtasticd_user})
-Provides:      group(spi)
-
 %description
-Meshtastic daemon. Meshtastic is an off-grid
+Meshtastic daemon for controlling Meshtastic devices. Meshtastic is an off-grid
 text communication platform that uses inexpensive LoRa radios.

 %prep
@@ -158,7 +151,6 @@ fi
 %license LICENSE
 %doc README.md
 %{_bindir}/meshtasticd
-%{_bindir}/meshtasticd-start.sh
 %dir %{_localstatedir}/lib/meshtasticd
 %{_udevrulesdir}/99-meshtasticd-udev.rules
 %dir %{_sysconfdir}/meshtasticd
@@ -50,15 +50,12 @@ build_flags = -Wno-missing-field-initializers
 	-DRADIOLIB_EXCLUDE_APRS=1
 	-DRADIOLIB_EXCLUDE_LORAWAN=1
 	-DMESHTASTIC_EXCLUDE_DROPZONE=1
-	-DMESHTASTIC_EXCLUDE_REPLYBOT=1
 	-DMESHTASTIC_EXCLUDE_REMOTEHARDWARE=1
 	-DMESHTASTIC_EXCLUDE_HEALTH_TELEMETRY=1
 	-DMESHTASTIC_EXCLUDE_POWERSTRESS=1 ; exclude power stress test module from main firmware
 	-DMESHTASTIC_EXCLUDE_GENERIC_THREAD_MODULE=1
 	-DMESHTASTIC_EXCLUDE_POWERMON=1
-	-DMESHTASTIC_EXCLUDE_STATUS=1
 	-D MAX_THREADS=40 ; As we've split modules, we have more threads to manage
-	-DLED_BUILTIN=-1
 	#-DBUILD_EPOCH=$UNIX_TIME ; set in platformio-custom.py now
 	#-D OLED_PL=1
 	#-D DEBUG_HEAP=1 ; uncomment to add free heap space / memory leak debugging logs
@@ -68,7 +65,7 @@ monitor_speed = 115200
 monitor_filters = direct
 lib_deps =
 	# renovate: datasource=git-refs depName=meshtastic-esp8266-oled-ssd1306 packageName=https://github.com/meshtastic/esp8266-oled-ssd1306 gitBranch=master
-	https://github.com/meshtastic/esp8266-oled-ssd1306/archive/21e484f409cde18d44012caef84c244eb5ca28f3.zip
+	https://github.com/meshtastic/esp8266-oled-ssd1306/archive/b34c6817c25d6faabb3a8a162b5d14fb75395433.zip
 	# renovate: datasource=git-refs depName=meshtastic-OneButton packageName=https://github.com/meshtastic/OneButton gitBranch=master
 	https://github.com/meshtastic/OneButton/archive/fa352d668c53f290cfa480a5f79ad422cd828c70.zip
 	# renovate: datasource=git-refs depName=meshtastic-arduino-fsm packageName=https://github.com/meshtastic/arduino-fsm gitBranch=master
@@ -117,12 +114,12 @@ lib_deps =
 [radiolib_base]
 lib_deps =
 	# renovate: datasource=custom.pio depName=RadioLib packageName=jgromes/library/RadioLib
-	jgromes/RadioLib@7.6.0
+	jgromes/RadioLib@7.5.0

 [device-ui_base]
 lib_deps =
 	# renovate: datasource=git-refs depName=meshtastic/device-ui packageName=https://github.com/meshtastic/device-ui gitBranch=master
-	https://github.com/meshtastic/device-ui/archive/6c75195e9987b7a49563232234f2f868dd343cae.zip
+	https://github.com/meshtastic/device-ui/archive/69739b84f87a91568d3c421498bc89977937a141.zip

 ; Common libs for environmental measurements in telemetry module
 [environmental_base]
@@ -146,7 +143,7 @@ lib_deps =
 	# renovate: datasource=custom.pio depName=Adafruit INA219 packageName=adafruit/library/Adafruit INA219
 	adafruit/Adafruit INA219@1.2.3
 	# renovate: datasource=custom.pio depName=Adafruit MPU6050 packageName=adafruit/library/Adafruit MPU6050
-	adafruit/Adafruit MPU6050@2.2.9
+	adafruit/Adafruit MPU6050@2.2.6
 	# renovate: datasource=custom.pio depName=Adafruit LIS3DH packageName=adafruit/library/Adafruit LIS3DH
 	adafruit/Adafruit LIS3DH@1.3.0
 	# renovate: datasource=custom.pio depName=Adafruit AHTX0 packageName=adafruit/library/Adafruit AHTX0
@@ -184,8 +181,39 @@ lib_deps =
 	# renovate: datasource=custom.pio depName=BH1750_WE packageName=wollewald/library/BH1750_WE
 	wollewald/BH1750_WE@1.1.10

-; Common environmental sensor libraries (not included in native / portduino)
-[environmental_extra_common]
+; (not included in native / portduino)
+[environmental_extra]
+lib_deps =
+	# renovate: datasource=custom.pio depName=Adafruit BMP3XX packageName=adafruit/library/Adafruit BMP3XX Library
+	adafruit/Adafruit BMP3XX Library@2.1.6
+	# renovate: datasource=custom.pio depName=Adafruit MAX1704X packageName=adafruit/library/Adafruit MAX1704X
+	adafruit/Adafruit MAX1704X@1.0.3
+	# renovate: datasource=custom.pio depName=Adafruit SHTC3 packageName=adafruit/library/Adafruit SHTC3 Library
+	adafruit/Adafruit SHTC3 Library@1.0.2
+	# renovate: datasource=custom.pio depName=Adafruit LPS2X packageName=adafruit/library/Adafruit LPS2X
+	adafruit/Adafruit LPS2X@2.0.6
+	# renovate: datasource=custom.pio depName=Adafruit SHT31 packageName=adafruit/library/Adafruit SHT31 Library
+	adafruit/Adafruit SHT31 Library@2.2.2
+	# renovate: datasource=custom.pio depName=Adafruit VEML7700 packageName=adafruit/library/Adafruit VEML7700 Library
+	adafruit/Adafruit VEML7700 Library@2.1.6
+	# renovate: datasource=custom.pio depName=Adafruit SHT4x packageName=adafruit/library/Adafruit SHT4x Library
+	adafruit/Adafruit SHT4x Library@1.0.5
+	# renovate: datasource=custom.pio depName=SparkFun Qwiic Scale NAU7802 packageName=sparkfun/library/SparkFun Qwiic Scale NAU7802 Arduino Library
+	sparkfun/SparkFun Qwiic Scale NAU7802 Arduino Library@1.0.6
+	# renovate: datasource=custom.pio depName=ClosedCube OPT3001 packageName=closedcube/library/ClosedCube OPT3001
+	closedcube/ClosedCube OPT3001@1.1.2
+	# renovate: datasource=custom.pio depName=Bosch BSEC2 packageName=boschsensortec/library/bsec2
+	boschsensortec/bsec2@1.10.2610
+	# renovate: datasource=custom.pio depName=Bosch BME68x packageName=boschsensortec/library/BME68x Sensor Library
+	boschsensortec/BME68x Sensor Library@1.3.40408
+	# renovate: datasource=git-refs depName=meshtastic-DFRobot_LarkWeatherStation packageName=https://github.com/meshtastic/DFRobot_LarkWeatherStation gitBranch=master
+	https://github.com/meshtastic/DFRobot_LarkWeatherStation/archive/4de3a9cadef0f6a5220a8a906cf9775b02b0040d.zip
+	# renovate: datasource=custom.pio depName=Sensirion Core packageName=sensirion/library/Sensirion Core
+	sensirion/Sensirion Core@0.7.2
+	# renovate: datasource=custom.pio depName=Sensirion I2C SCD4x packageName=sensirion/library/Sensirion I2C SCD4x
+	sensirion/Sensirion I2C SCD4x@1.1.0
+; Same as environmental_extra but without BSEC (saves ~3.5KB DRAM for original ESP32 targets)
+[environmental_extra_no_bsec]
 lib_deps =
 	# renovate: datasource=custom.pio depName=Adafruit BMP3XX packageName=adafruit/library/Adafruit BMP3XX Library
 	adafruit/Adafruit BMP3XX Library@2.1.6
@@ -208,26 +236,6 @@ lib_deps =
 	# renovate: datasource=git-refs depName=meshtastic-DFRobot_LarkWeatherStation packageName=https://github.com/meshtastic/DFRobot_LarkWeatherStation gitBranch=master
 	https://github.com/meshtastic/DFRobot_LarkWeatherStation/archive/4de3a9cadef0f6a5220a8a906cf9775b02b0040d.zip
 	# renovate: datasource=custom.pio depName=Sensirion Core packageName=sensirion/library/Sensirion Core
-	sensirion/Sensirion Core@0.7.3
+	sensirion/Sensirion Core@0.7.2
 	# renovate: datasource=custom.pio depName=Sensirion I2C SCD4x packageName=sensirion/library/Sensirion I2C SCD4x
-	sensirion/Sensirion I2C SCD4x@1.1.0
-	# renovate: datasource=custom.pio depName=Sensirion I2C SFA3x packageName=sensirion/library/Sensirion I2C SFA3x
-	sensirion/Sensirion I2C SFA3x@1.0.0
-	# renovate: datasource=custom.pio depName=Sensirion I2C SCD30 packageName=sensirion/library/Sensirion I2C SCD30
-	sensirion/Sensirion I2C SCD30@1.0.0
-
-; Environmental sensors with BSEC2 (Bosch proprietary IAQ)
-[environmental_extra]
-lib_deps =
-	${environmental_extra_common.lib_deps}
-	# renovate: datasource=custom.pio depName=Bosch BSEC2 packageName=boschsensortec/library/bsec2
-	boschsensortec/bsec2@1.10.2610
-	# renovate: datasource=custom.pio depName=Bosch BME68x packageName=boschsensortec/library/BME68x Sensor Library
-	boschsensortec/BME68x Sensor Library@1.3.40408
-
-; Environmental sensors without BSEC (saves ~3.5KB DRAM for original ESP32 targets)
-[environmental_extra_no_bsec]
-lib_deps =
-	${environmental_extra_common.lib_deps}
-	# renovate: datasource=custom.pio depName=adafruit/Adafruit BME680 Library packageName=adafruit/library/Adafruit BME680
-	adafruit/Adafruit BME680 Library@^2.0.5
+	sensirion/Sensirion I2C SCD4x@1.1.0
@@ -1,12 +0,0 @@
-(import (
-  let
-    lock = builtins.fromJSON (builtins.readFile ./flake.lock);
-    nodeName = lock.nodes.root.inputs.flake-compat;
-  in
-  fetchTarball {
-    url =
-      lock.nodes.${nodeName}.locked.url
-        or "https://github.com/NixOS/flake-compat/archive/${lock.nodes.${nodeName}.locked.rev}.tar.gz";
-    sha256 = lock.nodes.${nodeName}.locked.narHash;
-  }
-) { src = ./.; }).shellNix
@@ -1,23 +1,19 @@
-#ifndef AMBIENTLIGHTINGTHREAD_H
-#define AMBIENTLIGHTINGTHREAD_H
-
 #include "Observer.h"
 #include "configuration.h"
-#include "detect/ScanI2C.h"
-#include "sleep.h"

 #ifdef HAS_NCP5623
-#include <Wire.h>
-
-#include <NCP5623.h>
+#include <graphics/RAKled.h>
+NCP5623 rgb;
 #endif

 #ifdef HAS_LP5562
 #include <graphics/NomadStarLED.h>
+LP5562 rgbw;
 #endif

 #ifdef HAS_NEOPIXEL
-#include <Adafruit_NeoPixel.h>
+#include <graphics/NeoPixel.h>
+Adafruit_NeoPixel pixels(NEOPIXEL_COUNT, NEOPIXEL_DATA, NEOPIXEL_TYPE);
 #endif

 #ifdef UNPHONE
@@ -25,24 +21,10 @@
 extern unPhone unphone;
 #endif

+namespace concurrency
+{
 class AmbientLightingThread : public concurrency::OSThread
 {
-    friend class StatusLEDModule; // Let the LEDStatusModule trigger the ambient lighting for notifications and battery status.
-    friend class ExternalNotificationModule; // Let the ExternalNotificationModule trigger the ambient lighting for notifications.
-
-  private:
-#ifdef HAS_NCP5623
-    NCP5623 rgb;
-#endif
-
-#ifdef HAS_LP5562
-    LP5562 rgbw;
-#endif
-
-#ifdef HAS_NEOPIXEL
-    Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NEOPIXEL_COUNT, NEOPIXEL_DATA, NEOPIXEL_TYPE);
-#endif
-
  public:
    explicit AmbientLightingThread(ScanI2C::DeviceType type) : OSThread("AmbientLighting")
    {
@@ -54,15 +36,14 @@ class AmbientLightingThread : public concurrency::OSThread
        moduleConfig.ambient_lighting.led_state = true;
 #endif
 #endif
-#if AMBIENT_LIGHTING_TEST
-        // define to enable test
-        moduleConfig.ambient_lighting.led_state = true;
-        moduleConfig.ambient_lighting.current = 10;
+        // Uncomment to test module
+        // moduleConfig.ambient_lighting.led_state = true;
+        // moduleConfig.ambient_lighting.current = 10;
        // Default to a color based on our node number
-        moduleConfig.ambient_lighting.red = (myNodeInfo.my_node_num & 0xFF0000) >> 16;
-        moduleConfig.ambient_lighting.green = (myNodeInfo.my_node_num & 0x00FF00) >> 8;
-        moduleConfig.ambient_lighting.blue = myNodeInfo.my_node_num & 0x0000FF;
-#endif
+        // moduleConfig.ambient_lighting.red = (myNodeInfo.my_node_num & 0xFF0000) >> 16;
+        // moduleConfig.ambient_lighting.green = (myNodeInfo.my_node_num & 0x00FF00) >> 8;
+        // moduleConfig.ambient_lighting.blue = myNodeInfo.my_node_num & 0x0000FF;
+
 #if defined(HAS_NCP5623) || defined(HAS_LP5562)
        _type = type;
        if (_type == ScanI2C::DeviceType::NONE) {
@@ -72,6 +53,11 @@ class AmbientLightingThread : public concurrency::OSThread
        }
 #endif
 #ifdef HAS_RGB_LED
+        if (!moduleConfig.ambient_lighting.led_state) {
+            LOG_DEBUG("AmbientLighting Disable due to moduleConfig.ambient_lighting.led_state OFF");
+            disable();
+            return;
+        }
        LOG_DEBUG("AmbientLighting init");
 #ifdef HAS_NCP5623
        if (_type == ScanI2C::NCP5623) {
@@ -91,13 +77,7 @@ class AmbientLightingThread : public concurrency::OSThread
                pixels.clear(); // Set all pixel colors to 'off'
                pixels.setBrightness(moduleConfig.ambient_lighting.current);
 #endif
-                if (!moduleConfig.ambient_lighting.led_state) {
-                    LOG_DEBUG("AmbientLighting Disable due to moduleConfig.ambient_lighting.led_state OFF");
-                    disable();
-                    return;
-                }
-                setLighting(moduleConfig.ambient_lighting.current, moduleConfig.ambient_lighting.red,
-                            moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
+                setLighting();
 #endif
 #if defined(HAS_NCP5623) || defined(HAS_LP5562)
            }
@@ -111,8 +91,7 @@ class AmbientLightingThread : public concurrency::OSThread
 #if defined(HAS_NCP5623) || defined(HAS_LP5562)
            if ((_type == ScanI2C::NCP5623 || _type == ScanI2C::LP5562) && moduleConfig.ambient_lighting.led_state) {
 #endif
-                setLighting(moduleConfig.ambient_lighting.current, moduleConfig.ambient_lighting.red,
-                            moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
+                setLighting();
                return 30000; // 30 seconds to reset from any animations that may have been running from Ext. Notification
 #if defined(HAS_NCP5623) || defined(HAS_LP5562)
            }
@@ -169,53 +148,65 @@ class AmbientLightingThread : public concurrency::OSThread
            return 0;
        }

-      protected:
-        void setLighting(float current, uint8_t red, uint8_t green, uint8_t blue)
+        void setLighting()
        {
 #ifdef HAS_NCP5623
-            rgb.setCurrent(current);
-            rgb.setRed(red);
-            rgb.setGreen(green);
-            rgb.setBlue(blue);
-            LOG_DEBUG("Init NCP5623 Ambient light w/ current=%f, red=%d, green=%d, blue=%d", current, red, green, blue);
+            rgb.setCurrent(moduleConfig.ambient_lighting.current);
+            rgb.setRed(moduleConfig.ambient_lighting.red);
+            rgb.setGreen(moduleConfig.ambient_lighting.green);
+            rgb.setBlue(moduleConfig.ambient_lighting.blue);
+            LOG_DEBUG("Init NCP5623 Ambient light w/ current=%d, red=%d, green=%d, blue=%d",
+                      moduleConfig.ambient_lighting.current, moduleConfig.ambient_lighting.red,
+                      moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
 #endif
 #ifdef HAS_LP5562
-            rgbw.setCurrent(current);
-            rgbw.setRed(red);
-            rgbw.setGreen(green);
-            rgbw.setBlue(blue);
-            LOG_DEBUG("Init LP5562 Ambient light w/ current=%f, red=%d, green=%d, blue=%d", current, red, green, blue);
+            rgbw.setCurrent(moduleConfig.ambient_lighting.current);
+            rgbw.setRed(moduleConfig.ambient_lighting.red);
+            rgbw.setGreen(moduleConfig.ambient_lighting.green);
+            rgbw.setBlue(moduleConfig.ambient_lighting.blue);
+            LOG_DEBUG("Init LP5562 Ambient light w/ current=%d, red=%d, green=%d, blue=%d", moduleConfig.ambient_lighting.current,
+                      moduleConfig.ambient_lighting.red, moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
 #endif
 #ifdef HAS_NEOPIXEL
-            pixels.fill(pixels.Color(red, green, blue), 0, NEOPIXEL_COUNT);
+            pixels.fill(pixels.Color(moduleConfig.ambient_lighting.red, moduleConfig.ambient_lighting.green,
+                                     moduleConfig.ambient_lighting.blue),
+                        0, NEOPIXEL_COUNT);

 // RadioMaster Bandit has addressable LED at the two buttons
 // this allow us to set different lighting for them in variant.h file.
+#ifdef RADIOMASTER_900_BANDIT
 #if defined(BUTTON1_COLOR) && defined(BUTTON1_COLOR_INDEX)
            pixels.fill(BUTTON1_COLOR, BUTTON1_COLOR_INDEX, 1);
 #endif
 #if defined(BUTTON2_COLOR) && defined(BUTTON2_COLOR_INDEX)
            pixels.fill(BUTTON2_COLOR, BUTTON2_COLOR_INDEX, 1);
+#endif
 #endif
            pixels.show();
-            // LOG_DEBUG("Init NeoPixel Ambient light w/ brightness(current)=%f, red=%d, green=%d, blue=%d",
-            //        current, red, green, blue);
+            // LOG_DEBUG("Init NeoPixel Ambient light w/ brightness(current)=%d, red=%d, green=%d, blue=%d",
+            //        moduleConfig.ambient_lighting.current, moduleConfig.ambient_lighting.red,
+            //        moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
 #endif
 #ifdef RGBLED_CA
-            analogWrite(RGBLED_RED, 255 - red);
-            analogWrite(RGBLED_GREEN, 255 - green);
-            analogWrite(RGBLED_BLUE, 255 - blue);
-            LOG_DEBUG("Init Ambient light RGB Common Anode w/ red=%d, green=%d, blue=%d", red, green, blue);
+            analogWrite(RGBLED_RED, 255 - moduleConfig.ambient_lighting.red);
+            analogWrite(RGBLED_GREEN, 255 - moduleConfig.ambient_lighting.green);
+            analogWrite(RGBLED_BLUE, 255 - moduleConfig.ambient_lighting.blue);
+            LOG_DEBUG("Init Ambient light RGB Common Anode w/ red=%d, green=%d, blue=%d", moduleConfig.ambient_lighting.red,
+                      moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
 #elif defined(RGBLED_RED)
-        analogWrite(RGBLED_RED, red);
-        analogWrite(RGBLED_GREEN, green);
-        analogWrite(RGBLED_BLUE, blue);
-        LOG_DEBUG("Init Ambient light RGB Common Cathode w/ red=%d, green=%d, blue=%d", red, green, blue);
+        analogWrite(RGBLED_RED, moduleConfig.ambient_lighting.red);
+        analogWrite(RGBLED_GREEN, moduleConfig.ambient_lighting.green);
+        analogWrite(RGBLED_BLUE, moduleConfig.ambient_lighting.blue);
+        LOG_DEBUG("Init Ambient light RGB Common Cathode w/ red=%d, green=%d, blue=%d", moduleConfig.ambient_lighting.red,
+                  moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
 #endif
 #ifdef UNPHONE
-            unphone.rgb(red, green, blue);
-            LOG_DEBUG("Init unPhone Ambient light w/ red=%d, green=%d, blue=%d", red, green, blue);
+            unphone.rgb(moduleConfig.ambient_lighting.red, moduleConfig.ambient_lighting.green,
+                        moduleConfig.ambient_lighting.blue);
+            LOG_DEBUG("Init unPhone Ambient light w/ red=%d, green=%d, blue=%d", moduleConfig.ambient_lighting.red,
+                      moduleConfig.ambient_lighting.green, moduleConfig.ambient_lighting.blue);
 #endif
        }
    };
-#endif // AMBIENTLIGHTINGTHREAD_H
+
+} // namespace concurrency
@@ -4,7 +4,6 @@
 #include "configuration.h"
 #include "main.h"
 #include "sleep.h"
-#include <memory>

 #ifdef HAS_I2S
 #include <AudioFileSourcePROGMEM.h>
@@ -30,9 +29,9 @@ class AudioThread : public concurrency::OSThread
        io.digitalWrite(EXPANDS_AMP_EN, HIGH);
 #endif
        setCPUFast(true);
-        rtttlFile = std::unique_ptr<AudioFileSourcePROGMEM>(new AudioFileSourcePROGMEM(data, len));
-        i2sRtttl = std::unique_ptr<AudioGeneratorRTTTL>(new AudioGeneratorRTTTL());
-        i2sRtttl->begin(rtttlFile.get(), audioOut.get());
+        rtttlFile = new AudioFileSourcePROGMEM(data, len);
+        i2sRtttl = new AudioGeneratorRTTTL();
+        i2sRtttl->begin(rtttlFile, audioOut);
    }

    // Also handles actually playing the RTTTL, needs to be called in loop
@@ -48,10 +47,12 @@ class AudioThread : public concurrency::OSThread
    {
        if (i2sRtttl != nullptr) {
            i2sRtttl->stop();
+            delete i2sRtttl;
            i2sRtttl = nullptr;
        }

        if (rtttlFile != nullptr) {
+            delete rtttlFile;
            rtttlFile = nullptr;
        }

@@ -65,14 +66,16 @@ class AudioThread : public concurrency::OSThread
    {
        if (i2sRtttl != nullptr) {
            i2sRtttl->stop();
+            delete i2sRtttl;
            i2sRtttl = nullptr;
        }

 #ifdef T_LORA_PAGER
        io.digitalWrite(EXPANDS_AMP_EN, HIGH);
 #endif
-        auto sam = std::unique_ptr<ESP8266SAM>(new ESP8266SAM);
-        sam->Say(audioOut.get(), text);
+        ESP8266SAM *sam = new ESP8266SAM;
+        sam->Say(audioOut, text);
+        delete sam;
        setCPUFast(false);
 #ifdef T_LORA_PAGER
        io.digitalWrite(EXPANDS_AMP_EN, LOW);
@@ -93,15 +96,15 @@ class AudioThread : public concurrency::OSThread
  private:
    void initOutput()
    {
-        audioOut = std::unique_ptr<AudioOutputI2S>(new AudioOutputI2S(1, AudioOutputI2S::EXTERNAL_I2S));
+        audioOut = new AudioOutputI2S(1, AudioOutputI2S::EXTERNAL_I2S);
        audioOut->SetPinout(DAC_I2S_BCK, DAC_I2S_WS, DAC_I2S_DOUT, DAC_I2S_MCLK);
        audioOut->SetGain(0.2);
    };

-    std::unique_ptr<AudioGeneratorRTTTL> i2sRtttl = nullptr;
-    std::unique_ptr<AudioOutputI2S> audioOut = nullptr;
+    AudioGeneratorRTTTL *i2sRtttl = nullptr;
+    AudioOutputI2S *audioOut = nullptr;

-    std::unique_ptr<AudioFileSourcePROGMEM> rtttlFile = nullptr;
+    AudioFileSourcePROGMEM *rtttlFile = nullptr;
 };

 #endif
@@ -89,14 +89,22 @@ class BluetoothStatus : public Status
            case ConnectionState::CONNECTED:
                LOG_DEBUG("BluetoothStatus CONNECTED");
 #ifdef BLE_LED
-                digitalWrite(BLE_LED, LED_STATE_ON);
+#ifdef BLE_LED_INVERTED
+                digitalWrite(BLE_LED, LOW);
+#else
+                digitalWrite(BLE_LED, HIGH);
+#endif
 #endif
                break;

            case ConnectionState::DISCONNECTED:
                LOG_DEBUG("BluetoothStatus DISCONNECTED");
 #ifdef BLE_LED
-                digitalWrite(BLE_LED, LED_STATE_OFF);
+#ifdef BLE_LED_INVERTED
+                digitalWrite(BLE_LED, HIGH);
+#else
+                digitalWrite(BLE_LED, LOW);
+#endif
 #endif
                break;
            }
@@ -0,0 +1,66 @@
+#include "Led.h"
+#include "PowerMon.h"
+#include "main.h"
+#include "power.h"
+
+GpioVirtPin ledForceOn, ledBlink;
+
+#if defined(LED_PIN)
+// Most boards have a GPIO for LED control
+static GpioHwPin ledRawHwPin(LED_PIN);
+#else
+static GpioVirtPin ledRawHwPin; // Dummy pin for no hardware
+#endif
+
+#if LED_STATE_ON == 0
+static GpioVirtPin ledHwPin;
+static GpioNotTransformer ledInverter(&ledHwPin, &ledRawHwPin);
+#else
+static GpioPin &ledHwPin = ledRawHwPin;
+#endif
+
+#if defined(HAS_PMU)
+/**
+ * A GPIO controlled by the PMU
+ */
+class GpioPmuPin : public GpioPin
+{
+  public:
+    void set(bool value)
+    {
+        if (pmu_found && PMU) {
+            // blink the axp led
+            PMU->setChargingLedMode(value ? XPOWERS_CHG_LED_ON : XPOWERS_CHG_LED_OFF);
+        }
+    }
+} ledPmuHwPin;
+
+// In some cases we need to drive a PMU LED and a normal LED
+static GpioSplitter ledFinalPin(&ledHwPin, &ledPmuHwPin);
+#else
+static GpioPin &ledFinalPin = ledHwPin;
+#endif
+
+#ifdef USE_POWERMON
+/**
+ * We monitor changes to the LED drive output because we use that as a sanity test in our power monitor stuff.
+ */
+class MonitoredLedPin : public GpioPin
+{
+  public:
+    void set(bool value)
+    {
+        if (powerMon) {
+            if (value)
+                powerMon->setState(meshtastic_PowerMon_State_LED_On);
+            else
+                powerMon->clearState(meshtastic_PowerMon_State_LED_On);
+        }
+        ledFinalPin.set(value);
+    }
+} monitoredLedPin;
+#else
+static GpioPin &monitoredLedPin = ledFinalPin;
+#endif
+
+static GpioBinaryTransformer ledForcer(&ledForceOn, &ledBlink, &monitoredLedPin, GpioBinaryTransformer::Or);
@@ -0,0 +1,7 @@
+#include "GpioLogic.h"
+#include "configuration.h"
+
+/**
+ * ledForceOn and ledForceOff both override the normal ledBlinker behavior (which is controlled by main)
+ */
+extern GpioVirtPin ledForceOn, ledBlink;
@@ -459,8 +459,6 @@ class AnalogBatteryLevel : public HasBatteryLevel
        }
        // if it's not HIGH - check the battery
 #endif
-        // If we have an EXT_PWR_DETECT pin and it indicates no external power, believe it.
-        return false;

 // technically speaking this should work for all(?) NRF52 boards
 // but needs testing across multiple devices. NRF52 USB would not even work if
@@ -692,9 +690,7 @@ bool Power::setup()
    bool found = false;
    if (axpChipInit()) {
        found = true;
-    } else if (cw2015Init()) {
-        found = true;
-    } else if (max17048Init()) {
+    } else if (lipoInit()) {
        found = true;
    } else if (lipoChargerInit()) {
        found = true;
@@ -704,11 +700,11 @@ bool Power::setup()
        found = true;
    } else if (analogInit()) {
        found = true;
-    } else {
-#ifdef NRF_APM
-        found = true;
-#endif
    }
+
+#ifdef NRF_APM
+    found = true;
+#endif
 #ifdef EXT_PWR_DETECT
    attachInterrupt(
        EXT_PWR_DETECT,
@@ -820,9 +816,6 @@ void Power::shutdown()
 #endif
 #ifdef PIN_LED3
    ledOff(PIN_LED3);
-#endif
-#ifdef LED_NOTIFICATION
-    ledOff(LED_NOTIFICATION);
 #endif
    doDeepSleep(DELAY_FOREVER, true, true);
 #elif defined(ARCH_PORTDUINO)
@@ -846,10 +839,8 @@ void Power::readPowerStatus()

    if (batteryLevel) {
        hasBattery = batteryLevel->isBatteryConnect() ? OptTrue : OptFalse;
-#ifndef NRF_APM
        usbPowered = batteryLevel->isVbusIn() ? OptTrue : OptFalse;
        isChargingNow = batteryLevel->isCharging() ? OptTrue : OptFalse;
-#endif
        if (hasBattery) {
            batteryVoltageMv = batteryLevel->getBattVoltage();
            // If the AXP192 returns a valid battery percentage, use it
@@ -1325,7 +1316,7 @@ bool Power::axpChipInit()
 /**
 * Wrapper class for an I2C MAX17048 Lipo battery sensor.
 */
-class MAX17048BatteryLevel : public HasBatteryLevel
+class LipoBatteryLevel : public HasBatteryLevel
 {
  private:
    MAX17048Singleton *max17048 = nullptr;
@@ -1373,18 +1364,18 @@ class MAX17048BatteryLevel : public HasBatteryLevel
    virtual bool isCharging() override { return max17048->isBatteryCharging(); }
 };

-MAX17048BatteryLevel max17048Level;
+LipoBatteryLevel lipoLevel;

 /**
 * Init the Lipo battery level sensor
 */
-bool Power::max17048Init()
+bool Power::lipoInit()
 {
-    bool result = max17048Level.runOnce();
-    LOG_DEBUG("Power::max17048Init lipo sensor is %s", result ? "ready" : "not ready yet");
+    bool result = lipoLevel.runOnce();
+    LOG_DEBUG("Power::lipoInit lipo sensor is %s", result ? "ready" : "not ready yet");
    if (!result)
        return false;
-    batteryLevel = &max17048Level;
+    batteryLevel = &lipoLevel;
    return true;
 }

@@ -1392,88 +1383,7 @@ bool Power::max17048Init()
 /**
 * The Lipo battery level sensor is unavailable - default to AnalogBatteryLevel
 */
-bool Power::max17048Init()
-{
-    return false;
-}
-#endif
-
-#if !MESHTASTIC_EXCLUDE_I2C && HAS_CW2015
-
-class CW2015BatteryLevel : public AnalogBatteryLevel
-{
-  public:
-    /**
-     * Battery state of charge, from 0 to 100 or -1 for unknown
-     */
-    virtual int getBatteryPercent() override
-    {
-        int data = -1;
-        Wire.beginTransmission(CW2015_ADDR);
-        Wire.write(0x04);
-        if (Wire.endTransmission() == 0) {
-            if (Wire.requestFrom(CW2015_ADDR, (uint8_t)1)) {
-                data = Wire.read();
-            }
-        }
-        return data;
-    }
-
-    /**
-     * The raw voltage of the battery in millivolts, or NAN if unknown
-     */
-    virtual uint16_t getBattVoltage() override
-    {
-        uint16_t mv = 0;
-        Wire.beginTransmission(CW2015_ADDR);
-        Wire.write(0x02);
-        if (Wire.endTransmission() == 0) {
-            if (Wire.requestFrom(CW2015_ADDR, (uint8_t)2)) {
-                mv = Wire.read();
-                mv <<= 8;
-                mv |= Wire.read();
-                // Voltage is read in  305uV units, convert to mV
-                mv = mv * 305 / 1000;
-            }
-        }
-        return mv;
-    }
-};
-
-CW2015BatteryLevel cw2015Level;
-
-/**
- * Init the CW2015 battery level sensor
- */
-bool Power::cw2015Init()
-{
-
-    Wire.beginTransmission(CW2015_ADDR);
-    uint8_t getInfo[] = {0x0a, 0x00};
-    Wire.write(getInfo, 2);
-    Wire.endTransmission();
-    delay(10);
-    Wire.beginTransmission(CW2015_ADDR);
-    Wire.write(0x00);
-    bool result = false;
-    if (Wire.endTransmission() == 0) {
-        if (Wire.requestFrom(CW2015_ADDR, (uint8_t)1)) {
-            uint8_t data = Wire.read();
-            LOG_DEBUG("CW2015 init read data: 0x%x", data);
-            if (data == 0x73) {
-                result = true;
-                batteryLevel = &cw2015Level;
-            }
-        }
-    }
-    return result;
-}
-
-#else
-/**
- * The CW2015 battery level sensor is unavailable - default to AnalogBatteryLevel
- */
-bool Power::cw2015Init()
+bool Power::lipoInit()
 {
    return false;
 }
@@ -9,13 +9,13 @@
 */
 #include "PowerFSM.h"
 #include "Default.h"
+#include "Led.h"
 #include "MeshService.h"
 #include "NodeDB.h"
 #include "PowerMon.h"
 #include "configuration.h"
 #include "graphics/Screen.h"
 #include "main.h"
-#include "modules/StatusLEDModule.h"
 #include "sleep.h"
 #include "target_specific.h"

@@ -103,7 +103,7 @@ static void lsIdle()
            uint32_t sleepTime = SLEEP_TIME;

            powerMon->setState(meshtastic_PowerMon_State_CPU_LightSleep);
-            statusLEDModule->setPowerLED(false);
+            ledBlink.set(false); // Never leave led on while in light sleep
            esp_sleep_source_t wakeCause2 = doLightSleep(sleepTime * 1000LL);
            powerMon->clearState(meshtastic_PowerMon_State_CPU_LightSleep);

@@ -111,7 +111,7 @@ static void lsIdle()
            case ESP_SLEEP_WAKEUP_TIMER:
                // Normal case: timer expired, we should just go back to sleep ASAP

-                statusLEDModule->setPowerLED(true);
+                ledBlink.set(true);             // briefly turn on led
                wakeCause2 = doLightSleep(100); // leave led on for 1ms

                secsSlept += sleepTime;
@@ -146,7 +146,7 @@ static void lsIdle()
        }
    } else {
        // Time to stop sleeping!
-        statusLEDModule->setPowerLED(false);
+        ledBlink.set(false);
        LOG_INFO("Reached ls_secs, service loop()");
        powerFSM.trigger(EVENT_WAKE_TIMER);
    }
@@ -227,21 +227,34 @@ void RedirectablePrint::log_to_ble(const char *logLevel, const char *format, va_
        isBleConnected = nrf52Bluetooth != nullptr && nrf52Bluetooth->isConnected();
 #endif
        if (isBleConnected) {
+            char *message;
+            size_t initialLen;
+            size_t len;
+            initialLen = strlen(format);
+            message = new char[initialLen + 1];
+            len = vsnprintf(message, initialLen + 1, format, arg);
+            if (len > initialLen) {
+                delete[] message;
+                message = new char[len + 1];
+                vsnprintf(message, len + 1, format, arg);
+            }
            auto thread = concurrency::OSThread::currentThread;
            meshtastic_LogRecord logRecord = meshtastic_LogRecord_init_zero;
            logRecord.level = getLogLevel(logLevel);
-            vsprintf(logRecord.message, format, arg);
+            strcpy(logRecord.message, message);
            if (thread)
                strcpy(logRecord.source, thread->ThreadName.c_str());
            logRecord.time = getValidTime(RTCQuality::RTCQualityDevice, true);

-            auto buffer = std::unique_ptr<uint8_t[]>(new uint8_t[meshtastic_LogRecord_size]);
-            size_t size = pb_encode_to_bytes(buffer.get(), meshtastic_LogRecord_size, meshtastic_LogRecord_fields, &logRecord);
+            uint8_t *buffer = new uint8_t[meshtastic_LogRecord_size];
+            size_t size = pb_encode_to_bytes(buffer, meshtastic_LogRecord_size, meshtastic_LogRecord_fields, &logRecord);
 #ifdef ARCH_ESP32
-            nimbleBluetooth->sendLog(buffer.get(), size);
+            nimbleBluetooth->sendLog(buffer, size);
 #elif defined(ARCH_NRF52)
-            nrf52Bluetooth->sendLog(buffer.get(), size);
+            nrf52Bluetooth->sendLog(buffer, size);
 #endif
+            delete[] message;
+            delete[] buffer;
        }
    }
 #else
@@ -279,8 +292,8 @@ void RedirectablePrint::log(const char *logLevel, const char *format, ...)

    // append \n to format
    size_t len = strlen(format);
-    auto newFormat = std::unique_ptr<char[]>(new char[len + 2]);
-    strcpy(newFormat.get(), format);
+    char *newFormat = new char[len + 2];
+    strcpy(newFormat, format);
    newFormat[len] = '\n';
    newFormat[len + 1] = '\0';

@@ -297,18 +310,23 @@ void RedirectablePrint::log(const char *logLevel, const char *format, ...)
            va_end(arg);
        }
        if (portduino_config.logoutputlevel < level_trace && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_TRACE) == 0) {
+            delete[] newFormat;
            return;
        }
    }
    if (portduino_config.logoutputlevel < level_debug && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_DEBUG) == 0) {
+        delete[] newFormat;
        return;
    } else if (portduino_config.logoutputlevel < level_info && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_INFO) == 0) {
+        delete[] newFormat;
        return;
    } else if (portduino_config.logoutputlevel < level_warn && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_WARN) == 0) {
+        delete[] newFormat;
        return;
    }
 #endif
    if (moduleConfig.serial.override_console_serial_port && strcmp(logLevel, MESHTASTIC_LOG_LEVEL_DEBUG) == 0) {
+        delete[] newFormat;
        return;
    }

@@ -320,19 +338,11 @@ void RedirectablePrint::log(const char *logLevel, const char *format, ...)
 #endif

        va_list arg;
-        va_list arg_copy;
-
        va_start(arg, format);

-        va_copy(arg_copy, arg);
-        log_to_serial(logLevel, newFormat.get(), arg_copy);
-        va_end(arg_copy);
-
-        va_copy(arg_copy, arg);
-        log_to_syslog(logLevel, newFormat.get(), arg_copy);
-        va_end(arg_copy);
-
-        log_to_ble(logLevel, newFormat.get(), arg);
+        log_to_serial(logLevel, newFormat, arg);
+        log_to_syslog(logLevel, newFormat, arg);
+        log_to_ble(logLevel, newFormat, arg);

        va_end(arg);
 #ifdef HAS_FREE_RTOS
@@ -342,6 +352,7 @@ void RedirectablePrint::log(const char *logLevel, const char *format, ...)
 #endif
    }

+    delete[] newFormat;
    return;
 }

@@ -76,10 +76,8 @@ bool NotifiedWorkerThread::notifyLater(uint32_t delay, uint32_t v, bool overwrit

 void NotifiedWorkerThread::checkNotification()
 {
-    // Atomically read and clear. (This avoids a potential race condition where an interrupt handler could set a new notification
-    // after checkNotification reads but before it clears, which would cause us to miss that notification until the next one comes
-    // in.)
-    auto n = notification.exchange(0); // read+clear atomically: like `n = notification; notification = 0;` but interrupt-safe
+    auto n = notification;
+    notification = 0; // clear notification
    if (n) {
        onNotify(n);
    }
@@ -1,7 +1,6 @@
 #pragma once

 #include "OSThread.h"
-#include <atomic>

 namespace concurrency
 {
@@ -14,7 +13,7 @@ class NotifiedWorkerThread : public OSThread
    /**
     * The notification that was most recently used to wake the thread.  Read from runOnce()
     */
-    std::atomic<uint32_t> notification{0};
+    uint32_t notification = 0;

  public:
    NotifiedWorkerThread(const char *name) : OSThread(name) {}
@@ -217,7 +217,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define SHTC3_ADDR 0x70
 #define LPS22HB_ADDR 0x5C
 #define LPS22HB_ADDR_ALT 0x5D
-#define SFA30_ADDR 0x5D
 #define SHT31_4x_ADDR 0x44
 #define SHT31_4x_ADDR_ALT 0x45
 #define PMSA003I_ADDR 0x12
@@ -234,7 +233,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define NAU7802_ADDR 0x2A
 #define MAX30102_ADDR 0x57
 #define SCD4X_ADDR 0x62
-#define CW2015_ADDR 0x62
 #define MLX90614_ADDR_DEF 0x5A
 #define CGRADSENS_ADDR 0x66
 #define LTR390UV_ADDR 0x53
@@ -243,8 +241,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define BQ27220_ADDR 0x55 // same address as TDECK_KB
 #define BQ25896_ADDR 0x6B
 #define LTR553ALS_ADDR 0x23
-#define SEN5X_ADDR 0x69
-#define SCD30_ADDR 0x61

 // -----------------------------------------------------------------------------
 // ACCELEROMETER
@@ -394,6 +390,9 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #ifndef HAS_RADIO
 #define HAS_RADIO 0
 #endif
+#ifndef HAS_RTC
+#define HAS_RTC 0
+#endif
 #ifndef HAS_CPU_SHUTDOWN
 #define HAS_CPU_SHUTDOWN 0
 #endif
@@ -429,16 +428,12 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define HAS_RGB_LED
 #endif

+#ifndef LED_STATE_OFF
+#define LED_STATE_OFF 0
+#endif
 #ifndef LED_STATE_ON
 #define LED_STATE_ON 1
 #endif
-#ifndef LED_STATE_OFF
-#define LED_STATE_OFF (LED_STATE_ON ^ 1)
-#endif
-
-#ifndef ledOff
-#define ledOff(pin) pinMode(pin, INPUT)
-#endif

 // default mapping of pins
 #if defined(PIN_BUTTON2) && !defined(CANCEL_BUTTON_PIN)
@@ -43,8 +43,8 @@ ScanI2C::FoundDevice ScanI2C::firstAccelerometer() const

 ScanI2C::FoundDevice ScanI2C::firstAQI() const
 {
-    ScanI2C::DeviceType types[] = {PMSA003I, SEN5X, SCD4X, SFA30};
-    return firstOfOrNONE(4, types);
+    ScanI2C::DeviceType types[] = {PMSA003I, SCD4X};
+    return firstOfOrNONE(2, types);
 }

 ScanI2C::FoundDevice ScanI2C::firstRGBLED() const
@@ -88,11 +88,7 @@ class ScanI2C
        BH1750,
        DA217,
        CHSC6X,
-        CST226SE,
-        SEN5X,
-        SFA30,
-        CW2015,
-        SCD30
+        CST226SE
    } DeviceType;

    // typedef uint8_t DeviceAddress;
@@ -1,6 +1,4 @@
 #include "ScanI2CTwoWire.h"
-#include "configuration.h"
-#include "detect/ScanI2C.h"

 #if !MESHTASTIC_EXCLUDE_I2C

@@ -10,7 +8,6 @@
 #endif
 #if !defined(ARCH_PORTDUINO) && !defined(ARCH_STM32WL)
 #include "meshUtils.h" // vformat
-
 #endif

 bool in_array(uint8_t *array, int size, uint8_t lookfor)
@@ -117,64 +114,6 @@ uint16_t ScanI2CTwoWire::getRegisterValue(const ScanI2CTwoWire::RegisterLocation
    return value;
 }

-bool ScanI2CTwoWire::i2cCommandResponseLength(ScanI2C::DeviceAddress addr, uint16_t command, uint8_t expectedLength) const
-{
-    TwoWire *i2cBus = fetchI2CBus(addr);
-    i2cBus->beginTransmission(addr.address);
-    if (command > 0xFF) {
-        i2cBus->write((uint8_t)(command >> 8));
-    }
-    i2cBus->write((uint8_t)(command & 0xFF));
-    if (i2cBus->endTransmission() != 0) {
-        return false;
-    }
-    delay(20);
-    uint8_t received = i2cBus->requestFrom(addr.address, expectedLength);
-    bool match = (received == expectedLength);
-    while (i2cBus->available())
-        i2cBus->read();
-    return match;
-}
-
-/// for SEN5X detection
-// Note, this code needs to be called before setting the I2C bus speed
-// for the screen at high speed. The speed needs to be at 100kHz, otherwise
-// detection will not work
-String readSEN5xProductName(TwoWire *i2cBus, uint8_t address)
-{
-    uint8_t cmd[] = {0xD0, 0x14};
-    uint8_t response[48] = {0};
-
-    i2cBus->beginTransmission(address);
-    i2cBus->write(cmd, 2);
-    if (i2cBus->endTransmission() != 0)
-        return "";
-
-    delay(20);
-    if (i2cBus->requestFrom(address, (uint8_t)48) != 48)
-        return "";
-
-    for (int i = 0; i < 48 && i2cBus->available(); ++i) {
-        response[i] = i2cBus->read();
-    }
-
-    char productName[33] = {0};
-    int j = 0;
-    for (int i = 0; i < 48 && j < 32; i += 3) {
-        if (response[i] >= 32 && response[i] <= 126)
-            productName[j++] = response[i];
-        else
-            break;
-
-        if (response[i + 1] >= 32 && response[i + 1] <= 126)
-            productName[j++] = response[i + 1];
-        else
-            break;
-    }
-
-    return String(productName);
-}
-
 #define SCAN_SIMPLE_CASE(ADDR, T, ...)                                                                                           \
    case ADDR:                                                                                                                   \
        logFoundDevice(__VA_ARGS__);                                                                                             \
@@ -451,7 +390,8 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                if (getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x7E), 2) == 0x5449) {
                    type = OPT3001;
                    logFoundDevice("OPT3001", (uint8_t)addr.address);
-                } else if (i2cCommandResponseLength(addr, 0x89, 6)) { // SHT4x serial number (6 bytes inc. CRC)
+                } else if (getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x89), 6) !=
+                           0) { // unique SHT4x serial number (6 bytes inc. CRC)
                    type = SHT4X;
                    logFoundDevice("SHT4X", (uint8_t)addr.address);
                } else {
@@ -476,19 +416,6 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                break;

            case LPS22HB_ADDR_ALT:
-                // SFA30 detection: send 2-byte command 0xD060 (Get Device Marking) and check for 48-byte response
-                if (i2cCommandResponseLength(addr, 0xD060, 48)) {
-                    type = SFA30;
-                    logFoundDevice("SFA30", (uint8_t)addr.address);
-                    break;
-                }
-                // Fallback: LPS22HB detection at alternate address using WHO_AM_I register (0x0F == 0xB1)
-                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x0F), 1);
-                if (registerValue == 0xB1) {
-                    type = LPS22HB;
-                    logFoundDevice("LPS22HB", (uint8_t)addr.address);
-                }
-                break;
                SCAN_SIMPLE_CASE(LPS22HB_ADDR, LPS22HB, "LPS22HB", (uint8_t)addr.address)
                SCAN_SIMPLE_CASE(QMC6310U_ADDR, QMC6310U, "QMC6310U", (uint8_t)addr.address)

@@ -581,7 +508,6 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                SCAN_SIMPLE_CASE(DFROBOT_RAIN_ADDR, DFROBOT_RAIN, "DFRobot Rain Gauge", (uint8_t)addr.address);
                SCAN_SIMPLE_CASE(LTR390UV_ADDR, LTR390UV, "LTR390UV", (uint8_t)addr.address);
                SCAN_SIMPLE_CASE(PCT2075_ADDR, PCT2075, "PCT2075", (uint8_t)addr.address);
-                SCAN_SIMPLE_CASE(SCD30_ADDR, SCD30, "SCD30", (uint8_t)addr.address);
            case CST328_ADDR:
                // Do we have the CST328 or the CST226SE
                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0xAB), 1);
@@ -615,17 +541,7 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                break;

                SCAN_SIMPLE_CASE(BHI260AP_ADDR, BHI260AP, "BHI260AP", (uint8_t)addr.address);
-            case SCD4X_ADDR: {
-                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x8), 1);
-                if (registerValue == 0x18) {
-                    logFoundDevice("CW2015", (uint8_t)addr.address);
-                    type = CW2015;
-                } else {
-                    logFoundDevice("SCD4X", (uint8_t)addr.address);
-                    type = SCD4X;
-                }
-                break;
-            }
+                SCAN_SIMPLE_CASE(SCD4X_ADDR, SCD4X, "SCD4X", (uint8_t)addr.address);
                SCAN_SIMPLE_CASE(BMM150_ADDR, BMM150, "BMM150", (uint8_t)addr.address);
 #ifdef HAS_TPS65233
                SCAN_SIMPLE_CASE(TPS65233_ADDR, TPS65233, "TPS65233", (uint8_t)addr.address);
@@ -652,9 +568,8 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                }
                break;

-            case ICM20948_ADDR:     // same as BMX160_ADDR and SEN5X_ADDR
+            case ICM20948_ADDR:     // same as BMX160_ADDR
            case ICM20948_ADDR_ALT: // same as MPU6050_ADDR
-                // ICM20948 Register check
                registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x00), 1);
 #ifdef HAS_ICM20948
                type = ICM20948;
@@ -665,31 +580,14 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                    type = ICM20948;
                    logFoundDevice("ICM20948", (uint8_t)addr.address);
                    break;
+                } else if (addr.address == BMX160_ADDR) {
+                    type = BMX160;
+                    logFoundDevice("BMX160", (uint8_t)addr.address);
+                    break;
                } else {
-                    String prod = "";
-                    prod = readSEN5xProductName(i2cBus, addr.address);
-                    if (prod.startsWith("SEN55")) {
-                        type = SEN5X;
-                        logFoundDevice("Sensirion SEN55", addr.address);
-                        break;
-                    } else if (prod.startsWith("SEN54")) {
-                        type = SEN5X;
-                        logFoundDevice("Sensirion SEN54", addr.address);
-                        break;
-                    } else if (prod.startsWith("SEN50")) {
-                        type = SEN5X;
-                        logFoundDevice("Sensirion SEN50", addr.address);
-                        break;
-                    }
-                    if (addr.address == BMX160_ADDR) {
-                        type = BMX160;
-                        logFoundDevice("BMX160", (uint8_t)addr.address);
-                        break;
-                    } else {
-                        type = MPU6050;
-                        logFoundDevice("MPU6050", (uint8_t)addr.address);
-                        break;
-                    }
+                    type = MPU6050;
+                    logFoundDevice("MPU6050", (uint8_t)addr.address);
+                    break;
                }
                break;

@@ -55,8 +55,6 @@ class ScanI2CTwoWire : public ScanI2C

    uint16_t getRegisterValue(const RegisterLocation &, ResponseWidth, bool) const;

-    bool i2cCommandResponseLength(DeviceAddress addr, uint16_t command, uint8_t expectedLength) const;
-
    DeviceType probeOLED(ScanI2C::DeviceAddress) const;

    static void logFoundDevice(const char *device, uint8_t address);
@@ -1,31 +0,0 @@
-#include "reClockI2C.h"
-#include "ScanI2CTwoWire.h"
-
-uint32_t reClockI2C(uint32_t desiredClock, TwoWire *i2cBus, bool force)
-{
-
-    uint32_t currentClock = 0;
-
-    /* See https://github.com/arduino/Arduino/issues/11457
-      Currently, only ESP32 can getClock()
-      While all cores can setClock()
-      https://github.com/sandeepmistry/arduino-nRF5/blob/master/libraries/Wire/Wire.h#L50
-      https://github.com/earlephilhower/arduino-pico/blob/master/libraries/Wire/src/Wire.h#L60
-      https://github.com/stm32duino/Arduino_Core_STM32/blob/main/libraries/Wire/src/Wire.h#L103
-      For cases when I2C speed is different to the ones defined by sensors (see defines in sensor classes)
-      we need to reclock I2C and set it back to the previous desired speed.
-      Only for cases where we can know OR predefine the speed, we can do this.
-    */
-
-// TODO add getClock function or return a predefined clock speed per variant?
-#ifdef CAN_RECLOCK_I2C
-    currentClock = i2cBus->getClock();
-#endif
-
-    if ((currentClock != desiredClock) || force) {
-        LOG_DEBUG("Changing I2C clock to %u", desiredClock);
-        i2cBus->setClock(desiredClock);
-    }
-
-    return currentClock;
-}
@@ -1,11 +1,41 @@
-
-#ifndef RECLOCK_I2C_
-#define RECLOCK_I2C_
-
+#ifdef CAN_RECLOCK_I2C
 #include "ScanI2CTwoWire.h"
-#include <Wire.h>
-#include <stdint.h>

-uint32_t reClockI2C(uint32_t desiredClock, TwoWire *i2cBus, bool force);
+uint32_t reClockI2C(uint32_t desiredClock, TwoWire *i2cBus)
+{

+    uint32_t currentClock;
+
+    /* See https://github.com/arduino/Arduino/issues/11457
+      Currently, only ESP32 can getClock()
+      While all cores can setClock()
+      https://github.com/sandeepmistry/arduino-nRF5/blob/master/libraries/Wire/Wire.h#L50
+      https://github.com/earlephilhower/arduino-pico/blob/master/libraries/Wire/src/Wire.h#L60
+      https://github.com/stm32duino/Arduino_Core_STM32/blob/main/libraries/Wire/src/Wire.h#L103
+      For cases when I2C speed is different to the ones defined by sensors (see defines in sensor classes)
+      we need to reclock I2C and set it back to the previous desired speed.
+      Only for cases where we can know OR predefine the speed, we can do this.
+    */
+
+#ifdef ARCH_ESP32
+    currentClock = i2cBus->getClock();
+#elif defined(ARCH_NRF52)
+    // TODO add getClock function or return a predefined clock speed per variant?
+    return 0;
+#elif defined(ARCH_RP2040)
+    // TODO add getClock function or return a predefined clock speed per variant
+    return 0;
+#elif defined(ARCH_STM32WL)
+    // TODO add getClock function or return a predefined clock speed per variant
+    return 0;
+#else
+    return 0;
+#endif
+
+    if (currentClock != desiredClock) {
+        LOG_DEBUG("Changing I2C clock to %u", desiredClock);
+        i2cBus->setClock(desiredClock);
+    }
+    return currentClock;
+}
 #endif
@@ -52,7 +52,7 @@ SerialUART *GPS::_serial_gps = &GPS_SERIAL_PORT;
 HardwareSerial *GPS::_serial_gps = nullptr;
 #endif

-std::unique_ptr<GPS> gps = nullptr;
+GPS *gps = nullptr;

 static GPSUpdateScheduling scheduling;

@@ -127,7 +127,7 @@ static int32_t gpsSwitch()
    return 1000;
 }

-static std::unique_ptr<concurrency::Periodic> gpsPeriodic;
+static concurrency::Periodic *gpsPeriodic;
 #endif

 static void UBXChecksum(uint8_t *message, size_t length)
@@ -1485,7 +1485,7 @@ GnssModel_t GPS::getProbeResponse(unsigned long timeout, const std::vector<ChipI
    if (bufferSize > 2048)
        bufferSize = 2048;

-    auto response = std::unique_ptr<char[]>(new char[bufferSize]); // Dynamically allocate based on baud rate
+    char *response = new char[bufferSize](); // Dynamically allocate based on baud rate
    uint16_t responseLen = 0;
    unsigned long start = millis();
    while (millis() - start < timeout) {
@@ -1501,18 +1501,19 @@ GnssModel_t GPS::getProbeResponse(unsigned long timeout, const std::vector<ChipI
            if (c == ',' || (responseLen >= 2 && response[responseLen - 2] == '\r' && response[responseLen - 1] == '\n')) {
                // check if we can see our chips
                for (const auto &chipInfo : responseMap) {
-                    if (strstr(response.get(), chipInfo.detectionString.c_str()) != nullptr) {
+                    if (strstr(response, chipInfo.detectionString.c_str()) != nullptr) {
 #ifdef GPS_DEBUG
-                        LOG_DEBUG(response.get());
+                        LOG_DEBUG(response);
 #endif
                        LOG_INFO("%s detected", chipInfo.chipName.c_str());
+                        delete[] response; // Cleanup before return
                        return chipInfo.driver;
                    }
                }
            }
            if (responseLen >= 2 && response[responseLen - 2] == '\r' && response[responseLen - 1] == '\n') {
 #ifdef GPS_DEBUG
-                LOG_DEBUG(response.get());
+                LOG_DEBUG(response);
 #endif
                // Reset the response buffer for the next potential message
                responseLen = 0;
@@ -1521,12 +1522,13 @@ GnssModel_t GPS::getProbeResponse(unsigned long timeout, const std::vector<ChipI
        }
    }
 #ifdef GPS_DEBUG
-    LOG_DEBUG(response.get());
+    LOG_DEBUG(response);
 #endif
+    delete[] response;         // Cleanup before return
    return GNSS_MODEL_UNKNOWN; // Return unknown on timeout
 }

-std::unique_ptr<GPS> GPS::createGps()
+GPS *GPS::createGps()
 {
    int8_t _rx_gpio = config.position.rx_gpio;
    int8_t _tx_gpio = config.position.tx_gpio;
@@ -1551,7 +1553,7 @@ std::unique_ptr<GPS> GPS::createGps()
    if (!_rx_gpio || !_serial_gps) // Configured to have no GPS at all
        return nullptr;

-    auto new_gps = std::unique_ptr<GPS>(new GPS());
+    GPS *new_gps = new GPS;
    new_gps->rx_gpio = _rx_gpio;
    new_gps->tx_gpio = _tx_gpio;

@@ -1579,7 +1581,7 @@ std::unique_ptr<GPS> GPS::createGps()
 #ifdef PIN_GPS_SWITCH
    // toggle GPS via external GPIO switch
    pinMode(PIN_GPS_SWITCH, INPUT);
-    gpsPeriodic = std::unique_ptr<concurrency::Periodic>(new concurrency::Periodic("GPSSwitch", gpsSwitch));
+    gpsPeriodic = new concurrency::Periodic("GPSSwitch", gpsSwitch);
 #endif

 // Currently disabled per issue #525 (TinyGPS++ crash bug)
@@ -2,8 +2,6 @@
 #include "configuration.h"
 #if !MESHTASTIC_EXCLUDE_GPS

-#include <memory>
-
 #include "GPSStatus.h"
 #include "GpioLogic.h"
 #include "Observer.h"
@@ -120,7 +118,7 @@ class GPS : private concurrency::OSThread

    // Creates an instance of the GPS class.
    // Returns the new instance or null if the GPS is not present.
-    static std::unique_ptr<GPS> createGps();
+    static GPS *createGps();

    // Wake the GPS hardware - ready for an update
    void up();
@@ -258,5 +256,5 @@ class GPS : private concurrency::OSThread
    uint8_t fixeddelayCtr = 0;
 };

-extern std::unique_ptr<GPS> gps;
+extern GPS *gps;
 #endif // Exclude GPS
@@ -72,13 +72,11 @@ RTCSetResult readFromRTC()
 #elif defined(PCF8563_RTC) || defined(PCF85063_RTC)
 #if defined(PCF8563_RTC)
    if (rtc_found.address == PCF8563_RTC) {
-        SensorPCF8563 rtc;
 #elif defined(PCF85063_RTC)
    if (rtc_found.address == PCF85063_RTC) {
-        SensorPCF85063 rtc;
-
 #endif
        uint32_t now = millis();
+        SensorRtcHelper rtc;

 #if WIRE_INTERFACES_COUNT == 2
        rtc.begin(rtc_found.port == ScanI2C::I2CPort::WIRE1 ? Wire1 : Wire);
@@ -242,12 +240,10 @@ RTCSetResult perhapsSetRTC(RTCQuality q, const struct timeval *tv, bool forceUpd
 #elif defined(PCF8563_RTC) || defined(PCF85063_RTC)
 #if defined(PCF8563_RTC)
        if (rtc_found.address == PCF8563_RTC) {
-            SensorPCF8563 rtc;
 #elif defined(PCF85063_RTC)
        if (rtc_found.address == PCF85063_RTC) {
-            SensorPCF85063 rtc;
-
 #endif
+            SensorRtcHelper rtc;

 #if WIRE_INTERFACES_COUNT == 2
            rtc.begin(rtc_found.port == ScanI2C::I2CPort::WIRE1 ? Wire1 : Wire);
@@ -280,7 +276,11 @@ RTCSetResult perhapsSetRTC(RTCQuality q, const struct timeval *tv, bool forceUpd
        settimeofday(tv, NULL);
 #endif

+        // nrf52 doesn't have a readable RTC (yet - software not written)
+#if HAS_RTC
        readFromRTC();
+#endif
+
        return RTCSetResultSuccess;
    } else {
        return RTCSetResultNotSet; // RTC was already set with a higher quality time
@@ -312,7 +312,7 @@ const char *RtcName(RTCQuality quality)
 * @param t The time to potentially set the RTC to.
 * @return True if the RTC was set to the provided time, false otherwise.
 */
-RTCSetResult perhapsSetRTC(RTCQuality q, const struct tm &t)
+RTCSetResult perhapsSetRTC(RTCQuality q, struct tm &t)
 {
    /* Convert to unix time
    The Unix epoch (or Unix time or POSIX time or Unix timestamp) is the number of seconds that have elapsed since January 1, 1970
@@ -41,7 +41,7 @@ extern uint32_t lastSetFromPhoneNtpOrGps;

 /// If we haven't yet set our RTC this boot, set it from a GPS derived time
 RTCSetResult perhapsSetRTC(RTCQuality q, const struct timeval *tv, bool forceUpdate = false);
-RTCSetResult perhapsSetRTC(RTCQuality q, const struct tm &t);
+RTCSetResult perhapsSetRTC(RTCQuality q, struct tm &t);

 /// Return a string name for the quality
 const char *RtcName(RTCQuality quality);
@@ -10,7 +10,7 @@ EInkDynamicDisplay::EInkDynamicDisplay(uint8_t address, int sda, int scl, OLEDDI
 {
    // If tracking ghost pixels, grab memory
 #ifdef EINK_LIMIT_GHOSTING_PX
-    dirtyPixels = std::unique_ptr<uint8_t[]>(new uint8_t[EInkDisplay::displayBufferSize]()); // Init with zeros
+    dirtyPixels = new uint8_t[EInkDisplay::displayBufferSize](); // Init with zeros
 #endif
 }

@@ -19,7 +19,7 @@ EInkDynamicDisplay::~EInkDynamicDisplay()
 {
    // If we were tracking ghost pixels, free the memory
 #ifdef EINK_LIMIT_GHOSTING_PX
-    dirtyPixels = nullptr;
+    delete[] dirtyPixels;
 #endif
 }

@@ -454,7 +454,7 @@ void EInkDynamicDisplay::checkExcessiveGhosting()
 void EInkDynamicDisplay::resetGhostPixelTracking()
 {
    // Copy the current frame into dirtyPixels[] from the display buffer
-    memcpy(dirtyPixels.get(), EInkDisplay::buffer, EInkDisplay::displayBufferSize);
+    memcpy(dirtyPixels, EInkDisplay::buffer, EInkDisplay::displayBufferSize);
 }
 #endif // EINK_LIMIT_GHOSTING_PX

@@ -1,7 +1,6 @@
 #pragma once

 #include "configuration.h"
-#include <memory>

 #if defined(USE_EINK) && defined(USE_EINK_DYNAMICDISPLAY)

@@ -117,11 +116,11 @@ class EInkDynamicDisplay : public EInkDisplay, protected concurrency::NotifiedWo
    // Optional - track ghosting, pixel by pixel
    // May 2024: no longer used by any display. Kept for possible future use.
 #ifdef EINK_LIMIT_GHOSTING_PX
-    void countGhostPixels();                // Count any pixels which have moved from black to white since last full-refresh
-    void checkExcessiveGhosting();          // Check if ghosting exceeds defined limit
-    void resetGhostPixelTracking();         // Clear the dirty pixels array. Call when full-refresh cleans the display.
-    std::unique_ptr<uint8_t[]> dirtyPixels; // Any pixels that have been black since last full-refresh (dynamically allocated mem)
-    uint32_t ghostPixelCount = 0;           // Number of pixels with problematic ghosting. Retained here for LOG_DEBUG use
+    void countGhostPixels();        // Count any pixels which have moved from black to white since last full-refresh
+    void checkExcessiveGhosting();  // Check if ghosting exceeds defined limit
+    void resetGhostPixelTracking(); // Clear the dirty pixels array. Call when full-refresh cleans the display.
+    uint8_t *dirtyPixels;           // Any pixels that have been black since last full-refresh (dynamically allocated mem)
+    uint32_t ghostPixelCount = 0;   // Number of pixels with problematic ghosting. Retained here for LOG_DEBUG use
 #endif

    // Conditional - async full refresh - only with modified meshtastic/GxEPD2
@@ -0,0 +1,4 @@
+#ifdef HAS_NEOPIXEL
+#include <Adafruit_NeoPixel.h>
+extern Adafruit_NeoPixel pixels;
+#endif
@@ -1,6 +1,4 @@
 #ifdef HAS_LP5562
-#include <Wire.h>
-
 #include <LP5562.h>
 extern LP5562 rgbw;

@@ -0,0 +1,5 @@
+#ifdef HAS_NCP5623
+#include <NCP5623.h>
+extern NCP5623 rgb;
+
+#endif
@@ -221,6 +221,7 @@ void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *ti

    if (rtc_sec > 0) {
        // === Build Time String ===
+        long hms = (rtc_sec % SEC_PER_DAY + SEC_PER_DAY) % SEC_PER_DAY;
        int hour, minute, second;
        graphics::decomposeTime(rtc_sec, hour, minute, second);
        snprintf(timeStr, sizeof(timeStr), "%d:%02d", hour, minute);
@@ -427,33 +428,39 @@ const int *getTextPositions(OLEDDisplay *display)
 // *************************
 void drawCommonFooter(OLEDDisplay *display, int16_t x, int16_t y)
 {
-    if (!isAPIConnected(service->api_state))
-        return;
+    bool drawConnectionState = false;
+    if (service->api_state == service->STATE_BLE || service->api_state == service->STATE_WIFI ||
+        service->api_state == service->STATE_SERIAL || service->api_state == service->STATE_PACKET ||
+        service->api_state == service->STATE_HTTP || service->api_state == service->STATE_ETH) {
+        drawConnectionState = true;
+    }

-    const int scale = (currentResolution == ScreenResolution::High) ? 2 : 1;
-    display->setColor(BLACK);
-    display->fillRect(0, SCREEN_HEIGHT - (1 * scale) - (connection_icon_height * scale), (connection_icon_width * scale),
-                      (connection_icon_height * scale) + (2 * scale));
-    display->setColor(WHITE);
-    if (currentResolution == ScreenResolution::High) {
-        const int bytesPerRow = (connection_icon_width + 7) / 8;
-        int iconX = 0;
-        int iconY = SCREEN_HEIGHT - (connection_icon_height * 2);
+    if (drawConnectionState) {
+        const int scale = (currentResolution == ScreenResolution::High) ? 2 : 1;
+        display->setColor(BLACK);
+        display->fillRect(0, SCREEN_HEIGHT - (1 * scale) - (connection_icon_height * scale), (connection_icon_width * scale),
+                          (connection_icon_height * scale) + (2 * scale));
+        display->setColor(WHITE);
+        if (currentResolution == ScreenResolution::High) {
+            const int bytesPerRow = (connection_icon_width + 7) / 8;
+            int iconX = 0;
+            int iconY = SCREEN_HEIGHT - (connection_icon_height * 2);

-        for (int yy = 0; yy < connection_icon_height; ++yy) {
-            const uint8_t *rowPtr = connection_icon + yy * bytesPerRow;
-            for (int xx = 0; xx < connection_icon_width; ++xx) {
-                const uint8_t byteVal = pgm_read_byte(rowPtr + (xx >> 3));
-                const uint8_t bitMask = 1U << (xx & 7); // XBM is LSB-first
-                if (byteVal & bitMask) {
-                    display->fillRect(iconX + xx * scale, iconY + yy * scale, scale, scale);
+            for (int yy = 0; yy < connection_icon_height; ++yy) {
+                const uint8_t *rowPtr = connection_icon + yy * bytesPerRow;
+                for (int xx = 0; xx < connection_icon_width; ++xx) {
+                    const uint8_t byteVal = pgm_read_byte(rowPtr + (xx >> 3));
+                    const uint8_t bitMask = 1U << (xx & 7); // XBM is LSB-first
+                    if (byteVal & bitMask) {
+                        display->fillRect(iconX + xx * scale, iconY + yy * scale, scale, scale);
+                    }
                }
            }
-        }

-    } else {
-        display->drawXbm(0, SCREEN_HEIGHT - connection_icon_height, connection_icon_width, connection_icon_height,
-                         connection_icon);
+        } else {
+            display->drawXbm(0, SCREEN_HEIGHT - connection_icon_height, connection_icon_width, connection_icon_height,
+                             connection_icon);
+        }
    }
 }

@@ -63,18 +63,4 @@ bool isAllowedPunctuation(char c);

 std::string sanitizeString(const std::string &input);

-static inline bool isAPIConnected(uint8_t state)
-{
-    static constexpr bool connectedStates[] = {
-        /* STATE_NONE    */ false,
-        /* STATE_BLE     */ true,
-        /* STATE_WIFI    */ true,
-        /* STATE_SERIAL  */ true,
-        /* STATE_PACKET  */ true,
-        /* STATE_HTTP    */ true,
-        /* STATE_ETH     */ true,
-    };
-    return state < sizeof(connectedStates) ? connectedStates[state] : false;
-}
-
 } // namespace graphics
@@ -110,14 +110,14 @@ void getUptimeStr(uint32_t uptimeMillis, const char *prefix, char *uptimeStr, ui
    uint32_t secs = (uptimeMillis % 60000) / 1000;

    if (days) {
-        snprintf(uptimeStr, maxLength, "%s%ud %uh", prefix, days, hours);
+        snprintf(uptimeStr, maxLength, "%s: %ud %uh", prefix, days, hours);
    } else if (hours) {
-        snprintf(uptimeStr, maxLength, "%s%uh %um", prefix, hours, mins);
+        snprintf(uptimeStr, maxLength, "%s: %uh %um", prefix, hours, mins);
    } else if (!includeSecs) {
-        snprintf(uptimeStr, maxLength, "%s%um", prefix, mins);
+        snprintf(uptimeStr, maxLength, "%s: %um", prefix, mins);
    } else if (mins) {
-        snprintf(uptimeStr, maxLength, "%s%um %us", prefix, mins, secs);
+        snprintf(uptimeStr, maxLength, "%s: %um %us", prefix, mins, secs);
    } else {
-        snprintf(uptimeStr, maxLength, "%s%us", prefix, secs);
+        snprintf(uptimeStr, maxLength, "%s: %us", prefix, secs);
    }
-}
+}
@@ -429,10 +429,6 @@ void VirtualKeyboard::drawKey(OLEDDisplay *display, const VirtualKey &key, bool
            c = c - 'a' + 'A';
        }
        keyText = (key.character == ' ' || key.character == '_') ? "_" : std::string(1, c);
-        // Show the common "/" pairing next to "?" like on a real keyboard
-        if (key.type == VK_CHAR && key.character == '?') {
-            keyText = "?/";
-        }
    }

    int textWidth = display->getStringWidth(keyText.c_str());
@@ -522,13 +518,9 @@ char VirtualKeyboard::getCharForKey(const VirtualKey &key, bool isLongPress)

    char c = key.character;

-    // Long-press: letters become uppercase; for "?" provide "/" like a typical keyboard
-    if (isLongPress) {
-        if (c >= 'a' && c <= 'z') {
-            c = (char)(c - 'a' + 'A');
-        } else if (c == '?') {
-            c = '/';
-        }
+    // Long-press: only keep letter lowercase->uppercase conversion; remove other symbol mappings
+    if (isLongPress && c >= 'a' && c <= 'z') {
+        c = (char)(c - 'a' + 'A');
    }

    return c;
@@ -663,7 +663,7 @@ void drawSystemScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x

    if (SCREEN_HEIGHT > 64 || (SCREEN_HEIGHT <= 64 && line <= 5)) { // Only show uptime if the screen can show it
        char uptimeStr[32] = "";
-        getUptimeStr(millis(), "Up: ", uptimeStr, sizeof(uptimeStr));
+        getUptimeStr(millis(), "Up", uptimeStr, sizeof(uptimeStr));
        textWidth = display->getStringWidth(uptimeStr);
        nameX = (SCREEN_WIDTH - textWidth) / 2;
        display->drawString(nameX, getTextPositions(display)[line++], uptimeStr);
@@ -58,7 +58,7 @@ BannerOverlayOptions createStaticBannerOptions(const char *message, const MenuOp

 } // namespace

-menuHandler::screenMenus menuHandler::menuQueue = MenuNone;
+menuHandler::screenMenus menuHandler::menuQueue = menu_none;
 uint32_t menuHandler::pickedNodeNum = 0;
 bool test_enabled = false;
 uint8_t test_count = 0;
@@ -66,7 +66,7 @@ uint8_t test_count = 0;
 void menuHandler::loraMenu()
 {
    static const char *optionsArray[] = {"Back", "Device Role", "Radio Preset", "Frequency Slot", "LoRa Region"};
-    enum optionsNumbers { Back = 0, DeviceRolePicker = 1, RadioPresetPicker = 2, FrequencySlot = 3, LoraPicker = 4 };
+    enum optionsNumbers { Back = 0, device_role_picker = 1, radio_preset_picker = 2, frequency_slot = 3, lora_picker = 4 };
    BannerOverlayOptions bannerOptions;
    bannerOptions.message = "LoRa Actions";
    bannerOptions.optionsArrayPtr = optionsArray;
@@ -74,14 +74,14 @@ void menuHandler::loraMenu()
    bannerOptions.bannerCallback = [](int selected) -> void {
        if (selected == Back) {
            // No action
-        } else if (selected == DeviceRolePicker) {
-            menuHandler::menuQueue = menuHandler::DeviceRolePicker;
-        } else if (selected == RadioPresetPicker) {
-            menuHandler::menuQueue = menuHandler::RadioPresetPicker;
-        } else if (selected == FrequencySlot) {
-            menuHandler::menuQueue = menuHandler::FrequencySlot;
-        } else if (selected == LoraPicker) {
-            menuHandler::menuQueue = menuHandler::LoraPicker;
+        } else if (selected == device_role_picker) {
+            menuHandler::menuQueue = menuHandler::device_role_picker;
+        } else if (selected == radio_preset_picker) {
+            menuHandler::menuQueue = menuHandler::radio_preset_picker;
+        } else if (selected == frequency_slot) {
+            menuHandler::menuQueue = menuHandler::frequency_slot;
+        } else if (selected == lora_picker) {
+            menuHandler::menuQueue = menuHandler::lora_picker;
        }
    };
    screen->showOverlayBanner(bannerOptions);
@@ -102,7 +102,7 @@ void menuHandler::OnboardMessage()
    bannerOptions.optionsArrayPtr = optionsArray;
    bannerOptions.optionsCount = 2;
    bannerOptions.bannerCallback = [](int selected) -> void {
-        menuHandler::menuQueue = menuHandler::NoTimeoutLoraPicker;
+        menuHandler::menuQueue = menuHandler::no_timeout_lora_picker;
        screen->runNow();
    };
    screen->showOverlayBanner(bannerOptions);
@@ -216,7 +216,7 @@ void menuHandler::LoraRegionPicker(uint32_t duration)
    screen->showOverlayBanner(bannerOptions);
 }

-void menuHandler::deviceRolePicker()
+void menuHandler::DeviceRolePicker()
 {
    static const char *optionsArray[] = {"Back", "Client", "Client Mute", "Lost and Found", "Tracker"};
    enum optionsNumbers {
@@ -232,7 +232,7 @@ void menuHandler::deviceRolePicker()
    bannerOptions.optionsCount = 5;
    bannerOptions.bannerCallback = [](int selected) -> void {
        if (selected == Back) {
-            menuHandler::menuQueue = menuHandler::LoraMenu;
+            menuHandler::menuQueue = menuHandler::lora_Menu;
            screen->runNow();
            return;
        } else if (selected == devicerole_client) {
@@ -300,7 +300,7 @@ void menuHandler::FrequencySlotPicker()

    bannerOptions.bannerCallback = [](int selected) -> void {
        if (selected == Back) {
-            menuHandler::menuQueue = menuHandler::LoraMenu;
+            menuHandler::menuQueue = menuHandler::lora_Menu;
            screen->runNow();
            return;
        }
@@ -313,7 +313,7 @@ void menuHandler::FrequencySlotPicker()
    screen->showOverlayBanner(bannerOptions);
 }

-void menuHandler::radioPresetPicker()
+void menuHandler::RadioPresetPicker()
 {
    static const RadioPresetOption presetOptions[] = {
        {"Back", OptionsAction::Back},
@@ -333,7 +333,7 @@ void menuHandler::radioPresetPicker()
    auto bannerOptions =
        createStaticBannerOptions("Radio Preset", presetOptions, presetLabels, [](const RadioPresetOption &option, int) -> void {
            if (option.action == OptionsAction::Back) {
-                menuHandler::menuQueue = menuHandler::LoraMenu;
+                menuHandler::menuQueue = menuHandler::lora_Menu;
                screen->runNow();
                return;
            }
@@ -352,7 +352,7 @@ void menuHandler::radioPresetPicker()
    screen->showOverlayBanner(bannerOptions);
 }

-void menuHandler::twelveHourPicker()
+void menuHandler::TwelveHourPicker()
 {
    static const char *optionsArray[] = {"Back", "12-hour", "24-hour"};
    enum optionsNumbers { Back = 0, twelve = 1, twentyfour = 2 };
@@ -362,7 +362,7 @@ void menuHandler::twelveHourPicker()
    bannerOptions.optionsCount = 3;
    bannerOptions.bannerCallback = [](int selected) -> void {
        if (selected == Back) {
-            menuHandler::menuQueue = menuHandler::ClockMenu;
+            menuHandler::menuQueue = menuHandler::clock_menu;
            screen->runNow();
        } else if (selected == twelve) {
            config.display.use_12h_clock = true;
@@ -390,7 +390,7 @@ void menuHandler::showConfirmationBanner(const char *message, std::function<void
    screen->showOverlayBanner(confirmBanner);
 }

-void menuHandler::clockFacePicker()
+void menuHandler::ClockFacePicker()
 {
    static const ClockFaceOption clockFaceOptions[] = {
        {"Back", OptionsAction::Back},
@@ -404,7 +404,7 @@ void menuHandler::clockFacePicker()
    auto bannerOptions = createStaticBannerOptions("Which Face?", clockFaceOptions, clockFaceLabels,
                                                   [](const ClockFaceOption &option, int) -> void {
                                                       if (option.action == OptionsAction::Back) {
-                                                           menuHandler::menuQueue = menuHandler::ClockMenu;
+                                                           menuHandler::menuQueue = menuHandler::clock_menu;
                                                           screen->runNow();
                                                           return;
                                                       }
@@ -456,7 +456,7 @@ void menuHandler::TZPicker()
    auto bannerOptions = createStaticBannerOptions(
        "Pick Timezone", timezoneOptions, timezoneLabels, [](const TimezoneOption &option, int) -> void {
            if (option.action == OptionsAction::Back) {
-                menuHandler::menuQueue = menuHandler::ClockMenu;
+                menuHandler::menuQueue = menuHandler::clock_menu;
                screen->runNow();
                return;
            }
@@ -503,13 +503,13 @@ void menuHandler::clockMenu()
    bannerOptions.optionsCount = 4;
    bannerOptions.bannerCallback = [](int selected) -> void {
        if (selected == Clock) {
-            menuHandler::menuQueue = menuHandler::ClockFacePicker;
+            menuHandler::menuQueue = menuHandler::clock_face_picker;
            screen->runNow();
        } else if (selected == Time) {
-            menuHandler::menuQueue = menuHandler::TwelveHourPicker;
+            menuHandler::menuQueue = menuHandler::twelve_hour_picker;
            screen->runNow();
        } else if (selected == Timezone) {
-            menuHandler::menuQueue = menuHandler::TzPicker;
+            menuHandler::menuQueue = menuHandler::TZ_picker;
            screen->runNow();
        }
    };
@@ -539,7 +539,7 @@ void menuHandler::messageResponseMenu()
    // If viewing ALL chats, hide “Mute Chat”
    if (mode != graphics::MessageRenderer::ThreadMode::ALL && mode != graphics::MessageRenderer::ThreadMode::DIRECT) {
        const uint8_t chIndex = (threadChannel != 0) ? (uint8_t)threadChannel : channels.getPrimaryIndex();
-        const auto &chan = channels.getByIndex(chIndex);
+        auto &chan = channels.getByIndex(chIndex);

        optionsArray[options] = chan.settings.module_settings.is_muted ? "Unmute Channel" : "Mute Channel";
        optionsEnumArray[options++] = MuteChannel;
@@ -572,12 +572,12 @@ void menuHandler::messageResponseMenu()
        LOG_DEBUG("[ReplyCtx] mode=%d ch=%d peer=0x%08x", (int)mode, ch, (unsigned int)peer);

        if (selected == ViewMode) {
-            menuHandler::menuQueue = menuHandler::MessageViewModeMenu;
+            menuHandler::menuQueue = menuHandler::message_viewmode_menu;
            screen->runNow();

            // Reply submenu
        } else if (selected == ReplyMenu) {
-            menuHandler::menuQueue = menuHandler::ReplyMenu;
+            menuHandler::menuQueue = menuHandler::reply_menu;
            screen->runNow();

        } else if (selected == MuteChannel) {
@@ -589,7 +589,7 @@ void menuHandler::messageResponseMenu()
            }

        } else if (selected == DeleteMenu) {
-            menuHandler::menuQueue = menuHandler::DeleteMessagesMenu;
+            menuHandler::menuQueue = menuHandler::delete_messages_menu;
            screen->runNow();

 #ifdef HAS_I2S
@@ -649,7 +649,7 @@ void menuHandler::replyMenu()
        uint32_t peer = graphics::MessageRenderer::getThreadPeer();

        if (selected == Back) {
-            menuHandler::menuQueue = menuHandler::MessageResponseMenu;
+            menuHandler::menuQueue = menuHandler::message_response_menu;
            screen->runNow();
            return;
        }
@@ -737,7 +737,7 @@ void menuHandler::deleteMessagesMenu()
        uint32_t peer = graphics::MessageRenderer::getThreadPeer();

        if (selected == Back) {
-            menuHandler::menuQueue = menuHandler::MessageResponseMenu;
+            menuHandler::menuQueue = menuHandler::message_response_menu;
            screen->runNow();
            return;
        }
@@ -831,7 +831,7 @@ void menuHandler::messageViewModeMenu()
    // Gather unique peers
    auto dms = messageStore.getDirectMessages();
    std::vector<uint32_t> uniquePeers;
-    for (const auto &m : dms) {
+    for (auto &m : dms) {
        uint32_t peer = (m.sender == nodeDB->getNodeNum()) ? m.dest : m.sender;
        if (peer != nodeDB->getNodeNum() && std::find(uniquePeers.begin(), uniquePeers.end(), peer) == uniquePeers.end())
            uniquePeers.push_back(peer);
@@ -901,7 +901,7 @@ void menuHandler::messageViewModeMenu()
    bannerOptions.bannerCallback = [=](int selected) -> void {
        LOG_DEBUG("messageViewModeMenu: selected=%d", selected);
        if (selected == -1) {
-            menuHandler::menuQueue = menuHandler::MessageResponseMenu;
+            menuHandler::menuQueue = menuHandler::message_response_menu;
            screen->runNow();
        } else if (selected == -2) {
            graphics::MessageRenderer::setThreadMode(graphics::MessageRenderer::ThreadMode::ALL);
@@ -1083,23 +1083,23 @@ void menuHandler::systemBaseMenu()
    bannerOptions.optionsEnumPtr = optionsEnumArray;
    bannerOptions.bannerCallback = [](int selected) -> void {
        if (selected == Notifications) {
-            menuHandler::menuQueue = menuHandler::BuzzerModeMenuPicker;
+            menuHandler::menuQueue = menuHandler::buzzermodemenupicker;
            screen->runNow();
        } else if (selected == ScreenOptions) {
-            menuHandler::menuQueue = menuHandler::ScreenOptionsMenu;
+            menuHandler::menuQueue = menuHandler::screen_options_menu;
            screen->runNow();
        } else if (selected == PowerMenu) {
-            menuHandler::menuQueue = menuHandler::PowerMenu;
+            menuHandler::menuQueue = menuHandler::power_menu;
            screen->runNow();
        } else if (selected == Test) {
-            menuHandler::menuQueue = menuHandler::TestMenu;
+            menuHandler::menuQueue = menuHandler::test_menu;
            screen->runNow();
        } else if (selected == Bluetooth) {
-            menuQueue = BluetoothToggleMenu;
+            menuQueue = bluetooth_toggle_menu;
            screen->runNow();
 #if HAS_WIFI && !defined(ARCH_PORTDUINO)
        } else if (selected == WiFiToggle) {
-            menuQueue = WifiToggleMenu;
+            menuQueue = wifi_toggle_menu;
            screen->runNow();
 #endif
        } else if (selected == Back && !test_enabled) {
@@ -1177,7 +1177,7 @@ void menuHandler::favoriteBaseMenu()
            evt.action = UIFrameEvent::Action::SWITCH_TO_TEXTMESSAGE;
            screen->handleUIFrameEvent(&evt);
        } else if (selected == Remove) {
-            menuHandler::menuQueue = menuHandler::RemoveFavorite;
+            menuHandler::menuQueue = menuHandler::remove_favorite;
            screen->runNow();
        } else if (selected == TraceRoute) {
            if (traceRouteModule) {
@@ -1238,15 +1238,15 @@ void menuHandler::positionBaseMenu()
        auto action = static_cast<PositionAction>(option.value);
        switch (action) {
        case PositionAction::GpsToggle:
-            menuQueue = GpsToggleMenu;
+            menuQueue = gps_toggle_menu;
            screen->runNow();
            break;
        case PositionAction::GpsFormat:
-            menuQueue = GpsFormatMenu;
+            menuQueue = gps_format_menu;
            screen->runNow();
            break;
        case PositionAction::CompassMenu:
-            menuQueue = CompassPointNorthMenu;
+            menuQueue = compass_point_north_menu;
            screen->runNow();
            break;
        case PositionAction::CompassCalibrate:
@@ -1255,15 +1255,15 @@ void menuHandler::positionBaseMenu()
            }
            break;
        case PositionAction::GPSSmartPosition:
-            menuQueue = GpsSmartPositionMenu;
+            menuQueue = gps_smart_position_menu;
            screen->runNow();
            break;
        case PositionAction::GPSUpdateInterval:
-            menuQueue = GpsUpdateIntervalMenu;
+            menuQueue = gps_update_interval_menu;
            screen->runNow();
            break;
        case PositionAction::GPSPositionBroadcast:
-            menuQueue = GpsPositionBroadcastMenu;
+            menuQueue = gps_position_broadcast_menu;
            screen->runNow();
            break;
        }
@@ -1303,13 +1303,13 @@ void menuHandler::nodeListMenu()
    bannerOptions.optionsEnumPtr = optionsEnumArray;
    bannerOptions.bannerCallback = [](int selected) -> void {
        if (selected == NodePicker) {
-            menuQueue = NodePickerMenu;
+            menuQueue = NodePicker_menu;
            screen->runNow();
        } else if (selected == Reset) {
-            menuQueue = ResetNodeDbMenu;
+            menuQueue = reset_node_db_menu;
            screen->runNow();
        } else if (selected == NodeNameLength) {
-            menuHandler::menuQueue = menuHandler::NodeNameLengthMenu;
+            menuHandler::menuQueue = menuHandler::node_name_length_menu;
            screen->runNow();
        }
    };
@@ -1330,12 +1330,12 @@ void menuHandler::NodePicker()
        menuHandler::pickedNodeNum = nodenum;
        // Keep UI favorite context in sync (used elsewhere for some node-based actions)
        graphics::UIRenderer::currentFavoriteNodeNum = nodenum;
-        menuQueue = ManageNodeMenu;
+        menuQueue = Manage_Node_menu;
        screen->runNow();
    });
 }

-void menuHandler::manageNodeMenu()
+void menuHandler::ManageNodeMenu()
 {
    // If we don't have a node selected yet, go fast exit
    auto node = nodeDB->getMeshNode(menuHandler::pickedNodeNum);
@@ -1391,13 +1391,13 @@ void menuHandler::manageNodeMenu()
    bannerOptions.optionsEnumPtr = optionsEnumArray;
    bannerOptions.bannerCallback = [](int selected) -> void {
        if (selected == Back) {
-            menuQueue = NodeBaseMenu;
+            menuQueue = node_base_menu;
            screen->runNow();
            return;
        }

        if (selected == Favorite) {
-            const auto *n = nodeDB->getMeshNode(menuHandler::pickedNodeNum);
+            auto n = nodeDB->getMeshNode(menuHandler::pickedNodeNum);
            if (!n) {
                return;
            }
@@ -1483,7 +1483,7 @@ void menuHandler::nodeNameLengthMenu()
    auto bannerOptions = createStaticBannerOptions("Node Name Length", nodeNameOptions, nodeNameLabels,
                                                   [](const NodeNameOption &option, int) -> void {
                                                       if (option.action == OptionsAction::Back) {
-                                                           menuQueue = NodeBaseMenu;
+                                                           menuQueue = node_base_menu;
                                                           screen->runNow();
                                                           return;
                                                       }
@@ -1498,7 +1498,6 @@ void menuHandler::nodeNameLengthMenu()

                                                       config.display.use_long_node_name = option.value;
                                                       saveUIConfig();
-                                                       service->reloadConfig(SEGMENT_CONFIG);
                                                       LOG_INFO("Setting names to %s", option.value ? "long" : "short");
                                                   });

@@ -1529,7 +1528,7 @@ void menuHandler::resetNodeDBMenu()
            nodeDB->resetNodes(1);
            rebootAtMsec = (millis() + DEFAULT_REBOOT_SECONDS * 1000);
        } else if (selected == 0) {
-            menuQueue = NodeBaseMenu;
+            menuQueue = node_base_menu;
            screen->runNow();
        }
    };
@@ -1551,7 +1550,7 @@ void menuHandler::compassNorthMenu()
    auto bannerOptions = createStaticBannerOptions("North Directions?", compassOptions, compassLabels,
                                                   [](const CompassOption &option, int) -> void {
                                                       if (option.action == OptionsAction::Back) {
-                                                           menuQueue = PositionBaseMenu;
+                                                           menuQueue = position_base_menu;
                                                           screen->runNow();
                                                           return;
                                                       }
@@ -1596,7 +1595,7 @@ void menuHandler::GPSToggleMenu()
    auto bannerOptions =
        createStaticBannerOptions("Toggle GPS", gpsToggleOptions, toggleLabels, [](const GPSToggleOption &option, int) -> void {
            if (option.action == OptionsAction::Back) {
-                menuQueue = PositionBaseMenu;
+                menuQueue = position_base_menu;
                screen->runNow();
                return;
            }
@@ -1661,7 +1660,7 @@ void menuHandler::GPSFormatMenu()

    auto onSelection = [](const GPSFormatOption &option, int) -> void {
        if (option.action == OptionsAction::Back) {
-            menuQueue = PositionBaseMenu;
+            menuQueue = position_base_menu;
            screen->runNow();
            return;
        }
@@ -1716,7 +1715,7 @@ void menuHandler::GPSSmartPositionMenu()
    bannerOptions.optionsCount = 3;
    bannerOptions.bannerCallback = [](int selected) -> void {
        if (selected == 0) {
-            menuQueue = PositionBaseMenu;
+            menuQueue = position_base_menu;
            screen->runNow();
        } else if (selected == 1) {
            config.position.position_broadcast_smart_enabled = true;
@@ -1745,7 +1744,7 @@ void menuHandler::GPSUpdateIntervalMenu()
    bannerOptions.optionsCount = 16;
    bannerOptions.bannerCallback = [](int selected) -> void {
        if (selected == 0) {
-            menuQueue = PositionBaseMenu;
+            menuQueue = position_base_menu;
            screen->runNow();
        } else if (selected == 1) {
            config.position.gps_update_interval = 8;
@@ -1833,7 +1832,7 @@ void menuHandler::GPSPositionBroadcastMenu()
    bannerOptions.optionsCount = 17;
    bannerOptions.bannerCallback = [](int selected) -> void {
        if (selected == 0) {
-            menuQueue = PositionBaseMenu;
+            menuQueue = position_base_menu;
            screen->runNow();
        } else if (selected == 1) {
            config.position.position_broadcast_secs = 60;
@@ -1916,7 +1915,7 @@ void menuHandler::GPSPositionBroadcastMenu()

 #endif

-void menuHandler::bluetoothToggleMenu()
+void menuHandler::BluetoothToggleMenu()
 {
    static const char *optionsArray[] = {"Back", "Enabled", "Disabled"};
    BannerOverlayOptions bannerOptions;
@@ -2044,7 +2043,7 @@ void menuHandler::TFTColorPickerMenu(OLEDDisplay *display)
    auto bannerOptions = createStaticBannerOptions(
        "Select Screen Color", colorOptions, colorLabels, [display](const ScreenColorOption &option, int) -> void {
            if (option.action == OptionsAction::Back) {
-                menuQueue = SystemBaseMenu;
+                menuQueue = system_base_menu;
                screen->runNow();
                return;
            }
@@ -2139,7 +2138,7 @@ void menuHandler::rebootMenu()
            messageStore.saveToFlash();
            rebootAtMsec = millis() + DEFAULT_REBOOT_SECONDS * 1000;
        } else {
-            menuQueue = PowerMenu;
+            menuQueue = power_menu;
            screen->runNow();
        }
    };
@@ -2161,7 +2160,7 @@ void menuHandler::shutdownMenu()
            InputEvent event = {.inputEvent = (input_broker_event)INPUT_BROKER_SHUTDOWN, .kbchar = 0, .touchX = 0, .touchY = 0};
            inputBroker->injectInputEvent(&event);
        } else {
-            menuQueue = PowerMenu;
+            menuQueue = power_menu;
            screen->runNow();
        }
    };
@@ -2222,14 +2221,14 @@ void menuHandler::testMenu()
    bannerOptions.optionsEnumPtr = optionsEnumArray;
    bannerOptions.bannerCallback = [](int selected) -> void {
        if (selected == NumberPicker) {
-            menuQueue = NumberTest;
+            menuQueue = number_test;
            screen->runNow();
        } else if (selected == ShowChirpy) {
            screen->toggleFrameVisibility("chirpy");
            screen->setFrames(Screen::FOCUS_SYSTEM);

        } else {
-            menuQueue = SystemBaseMenu;
+            menuQueue = system_base_menu;
            screen->runNow();
        }
    };
@@ -2253,7 +2252,7 @@ void menuHandler::wifiBaseMenu()
    bannerOptions.optionsCount = 2;
    bannerOptions.bannerCallback = [](int selected) -> void {
        if (selected == Wifi_toggle) {
-            menuQueue = WifiToggleMenu;
+            menuQueue = wifi_toggle_menu;
            screen->runNow();
        }
    };
@@ -2292,18 +2291,19 @@ void menuHandler::wifiToggleMenu()
 void menuHandler::screenOptionsMenu()
 {
    // Check if brightness is supported
-#if defined(T_DECK)
-    // TDeck Doesn't seem to support brightness at all, at least not reliably
-    bool hasSupportBrightness = false;
-#elif defined(ST7789_CS) || defined(USE_OLED) || defined(USE_SSD1306) || defined(USE_SH1106) || defined(USE_SH1107)
-    bool hasSupportBrightness = true;
-#else
    bool hasSupportBrightness = false;
+#if defined(ST7789_CS) || defined(USE_OLED) || defined(USE_SSD1306) || defined(USE_SH1106) || defined(USE_SH1107)
+    hasSupportBrightness = true;
 #endif

-    enum optionsNumbers { Back, Brightness, ScreenColor, FrameToggles, DisplayUnits, MessageBubbles };
-    static const char *optionsArray[6] = {"Back"};
-    static int optionsEnumArray[6] = {Back};
+#if defined(T_DECK)
+    // TDeck Doesn't seem to support brightness at all, at least not reliably
+    hasSupportBrightness = false;
+#endif
+
+    enum optionsNumbers { Back, Brightness, ScreenColor, FrameToggles, DisplayUnits };
+    static const char *optionsArray[5] = {"Back"};
+    static int optionsEnumArray[5] = {Back};
    int options = 1;

    // Only show brightness for B&W displays
@@ -2325,9 +2325,6 @@ void menuHandler::screenOptionsMenu()
    optionsArray[options] = "Display Units";
    optionsEnumArray[options++] = DisplayUnits;

-    optionsArray[options] = "Message Bubbles";
-    optionsEnumArray[options++] = MessageBubbles;
-
    BannerOverlayOptions bannerOptions;
    bannerOptions.message = "Display Options";
    bannerOptions.optionsArrayPtr = optionsArray;
@@ -2335,10 +2332,10 @@ void menuHandler::screenOptionsMenu()
    bannerOptions.optionsEnumPtr = optionsEnumArray;
    bannerOptions.bannerCallback = [](int selected) -> void {
        if (selected == Brightness) {
-            menuHandler::menuQueue = menuHandler::BrightnessPicker;
+            menuHandler::menuQueue = menuHandler::brightness_picker;
            screen->runNow();
        } else if (selected == ScreenColor) {
-            menuHandler::menuQueue = menuHandler::TftColorMenuPicker;
+            menuHandler::menuQueue = menuHandler::tftcolormenupicker;
            screen->runNow();
        } else if (selected == FrameToggles) {
            menuHandler::menuQueue = menuHandler::FrameToggles;
@@ -2346,11 +2343,8 @@ void menuHandler::screenOptionsMenu()
        } else if (selected == DisplayUnits) {
            menuHandler::menuQueue = menuHandler::DisplayUnits;
            screen->runNow();
-        } else if (selected == MessageBubbles) {
-            menuHandler::menuQueue = menuHandler::MessageBubblesMenu;
-            screen->runNow();
        } else {
-            menuQueue = SystemBaseMenu;
+            menuQueue = system_base_menu;
            screen->runNow();
        }
    };
@@ -2386,16 +2380,16 @@ void menuHandler::powerMenu()
    bannerOptions.optionsEnumPtr = optionsEnumArray;
    bannerOptions.bannerCallback = [](int selected) -> void {
        if (selected == Reboot) {
-            menuHandler::menuQueue = menuHandler::RebootMenu;
+            menuHandler::menuQueue = menuHandler::reboot_menu;
            screen->runNow();
        } else if (selected == Shutdown) {
-            menuHandler::menuQueue = menuHandler::ShutdownMenu;
+            menuHandler::menuQueue = menuHandler::shutdown_menu;
            screen->runNow();
        } else if (selected == MUI) {
-            menuHandler::menuQueue = menuHandler::MuiPicker;
+            menuHandler::menuQueue = menuHandler::mui_picker;
            screen->runNow();
        } else {
-            menuQueue = SystemBaseMenu;
+            menuQueue = system_base_menu;
            screen->runNow();
        }
    };
@@ -2433,7 +2427,7 @@ void menuHandler::keyVerificationFinalPrompt()
    }
 }

-void menuHandler::frameTogglesMenu()
+void menuHandler::FrameToggles_menu()
 {
    enum optionsNumbers {
        Finish,
@@ -2443,7 +2437,7 @@ void menuHandler::frameTogglesMenu()
        nodelist_hopsignal,
        nodelist_distance,
        nodelist_bearings,
-        gps_position,
+        gps,
        lora,
        clock,
        show_favorites,
@@ -2481,7 +2475,7 @@ void menuHandler::frameTogglesMenu()
 #endif

    optionsArray[options] = screen->isFrameHidden("gps") ? "Show Position" : "Hide Position";
-    optionsEnumArray[options++] = gps_position;
+    optionsEnumArray[options++] = gps;
 #endif

    optionsArray[options] = screen->isFrameHidden("lora") ? "Show LoRa" : "Hide LoRa";
@@ -2544,7 +2538,7 @@ void menuHandler::frameTogglesMenu()
            screen->toggleFrameVisibility("nodelist_bearings");
            menuHandler::menuQueue = menuHandler::FrameToggles;
            screen->runNow();
-        } else if (selected == gps_position) {
+        } else if (selected == gps) {
            screen->toggleFrameVisibility("gps");
            menuHandler::menuQueue = menuHandler::FrameToggles;
            screen->runNow();
@@ -2577,7 +2571,7 @@ void menuHandler::frameTogglesMenu()
    screen->showOverlayBanner(bannerOptions);
 }

-void menuHandler::displayUnitsMenu()
+void menuHandler::DisplayUnits_menu()
 {
    enum optionsNumbers { Back, MetricUnits, ImperialUnits };

@@ -2598,34 +2592,7 @@ void menuHandler::displayUnitsMenu()
            config.display.units = meshtastic_Config_DisplayConfig_DisplayUnits_IMPERIAL;
            service->reloadConfig(SEGMENT_CONFIG);
        } else {
-            menuHandler::menuQueue = menuHandler::ScreenOptionsMenu;
-            screen->runNow();
-        }
-    };
-    screen->showOverlayBanner(bannerOptions);
-}
-
-void menuHandler::messageBubblesMenu()
-{
-    enum optionsNumbers { Back, ShowBubbles, HideBubbles };
-
-    static const char *optionsArray[] = {"Back", "Show Bubbles", "Hide Bubbles"};
-    BannerOverlayOptions bannerOptions;
-    bannerOptions.message = "Message Bubbles";
-    bannerOptions.optionsArrayPtr = optionsArray;
-    bannerOptions.optionsCount = 3;
-    bannerOptions.InitialSelected = config.display.enable_message_bubbles ? 1 : 2;
-    bannerOptions.bannerCallback = [](int selected) -> void {
-        if (selected == ShowBubbles) {
-            config.display.enable_message_bubbles = true;
-            service->reloadConfig(SEGMENT_CONFIG);
-            LOG_INFO("Message bubbles enabled");
-        } else if (selected == HideBubbles) {
-            config.display.enable_message_bubbles = false;
-            service->reloadConfig(SEGMENT_CONFIG);
-            LOG_INFO("Message bubbles disabled");
-        } else {
-            menuHandler::menuQueue = menuHandler::ScreenOptionsMenu;
+            menuHandler::menuQueue = menuHandler::screen_options_menu;
            screen->runNow();
        }
    };
@@ -2634,156 +2601,153 @@ void menuHandler::messageBubblesMenu()

 void menuHandler::handleMenuSwitch(OLEDDisplay *display)
 {
-    if (menuQueue != MenuNone)
+    if (menuQueue != menu_none)
        test_count = 0;
    switch (menuQueue) {
-    case MenuNone:
+    case menu_none:
        break;
-    case LoraMenu:
+    case lora_Menu:
        loraMenu();
        break;
-    case LoraPicker:
+    case lora_picker:
        LoraRegionPicker();
        break;
-    case DeviceRolePicker:
-        deviceRolePicker();
+    case device_role_picker:
+        DeviceRolePicker();
        break;
-    case RadioPresetPicker:
-        radioPresetPicker();
+    case radio_preset_picker:
+        RadioPresetPicker();
        break;
-    case FrequencySlot:
+    case frequency_slot:
        FrequencySlotPicker();
        break;
-    case NoTimeoutLoraPicker:
+    case no_timeout_lora_picker:
        LoraRegionPicker(0);
        break;
-    case TzPicker:
+    case TZ_picker:
        TZPicker();
        break;
-    case TwelveHourPicker:
-        twelveHourPicker();
+    case twelve_hour_picker:
+        TwelveHourPicker();
        break;
-    case ClockFacePicker:
-        clockFacePicker();
+    case clock_face_picker:
+        ClockFacePicker();
        break;
-    case ClockMenu:
+    case clock_menu:
        clockMenu();
        break;
-    case SystemBaseMenu:
+    case system_base_menu:
        systemBaseMenu();
        break;
-    case PositionBaseMenu:
+    case position_base_menu:
        positionBaseMenu();
        break;
-    case NodeBaseMenu:
+    case node_base_menu:
        nodeListMenu();
        break;
 #if !MESHTASTIC_EXCLUDE_GPS
-    case GpsToggleMenu:
+    case gps_toggle_menu:
        GPSToggleMenu();
        break;
-    case GpsFormatMenu:
+    case gps_format_menu:
        GPSFormatMenu();
        break;
-    case GpsSmartPositionMenu:
+    case gps_smart_position_menu:
        GPSSmartPositionMenu();
        break;
-    case GpsUpdateIntervalMenu:
+    case gps_update_interval_menu:
        GPSUpdateIntervalMenu();
        break;
-    case GpsPositionBroadcastMenu:
+    case gps_position_broadcast_menu:
        GPSPositionBroadcastMenu();
        break;
 #endif
-    case CompassPointNorthMenu:
+    case compass_point_north_menu:
        compassNorthMenu();
        break;
-    case ResetNodeDbMenu:
+    case reset_node_db_menu:
        resetNodeDBMenu();
        break;
-    case BuzzerModeMenuPicker:
+    case buzzermodemenupicker:
        BuzzerModeMenu();
        break;
-    case MuiPicker:
+    case mui_picker:
        switchToMUIMenu();
        break;
-    case TftColorMenuPicker:
+    case tftcolormenupicker:
        TFTColorPickerMenu(display);
        break;
-    case BrightnessPicker:
+    case brightness_picker:
        BrightnessPickerMenu();
        break;
-    case NodeNameLengthMenu:
+    case node_name_length_menu:
        nodeNameLengthMenu();
        break;
-    case RebootMenu:
+    case reboot_menu:
        rebootMenu();
        break;
-    case ShutdownMenu:
+    case shutdown_menu:
        shutdownMenu();
        break;
-    case NodePickerMenu:
+    case NodePicker_menu:
        NodePicker();
        break;
-    case ManageNodeMenu:
-        manageNodeMenu();
+    case Manage_Node_menu:
+        ManageNodeMenu();
        break;
-    case RemoveFavorite:
+    case remove_favorite:
        removeFavoriteMenu();
        break;
-    case TraceRouteMenu:
+    case trace_route_menu:
        traceRouteMenu();
        break;
-    case TestMenu:
+    case test_menu:
        testMenu();
        break;
-    case NumberTest:
+    case number_test:
        numberTest();
        break;
-    case WifiToggleMenu:
+    case wifi_toggle_menu:
        wifiToggleMenu();
        break;
-    case KeyVerificationInit:
+    case key_verification_init:
        keyVerificationInitMenu();
        break;
-    case KeyVerificationFinalPrompt:
+    case key_verification_final_prompt:
        keyVerificationFinalPrompt();
        break;
-    case BluetoothToggleMenu:
-        bluetoothToggleMenu();
+    case bluetooth_toggle_menu:
+        BluetoothToggleMenu();
        break;
-    case ScreenOptionsMenu:
+    case screen_options_menu:
        screenOptionsMenu();
        break;
-    case PowerMenu:
+    case power_menu:
        powerMenu();
        break;
    case FrameToggles:
-        frameTogglesMenu();
+        FrameToggles_menu();
        break;
    case DisplayUnits:
-        displayUnitsMenu();
+        DisplayUnits_menu();
        break;
-    case ThrottleMessage:
+    case throttle_message:
        screen->showSimpleBanner("Too Many Attempts\nTry again in 60 seconds.", 5000);
        break;
-    case MessageResponseMenu:
+    case message_response_menu:
        messageResponseMenu();
        break;
-    case ReplyMenu:
+    case reply_menu:
        replyMenu();
        break;
-    case DeleteMessagesMenu:
+    case delete_messages_menu:
        deleteMessagesMenu();
        break;
-    case MessageViewModeMenu:
+    case message_viewmode_menu:
        messageViewModeMenu();
        break;
-    case MessageBubblesMenu:
-        messageBubblesMenu();
-        break;
    }
-    menuQueue = MenuNone;
+    menuQueue = menu_none;
 }

 void menuHandler::saveUIConfig()
@@ -8,54 +8,53 @@ class menuHandler
 {
  public:
    enum screenMenus {
-        MenuNone,
-        LoraMenu,
-        LoraPicker,
-        DeviceRolePicker,
-        RadioPresetPicker,
-        FrequencySlot,
-        NoTimeoutLoraPicker,
-        TzPicker,
-        TwelveHourPicker,
-        ClockFacePicker,
-        ClockMenu,
-        PositionBaseMenu,
-        NodeBaseMenu,
-        GpsToggleMenu,
-        GpsFormatMenu,
-        GpsSmartPositionMenu,
-        GpsUpdateIntervalMenu,
-        GpsPositionBroadcastMenu,
-        CompassPointNorthMenu,
-        ResetNodeDbMenu,
-        BuzzerModeMenuPicker,
-        MuiPicker,
-        TftColorMenuPicker,
-        BrightnessPicker,
-        RebootMenu,
-        ShutdownMenu,
-        NodePickerMenu,
-        ManageNodeMenu,
-        RemoveFavorite,
-        TestMenu,
-        NumberTest,
-        WifiToggleMenu,
-        BluetoothToggleMenu,
-        ScreenOptionsMenu,
-        PowerMenu,
-        SystemBaseMenu,
-        KeyVerificationInit,
-        KeyVerificationFinalPrompt,
-        TraceRouteMenu,
-        ThrottleMessage,
-        MessageResponseMenu,
-        MessageViewModeMenu,
-        ReplyMenu,
-        DeleteMessagesMenu,
-        NodeNameLengthMenu,
+        menu_none,
+        lora_Menu,
+        lora_picker,
+        device_role_picker,
+        radio_preset_picker,
+        frequency_slot,
+        no_timeout_lora_picker,
+        TZ_picker,
+        twelve_hour_picker,
+        clock_face_picker,
+        clock_menu,
+        position_base_menu,
+        node_base_menu,
+        gps_toggle_menu,
+        gps_format_menu,
+        gps_smart_position_menu,
+        gps_update_interval_menu,
+        gps_position_broadcast_menu,
+        compass_point_north_menu,
+        reset_node_db_menu,
+        buzzermodemenupicker,
+        mui_picker,
+        tftcolormenupicker,
+        brightness_picker,
+        reboot_menu,
+        shutdown_menu,
+        NodePicker_menu,
+        Manage_Node_menu,
+        remove_favorite,
+        test_menu,
+        number_test,
+        wifi_toggle_menu,
+        bluetooth_toggle_menu,
+        screen_options_menu,
+        power_menu,
+        system_base_menu,
+        key_verification_init,
+        key_verification_final_prompt,
+        trace_route_menu,
+        throttle_message,
+        message_response_menu,
+        message_viewmode_menu,
+        reply_menu,
+        delete_messages_menu,
+        node_name_length_menu,
        FrameToggles,
-        DisplayUnits,
-        MessageBubblesMenu
+        DisplayUnits
    };
    static screenMenus menuQueue;
    static uint32_t pickedNodeNum; // node selected by NodePicker for ManageNodeMenu
@@ -63,15 +62,15 @@ class menuHandler
    static void OnboardMessage();
    static void LoraRegionPicker(uint32_t duration = 30000);
    static void loraMenu();
-    static void deviceRolePicker();
-    static void radioPresetPicker();
+    static void DeviceRolePicker();
+    static void RadioPresetPicker();
    static void FrequencySlotPicker();
    static void handleMenuSwitch(OLEDDisplay *display);
    static void showConfirmationBanner(const char *message, std::function<void()> onConfirm);
    static void clockMenu();
    static void TZPicker();
-    static void twelveHourPicker();
-    static void clockFacePicker();
+    static void TwelveHourPicker();
+    static void ClockFacePicker();
    static void messageResponseMenu();
    static void messageViewModeMenu();
    static void replyMenu();
@@ -96,7 +95,7 @@ class menuHandler
    static void rebootMenu();
    static void shutdownMenu();
    static void NodePicker();
-    static void manageNodeMenu();
+    static void ManageNodeMenu();
    static void addFavoriteMenu();
    static void removeFavoriteMenu();
    static void traceRouteMenu();
@@ -107,16 +106,15 @@ class menuHandler
    static void screenOptionsMenu();
    static void powerMenu();
    static void nodeNameLengthMenu();
-    static void frameTogglesMenu();
-    static void displayUnitsMenu();
-    static void messageBubblesMenu();
+    static void FrameToggles_menu();
+    static void DisplayUnits_menu();
    static void textMessageMenu();

  private:
    static void saveUIConfig();
    static void keyVerificationInitMenu();
    static void keyVerificationFinalPrompt();
-    static void bluetoothToggleMenu();
+    static void BluetoothToggleMenu();
 };

 /* Generic Menu Options designations  */
@@ -527,12 +527,8 @@ void drawTextMessageFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
    constexpr int BUBBLE_MIN_W = 24;
    constexpr int BUBBLE_TEXT_INDENT = 2;

-    // Check if bubbles are enabled
-    const bool showBubbles = config.display.enable_message_bubbles;
-    const int textIndent = showBubbles ? (BUBBLE_PAD_X + BUBBLE_TEXT_INDENT) : LEFT_MARGIN;
-
    // Derived widths
-    const int leftTextWidth = SCREEN_WIDTH - LEFT_MARGIN - RIGHT_MARGIN - (showBubbles ? (BUBBLE_PAD_X * 2) : 0);
+    const int leftTextWidth = SCREEN_WIDTH - LEFT_MARGIN - RIGHT_MARGIN - (BUBBLE_PAD_X * 2);
    const int rightTextWidth = SCREEN_WIDTH - LEFT_MARGIN - RIGHT_MARGIN - SCROLLBAR_WIDTH;

    // Title string depending on mode
@@ -800,105 +796,114 @@ void drawTextMessageFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
        }
    }

-    // Draw bubbles (only if enabled)
-    if (showBubbles) {
-        for (size_t bi = 0; bi < blocks.size(); ++bi) {
-            const auto &b = blocks[bi];
-            if (b.start >= cachedLines.size() || b.end >= cachedLines.size() || b.start > b.end)
-                continue;
+    // Draw bubbles
+    for (size_t bi = 0; bi < blocks.size(); ++bi) {
+        const auto &b = blocks[bi];
+        if (b.start >= cachedLines.size() || b.end >= cachedLines.size() || b.start > b.end)
+            continue;

-            int visualTop = lineTop[b.start];
+        int visualTop = lineTop[b.start];

-            int topY;
-            if (isHeader[b.start]) {
-                // Header start
-                constexpr int BUBBLE_PAD_TOP_HEADER = 1; // try 1 or 2
-                topY = visualTop - BUBBLE_PAD_TOP_HEADER;
+        int topY;
+        if (isHeader[b.start]) {
+            // Header start
+            constexpr int BUBBLE_PAD_TOP_HEADER = 1; // try 1 or 2
+            topY = visualTop - BUBBLE_PAD_TOP_HEADER;
+        } else {
+            // Body start
+            bool thisLineHasEmote = false;
+            for (int e = 0; e < numEmotes; ++e) {
+                if (cachedLines[b.start].find(emotes[e].label) != std::string::npos) {
+                    thisLineHasEmote = true;
+                    break;
+                }
+            }
+            if (thisLineHasEmote) {
+                constexpr int EMOTE_PADDING_ABOVE = 4;
+                visualTop -= EMOTE_PADDING_ABOVE;
+            }
+            topY = visualTop - BUBBLE_PAD_Y;
+        }
+        int visualBottom = getDrawnLinePixelBottom(lineTop[b.end], cachedLines[b.end], isHeader[b.end]);
+        int bottomY = visualBottom + BUBBLE_PAD_Y;
+
+        if (bi + 1 < blocks.size()) {
+            int nextHeaderIndex = (int)blocks[bi + 1].start;
+            int nextTop = lineTop[nextHeaderIndex];
+            int maxBottom = nextTop - 1 - bubbleGapY;
+            if (bottomY > maxBottom)
+                bottomY = maxBottom;
+        }
+
+        if (bottomY <= topY + 2)
+            continue;
+
+        if (bottomY < contentTop || topY > contentBottom - 1)
+            continue;
+
+        int maxLineW = 0;
+
+        for (size_t i = b.start; i <= b.end; ++i) {
+            int w = 0;
+            if (isHeader[i]) {
+                w = display->getStringWidth(cachedLines[i].c_str());
+                if (b.mine)
+                    w += 12; // room for ACK/NACK/relay mark
            } else {
-                // Body start
-                bool thisLineHasEmote = false;
-                for (int e = 0; e < numEmotes; ++e) {
-                    if (cachedLines[b.start].find(emotes[e].label) != std::string::npos) {
-                        thisLineHasEmote = true;
-                        break;
-                    }
-                }
-                if (thisLineHasEmote) {
-                    constexpr int EMOTE_PADDING_ABOVE = 4;
-                    visualTop -= EMOTE_PADDING_ABOVE;
-                }
-                topY = visualTop - BUBBLE_PAD_Y;
+                w = getRenderedLineWidth(display, cachedLines[i], emotes, numEmotes);
            }
-            int visualBottom = getDrawnLinePixelBottom(lineTop[b.end], cachedLines[b.end], isHeader[b.end]);
-            int bottomY = visualBottom + BUBBLE_PAD_Y;
+            if (w > maxLineW)
+                maxLineW = w;
+        }

-            if (bi + 1 < blocks.size()) {
-                int nextHeaderIndex = (int)blocks[bi + 1].start;
-                int nextTop = lineTop[nextHeaderIndex];
-                int maxBottom = nextTop - 1 - bubbleGapY;
-                if (bottomY > maxBottom)
-                    bottomY = maxBottom;
-            }
+        int bubbleW = std::max(BUBBLE_MIN_W, maxLineW + (BUBBLE_PAD_X * 2));
+        int bubbleH = (bottomY - topY) + 1;
+        int bubbleX = 0;
+        if (b.mine) {
+            bubbleX = rightEdge - bubbleW;
+        } else {
+            bubbleX = x;
+        }
+        if (bubbleX < x)
+            bubbleX = x;
+        if (bubbleX + bubbleW > rightEdge)
+            bubbleW = std::max(1, rightEdge - bubbleX);

-            if (bottomY <= topY + 2)
-                continue;
+        if (bubbleW > 1 && bubbleH > 1) {
+            int x1 = bubbleX + bubbleW - 1;
+            int y1 = topY + bubbleH - 1;

-            if (bottomY < contentTop || topY > contentBottom - 1)
-                continue;
-
-            int maxLineW = 0;
-
-            for (size_t i = b.start; i <= b.end; ++i) {
-                int w = 0;
-                if (isHeader[i]) {
-                    w = display->getStringWidth(cachedLines[i].c_str());
-                    if (b.mine)
-                        w += 12; // room for ACK/NACK/relay mark
-                } else {
-                    w = getRenderedLineWidth(display, cachedLines[i], emotes, numEmotes);
-                }
-                if (w > maxLineW)
-                    maxLineW = w;
-            }
-
-            int bubbleW = std::max(BUBBLE_MIN_W, maxLineW + (textIndent * 2));
-            int bubbleH = (bottomY - topY) + 1;
-            int bubbleX = 0;
            if (b.mine) {
-                bubbleX = rightEdge - bubbleW;
+                // Send Message (Right side)
+                display->drawRect(x1 + 2 - bubbleW, y1 - bubbleH, bubbleW, bubbleH);
+                // Top Right Corner
+                display->drawRect(x1, topY, 2, 1);
+                display->drawRect(x1, topY, 1, 2);
+                // Bottom Right Corner
+                display->drawRect(x1 - 1, bottomY - 2, 2, 1);
+                display->drawRect(x1, bottomY - 3, 1, 2);
+                // Knock the corners off to make a bubble
+                display->setColor(BLACK);
+                display->drawRect(x1 - bubbleW, topY - 1, 1, 1);
+                display->drawRect(x1 - bubbleW, bottomY - 1, 1, 1);
+                display->setColor(WHITE);
            } else {
-                bubbleX = x;
-            }
-            if (bubbleX < x)
-                bubbleX = x;
-            if (bubbleX + bubbleW > rightEdge)
-                bubbleW = std::max(1, rightEdge - bubbleX);
-
-            // Draw rounded rectangle bubble
-            if (bubbleW > BUBBLE_RADIUS * 2 && bubbleH > BUBBLE_RADIUS * 2) {
-                const int r = BUBBLE_RADIUS;
-                const int bx = bubbleX;
-                const int by = topY;
-                const int bw = bubbleW;
-                const int bh = bubbleH;
-
-                // Draw the 4 corner arcs using drawCircleQuads
-                display->drawCircleQuads(bx + r, by + r, r, 0x2);                   // Top-left
-                display->drawCircleQuads(bx + bw - r - 1, by + r, r, 0x1);          // Top-right
-                display->drawCircleQuads(bx + r, by + bh - r - 1, r, 0x4);          // Bottom-left
-                display->drawCircleQuads(bx + bw - r - 1, by + bh - r - 1, r, 0x8); // Bottom-right
-
-                // Draw the 4 edges between corners
-                display->drawHorizontalLine(bx + r, by, bw - 2 * r);          // Top edge
-                display->drawHorizontalLine(bx + r, by + bh - 1, bw - 2 * r); // Bottom edge
-                display->drawVerticalLine(bx, by + r, bh - 2 * r);            // Left edge
-                display->drawVerticalLine(bx + bw - 1, by + r, bh - 2 * r);   // Right edge
-            } else if (bubbleW > 1 && bubbleH > 1) {
-                // Fallback to simple rectangle for very small bubbles
-                display->drawRect(bubbleX, topY, bubbleW, bubbleH);
+                // Received Message (Left Side)
+                display->drawRect(bubbleX, topY, bubbleW + 1, bubbleH);
+                // Top Left Corner
+                display->drawRect(bubbleX + 1, topY + 1, 2, 1);
+                display->drawRect(bubbleX + 1, topY + 1, 1, 2);
+                // Bottom Left Corner
+                display->drawRect(bubbleX + 1, bottomY - 1, 2, 1);
+                display->drawRect(bubbleX + 1, bottomY - 2, 1, 2);
+                // Knock the corners off to make a bubble
+                display->setColor(BLACK);
+                display->drawRect(bubbleX + bubbleW, topY, 1, 1);
+                display->drawRect(bubbleX + bubbleW, bottomY, 1, 1);
+                display->setColor(WHITE);
            }
        }
-    } // end if (showBubbles)
+    }

    // Render visible lines
    int lineY = yOffset;
@@ -911,11 +916,11 @@ void drawTextMessageFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
                int headerX;
                if (isMine[i]) {
                    // push header left to avoid overlap with scrollbar
-                    headerX = (SCREEN_WIDTH - SCROLLBAR_WIDTH - RIGHT_MARGIN) - w - (showBubbles ? textIndent : 0);
+                    headerX = (SCREEN_WIDTH - SCROLLBAR_WIDTH - RIGHT_MARGIN) - w - BUBBLE_TEXT_INDENT;
                    if (headerX < LEFT_MARGIN)
                        headerX = LEFT_MARGIN;
                } else {
-                    headerX = x + textIndent;
+                    headerX = x + BUBBLE_PAD_X + BUBBLE_TEXT_INDENT;
                }
                display->drawString(headerX, lineY, cachedLines[i].c_str());

@@ -955,13 +960,14 @@ void drawTextMessageFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
                if (isMine[i]) {
                    // Calculate actual rendered width including emotes
                    int renderedWidth = getRenderedLineWidth(display, cachedLines[i], emotes, numEmotes);
-                    int rightX = (SCREEN_WIDTH - SCROLLBAR_WIDTH - RIGHT_MARGIN) - renderedWidth - (showBubbles ? textIndent : 0);
+                    int rightX = (SCREEN_WIDTH - SCROLLBAR_WIDTH - RIGHT_MARGIN) - renderedWidth - BUBBLE_TEXT_INDENT;
                    if (rightX < LEFT_MARGIN)
                        rightX = LEFT_MARGIN;

                    drawStringWithEmotes(display, rightX, lineY, cachedLines[i], emotes, numEmotes);
                } else {
-                    drawStringWithEmotes(display, x + textIndent, lineY, cachedLines[i], emotes, numEmotes);
+                    drawStringWithEmotes(display, x + BUBBLE_PAD_X + BUBBLE_TEXT_INDENT, lineY, cachedLines[i], emotes,
+                                         numEmotes);
                }
            }
        }
@@ -171,7 +171,7 @@ unsigned long getModeCycleIntervalMs()

 int calculateMaxScroll(int totalEntries, int visibleRows)
 {
-    return max(0, (totalEntries - 1) / (visibleRows * 2));
+    return std::max(0, (totalEntries - 1) / (visibleRows * 2));
 }

 void drawColumnSeparator(OLEDDisplay *display, int16_t x, int16_t yStart, int16_t yEnd)
@@ -187,12 +187,13 @@ void drawScrollbar(OLEDDisplay *display, int visibleNodeRows, int totalEntries,
    if (totalEntries <= visibleNodeRows * columns)
        return;

-    int scrollbarHeight = display->getHeight() - scrollStartY - 10;
-    int thumbHeight = max(4, (scrollbarHeight * visibleNodeRows * columns) / totalEntries);
-    int thumbY = scrollStartY + (scrollIndex * (scrollbarHeight - thumbHeight)) /
-                                    max(1, max(0, (totalEntries - 1) / (visibleNodeRows * columns)));
-
    int scrollbarX = display->getWidth() - 2;
+    int scrollbarHeight = display->getHeight() - scrollStartY - 10;
+    int thumbHeight = std::max(4, (scrollbarHeight * visibleNodeRows * columns) / totalEntries);
+    int perPage = visibleNodeRows * columns;
+    int maxScroll = std::max(0, (totalEntries - 1) / perPage);
+    int thumbY = scrollStartY + (scrollIndex * (scrollbarHeight - thumbHeight)) / std::max(1, maxScroll);
+
    for (int i = 0; i < thumbHeight; i++) {
        display->setPixel(scrollbarX, thumbY + i);
    }
@@ -555,13 +556,13 @@ void drawNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t

    int maxScroll = 0;
    if (perPage > 0) {
-        maxScroll = max(0, (totalEntries - 1) / perPage);
+        maxScroll = std::max(0, (totalEntries - 1) / perPage);
    }

    if (scrollIndex > maxScroll)
        scrollIndex = maxScroll;
    int startIndex = scrollIndex * visibleNodeRows * totalColumns;
-    int endIndex = min(startIndex + visibleNodeRows * totalColumns, totalEntries);
+    int endIndex = std::min(startIndex + visibleNodeRows * totalColumns, totalEntries);
    int yOffset = 0;
    int col = 0;
    int lastNodeY = y;
@@ -579,7 +580,7 @@ void drawNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t
        if (extras)
            extras(display, node, xPos, yPos, columnWidth, heading, lat, lon);

-        lastNodeY = max(lastNodeY, yPos + FONT_HEIGHT_SMALL);
+        lastNodeY = std::max(lastNodeY, yPos + FONT_HEIGHT_SMALL);
        yOffset += rowYOffset;
        shownCount++;
        rowCount++;
@@ -612,11 +613,13 @@ void drawNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t
    if (millis() - popupTime < POPUP_DURATION_MS) {
        popupTotal = totalEntries;

+        int perPage = visibleNodeRows * totalColumns;
+
        popupStart = startIndex + 1;
-        popupEnd = min(startIndex + perPage, totalEntries);
+        popupEnd = std::min(startIndex + perPage, totalEntries);

        popupPage = (scrollIndex + 1);
-        popupMaxPage = max(1, (totalEntries + perPage - 1) / perPage);
+        popupMaxPage = std::max(1, (totalEntries + perPage - 1) / perPage);

        char buf[32];
        snprintf(buf, sizeof(buf), "%d-%d/%d  Pg %d/%d", popupStart, popupEnd, popupTotal, popupPage, popupMaxPage);
@@ -2,7 +2,6 @@
 #if HAS_SCREEN
 #include "CompassRenderer.h"
 #include "GPSStatus.h"
-#include "MeshService.h"
 #include "NodeDB.h"
 #include "NodeListRenderer.h"
 #include "UIRenderer.h"
@@ -12,7 +11,6 @@
 #include "graphics/TimeFormatters.h"
 #include "graphics/images.h"
 #include "main.h"
-#include "modules/CannedMessageModule.h"
 #include "target_specific.h"
 #include <OLEDDisplay.h>
 #include <RTC.h>
@@ -289,8 +287,7 @@ void UIRenderer::drawNodes(OLEDDisplay *display, int16_t x, int16_t y, const mes
 // **********************
 // * Favorite Node Info *
 // **********************
-// cppcheck-suppress constParameterPointer; signature must match FrameCallback typedef from OLEDDisplayUi library
-void UIRenderer::drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
+void UIRenderer::drawNodeInfo(OLEDDisplay *display, const OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
    if (favoritedNodes.empty())
        return;
@@ -316,7 +313,7 @@ void UIRenderer::drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, i
    // === Create the shortName and title string ===
    const char *shortName = (node->has_user && haveGlyphs(node->user.short_name)) ? node->user.short_name : "Node";
    char titlestr[32] = {0};
-    snprintf(titlestr, sizeof(titlestr), "*%s*", shortName);
+    snprintf(titlestr, sizeof(titlestr), "Fav: %s", shortName);

    // === Draw battery/time/mail header (common across screens) ===
    graphics::drawCommonHeader(display, x, y, titlestr);
@@ -345,162 +342,34 @@ void UIRenderer::drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, i
    }

    // === 2. Signal and Hops (combined on one line, if available) ===
+    // If both are present: "Sig: 97%  [2hops]"
+    // If only one: show only that one
    char signalHopsStr[32] = "";
    bool haveSignal = false;
-    int bars = 0;
+    int percentSignal = clamp((int)((node->snr + 10) * 5), 0, 100);

-    // Helper to get SNR limit based on modem preset
-    auto getSnrLimit = [](meshtastic_Config_LoRaConfig_ModemPreset preset) -> float {
-        switch (preset) {
-        case meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW:
-        case meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE:
-        case meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST:
-            return -6.0f;
-        case meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_SLOW:
-        case meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST:
-            return -5.5f;
-        case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_SLOW:
-        case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_FAST:
-        case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO:
-            return -4.5f;
-        default:
-            return -6.0f;
-        }
-    };
-
-    // Calculate signal grade using modem preset and SNR only
-    float snrLimit = getSnrLimit(config.lora.modem_preset);
-    float snr = node->snr;
-
-    // Determine signal quality label and bars using SNR-only grading
-    const char *qualityLabel = nullptr;
-
-    if (snr > snrLimit + 10) {
-        qualityLabel = "Good";
-        bars = 4;
-    } else if (snr > snrLimit + 6) {
-        qualityLabel = "Good";
-        bars = 3;
-    } else if (snr > snrLimit + 2) {
-        qualityLabel = "Good";
-        bars = 2;
-    } else if (snr > snrLimit - 4) {
-        qualityLabel = "Fair";
-        bars = 1;
-    } else {
-        qualityLabel = "Bad";
-        bars = 1;
-    }
-
-    // Add extra spacing on the left if we have an API connection to account for the common footer icons
-    const char *leftSideSpacing =
-        graphics::isAPIConnected(service->api_state) ? (currentResolution == ScreenResolution::High ? "     " : "   ") : " ";
+    // Always use "Sig" for the label
+    const char *signalLabel = " Sig";

    // --- Build the Signal/Hops line ---
-    // Only show signal if we have valid SNR
-    if (snr > -100 && snr != 0) {
-        snprintf(signalHopsStr, sizeof(signalHopsStr), "%sSig:%s", leftSideSpacing, qualityLabel);
+    // If SNR looks reasonable, show signal
+    if ((int)((node->snr + 10) * 5) >= 0 && node->snr > -100) {
+        snprintf(signalHopsStr, sizeof(signalHopsStr), "%s: %d%%", signalLabel, percentSignal);
        haveSignal = true;
    }
-
+    // If hops is valid (>0), show right after signal
    if (node->hops_away > 0) {
        size_t len = strlen(signalHopsStr);
+        // Decide between "1 Hop" and "N Hops"
        if (haveSignal) {
-            snprintf(signalHopsStr + len, sizeof(signalHopsStr) - len, " [#]");
+            snprintf(signalHopsStr + len, sizeof(signalHopsStr) - len, " [%d %s]", node->hops_away,
+                     (node->hops_away == 1 ? "Hop" : "Hops"));
        } else {
-            snprintf(signalHopsStr, sizeof(signalHopsStr), "[#]");
+            snprintf(signalHopsStr, sizeof(signalHopsStr), "[%d %s]", node->hops_away, (node->hops_away == 1 ? "Hop" : "Hops"));
        }
    }
-
-    if (signalHopsStr[0]) {
-        int yPos = getTextPositions(display)[line++];
-        int curX = x;
-
-        // Split combined string into signal text and hop suffix
-        char sigPart[20] = "";
-        const char *hopPart = nullptr;
-
-        char *bracket = strchr(signalHopsStr, '[');
-        if (bracket) {
-            size_t n = (size_t)(bracket - signalHopsStr);
-            if (n >= sizeof(sigPart))
-                n = sizeof(sigPart) - 1;
-            memcpy(sigPart, signalHopsStr, n);
-            sigPart[n] = '\0';
-
-            // Trim trailing spaces
-            while (strlen(sigPart) && sigPart[strlen(sigPart) - 1] == ' ') {
-                sigPart[strlen(sigPart) - 1] = '\0';
-            }
-
-            hopPart = bracket; // "[n Hop(s)]"
-        } else {
-            strncpy(sigPart, signalHopsStr, sizeof(sigPart) - 1);
-            sigPart[sizeof(sigPart) - 1] = '\0';
-        }
-
-        // Draw signal quality text
-        display->drawString(curX, yPos, sigPart);
-        curX += display->getStringWidth(sigPart) + 4;
-
-        // Draw signal bars (skip on UltraLow, text only)
-        if (currentResolution != ScreenResolution::UltraLow && haveSignal && bars > 0) {
-            const int kMaxBars = 4;
-            if (bars < 1)
-                bars = 1;
-            if (bars > kMaxBars)
-                bars = kMaxBars;
-
-            int barX = curX;
-
-            const bool hi = (currentResolution == ScreenResolution::High);
-            int barWidth = hi ? 2 : 1;
-            int barGap = hi ? 2 : 1;
-            int maxBarHeight = FONT_HEIGHT_SMALL - 7;
-            if (!hi)
-                maxBarHeight -= 1;
-            int barY = yPos + (FONT_HEIGHT_SMALL - maxBarHeight) / 2;
-
-            for (int bi = 0; bi < kMaxBars; bi++) {
-                int barHeight = maxBarHeight * (bi + 1) / kMaxBars;
-                if (barHeight < 2)
-                    barHeight = 2;
-
-                int bx = barX + bi * (barWidth + barGap);
-                int by = barY + maxBarHeight - barHeight;
-
-                if (bi < bars) {
-                    display->fillRect(bx, by, barWidth, barHeight);
-                } else {
-                    int baseY = barY + maxBarHeight - 1;
-                    display->drawHorizontalLine(bx, baseY, barWidth);
-                }
-            }
-
-            curX += (kMaxBars * barWidth) + ((kMaxBars - 1) * barGap) + 2;
-        }
-
-        // Draw hops AFTER the bars as: [ number + hop icon ]
-        if (hopPart && node->hops_away > 0) {
-
-            // open bracket
-            display->drawString(curX, yPos, "[");
-            curX += display->getStringWidth("[") + 1;
-
-            // hop count
-            char hopCount[6];
-            snprintf(hopCount, sizeof(hopCount), "%d", node->hops_away);
-            display->drawString(curX, yPos, hopCount);
-            curX += display->getStringWidth(hopCount) + 2;
-
-            // hop icon
-            const int iconY = yPos + (FONT_HEIGHT_SMALL - hop_height) / 2;
-            display->drawXbm(curX, iconY, hop_width, hop_height, hop);
-            curX += hop_width + 1;
-
-            // closing bracket
-            display->drawString(curX, yPos, "]");
-        }
+    if (signalHopsStr[0] && line < 5) {
+        display->drawString(x, getTextPositions(display)[line++], signalHopsStr);
    }

    // === 3. Heard (last seen, skip if node never seen) ===
@@ -508,8 +377,8 @@ void UIRenderer::drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, i
    uint32_t seconds = sinceLastSeen(node);
    if (seconds != 0 && seconds != UINT32_MAX) {
        uint32_t minutes = seconds / 60, hours = minutes / 60, days = hours / 24;
-        // Format as "Heard:Xm ago", "Heard:Xh ago", or "Heard:Xd ago"
-        snprintf(seenStr, sizeof(seenStr), (days > 365 ? " Heard:?" : "%sHeard:%d%c ago"), leftSideSpacing,
+        // Format as "Heard: Xm ago", "Heard: Xh ago", or "Heard: Xd ago"
+        snprintf(seenStr, sizeof(seenStr), (days > 365 ? " Heard: ?" : " Heard: %d%c ago"),
                 (days    ? days
                  : hours ? hours
                          : minutes),
@@ -517,18 +386,16 @@ void UIRenderer::drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, i
                  : hours ? 'h'
                          : 'm'));
    }
-    if (seenStr[0]) {
+    if (seenStr[0] && line < 5) {
        display->drawString(x, getTextPositions(display)[line++], seenStr);
    }
 #if !defined(M5STACK_UNITC6L)
    // === 4. Uptime (only show if metric is present) ===
    char uptimeStr[32] = "";
    if (node->has_device_metrics && node->device_metrics.has_uptime_seconds) {
-        char upPrefix[12]; // enough for leftSideSpacing + "Up:"
-        snprintf(upPrefix, sizeof(upPrefix), "%sUp:", leftSideSpacing);
-        getUptimeStr(node->device_metrics.uptime_seconds * 1000, upPrefix, uptimeStr, sizeof(uptimeStr));
+        getUptimeStr(node->device_metrics.uptime_seconds * 1000, " Up", uptimeStr, sizeof(uptimeStr));
    }
-    if (uptimeStr[0]) {
+    if (uptimeStr[0] && line < 5) {
        display->drawString(x, getTextPositions(display)[line++], uptimeStr);
    }

@@ -555,16 +422,16 @@ void UIRenderer::drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, i
            if (miles < 0.1) {
                int feet = (int)(miles * 5280);
                if (feet > 0 && feet < 1000) {
-                    snprintf(distStr, sizeof(distStr), "%sDistance:%dft", leftSideSpacing, feet);
+                    snprintf(distStr, sizeof(distStr), " Distance: %dft", feet);
                    haveDistance = true;
                } else if (feet >= 1000) {
-                    snprintf(distStr, sizeof(distStr), "%sDistance:¼mi", leftSideSpacing);
+                    snprintf(distStr, sizeof(distStr), " Distance: ¼mi");
                    haveDistance = true;
                }
            } else {
                int roundedMiles = (int)(miles + 0.5);
                if (roundedMiles > 0 && roundedMiles < 1000) {
-                    snprintf(distStr, sizeof(distStr), "%sDistance:%dmi", leftSideSpacing, roundedMiles);
+                    snprintf(distStr, sizeof(distStr), " Distance: %dmi", roundedMiles);
                    haveDistance = true;
                }
            }
@@ -572,74 +439,26 @@ void UIRenderer::drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, i
            if (distanceKm < 1.0) {
                int meters = (int)(distanceKm * 1000);
                if (meters > 0 && meters < 1000) {
-                    snprintf(distStr, sizeof(distStr), "%sDistance:%dm", leftSideSpacing, meters);
+                    snprintf(distStr, sizeof(distStr), " Distance: %dm", meters);
                    haveDistance = true;
                } else if (meters >= 1000) {
-                    snprintf(distStr, sizeof(distStr), "%sDistance:1km", leftSideSpacing);
+                    snprintf(distStr, sizeof(distStr), " Distance: 1km");
                    haveDistance = true;
                }
            } else {
                int km = (int)(distanceKm + 0.5);
                if (km > 0 && km < 1000) {
-                    snprintf(distStr, sizeof(distStr), "%sDistance:%dkm", leftSideSpacing, km);
+                    snprintf(distStr, sizeof(distStr), " Distance: %dkm", km);
                    haveDistance = true;
                }
            }
        }
    }
-    if (haveDistance && distStr[0]) {
+    // Only display if we actually have a value!
+    if (haveDistance && distStr[0] && line < 5) {
        display->drawString(x, getTextPositions(display)[line++], distStr);
    }

-    // === 6. Battery after Distance line, otherwise next available line ===
-    char batLine[32] = "";
-    bool haveBatLine = false;
-
-    if (node->has_device_metrics) {
-        bool hasPct = node->device_metrics.has_battery_level;
-        bool hasVolt = node->device_metrics.has_voltage && node->device_metrics.voltage > 0.001f;
-
-        int pct = 0;
-        float volt = 0.0f;
-
-        if (hasPct) {
-            pct = (int)node->device_metrics.battery_level;
-        }
-
-        if (hasVolt) {
-            volt = node->device_metrics.voltage;
-        }
-
-        if (hasPct && pct > 0 && pct <= 100) {
-            // Normal battery percentage
-            if (hasVolt) {
-                snprintf(batLine, sizeof(batLine), "%sBat:%d%% (%.2fV)", leftSideSpacing, pct, volt);
-            } else {
-                snprintf(batLine, sizeof(batLine), "%sBat:%d%%", leftSideSpacing, pct);
-            }
-            haveBatLine = true;
-        } else if (hasPct && pct > 100) {
-            // Plugged in
-            if (hasVolt) {
-                snprintf(batLine, sizeof(batLine), "%sPlugged In (%.2fV)", leftSideSpacing, volt);
-            } else {
-                snprintf(batLine, sizeof(batLine), "%sPlugged In", leftSideSpacing);
-            }
-            haveBatLine = true;
-        } else if (!hasPct && hasVolt) {
-            // Voltage only
-            snprintf(batLine, sizeof(batLine), "%sBat:%.2fV", leftSideSpacing, volt);
-            haveBatLine = true;
-        }
-    }
-
-    const int maxTextLines = (currentResolution == ScreenResolution::High) ? 6 : 5;
-
-    // Only draw battery if it fits within the allowed lines
-    if (haveBatLine && line <= maxTextLines) {
-        display->drawString(x, getTextPositions(display)[line++], batLine);
-    }
-
    // --- Compass Rendering: landscape (wide) screens use the original side-aligned logic ---
    if (SCREEN_WIDTH > SCREEN_HEIGHT) {
        bool showCompass = false;
@@ -774,7 +593,7 @@ void UIRenderer::drawDeviceFocused(OLEDDisplay *display, OLEDDisplayUiState *sta
    }
    char uptimeStr[32] = "";
    if (currentResolution != ScreenResolution::UltraLow) {
-        getUptimeStr(millis(), "Up: ", uptimeStr, sizeof(uptimeStr));
+        getUptimeStr(millis(), "Up", uptimeStr, sizeof(uptimeStr));
    }
    display->drawString(SCREEN_WIDTH - display->getStringWidth(uptimeStr), getTextPositions(display)[line++], uptimeStr);

@@ -1165,6 +984,7 @@ void UIRenderer::drawCompassAndLocationScreen(OLEDDisplay *display, OLEDDisplayU
    config.display.heading_bold = false;

    const char *displayLine = ""; // Initialize to empty string by default
+    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());

    if (config.position.gps_mode != meshtastic_Config_PositionConfig_GpsMode_ENABLED) {
        if (config.position.fixed_position) {
@@ -1209,10 +1029,10 @@ void UIRenderer::drawCompassAndLocationScreen(OLEDDisplay *display, OLEDDisplayU
            char uptimeStr[32];
 #if defined(USE_EINK)
            // E-Ink: skip seconds, show only days/hours/mins
-            getUptimeStr(delta, "Last: ", uptimeStr, sizeof(uptimeStr), false);
+            getUptimeStr(delta, "Last", uptimeStr, sizeof(uptimeStr), false);
 #else
            // Non E-Ink: include seconds where useful
-            getUptimeStr(delta, "Last: ", uptimeStr, sizeof(uptimeStr), true);
+            getUptimeStr(delta, "Last", uptimeStr, sizeof(uptimeStr), true);
 #endif

            display->drawString(0, getTextPositions(display)[line++], uptimeStr);
@@ -1390,7 +1210,6 @@ static int8_t lastFrameIndex = -1;
 static uint32_t lastFrameChangeTime = 0;
 constexpr uint32_t ICON_DISPLAY_DURATION_MS = 2000;

-// cppcheck-suppress constParameterPointer; signature must match OverlayCallback typedef from OLEDDisplayUi library
 void UIRenderer::drawNavigationBar(OLEDDisplay *display, OLEDDisplayUiState *state)
 {
    int currentFrame = state->currentFrame;
@@ -1423,11 +1242,6 @@ void UIRenderer::drawNavigationBar(OLEDDisplay *display, OLEDDisplayUiState *sta
    const int totalWidth = (pageEnd - pageStart) * iconSize + (pageEnd - pageStart - 1) * spacing;
    const int xStart = (SCREEN_WIDTH - totalWidth) / 2;

-    // Suppress nav overlay entirely
-    if (cannedMessageModule && cannedMessageModule->isFreeTextUIActive()) {
-        return;
-    }
-
    bool navBarVisible = millis() - lastFrameChangeTime <= ICON_DISPLAY_DURATION_MS;
    int y = navBarVisible ? (SCREEN_HEIGHT - iconSize - 1) : SCREEN_HEIGHT;

@@ -49,7 +49,7 @@ class UIRenderer
    // Navigation bar overlay
    static void drawNavigationBar(OLEDDisplay *display, OLEDDisplayUiState *state);

-    static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
+    static void drawNodeInfo(OLEDDisplay *display, const OLEDDisplayUiState *state, int16_t x, int16_t y);

    static void drawDeviceFocused(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);

@@ -83,12 +83,6 @@ static const unsigned char mail[] PROGMEM = {
    0b11111111, 0b00  // Bottom line
 };

-// Hop icon (9x10)
-#define hop_width 9
-#define hop_height 10
-const uint8_t hop[] PROGMEM = {0x05, 0x00, 0x07, 0x00, 0x05, 0x00, 0x38, 0x00, 0x28, 0x00,
-                               0x38, 0x00, 0xC0, 0x01, 0x40, 0x01, 0xC0, 0x01, 0x40, 0x00};
-
 // 📬 Mail / Message
 const uint8_t icon_mail[] PROGMEM = {
    0b11111111, // ████████ top border
@@ -42,7 +42,7 @@ int LatchingBacklight::beforeDeepSleep(void *unused)
 {
    // Contingency only
    // - pin wasn't set
-    if (pin != static_cast<uint8_t>(-1)) {
+    if (pin != (uint8_t)-1) {
        off();
        pinMode(pin, INPUT); // High impedance - unnecessary?
    } else
@@ -55,7 +55,7 @@ int LatchingBacklight::beforeDeepSleep(void *unused)
 // The effect on the backlight is the same; peek and latch are separated to simplify short vs long press button handling
 void LatchingBacklight::peek()
 {
-    assert(pin != static_cast<uint8_t>(-1));
+    assert(pin != (uint8_t)-1);
    digitalWrite(pin, logicActive); // On
    on = true;
    latched = false;
@@ -67,7 +67,7 @@ void LatchingBacklight::peek()
 // The effect on the backlight is the same; peek and latch are separated to simplify short vs long press button handling
 void LatchingBacklight::latch()
 {
-    assert(pin != static_cast<uint8_t>(-1));
+    assert(pin != (uint8_t)-1);

    // Blink if moving from peek to latch
    // Indicates to user that the transition has taken place
@@ -89,7 +89,7 @@ void LatchingBacklight::latch()
 // Suitable for ending both peek and latch
 void LatchingBacklight::off()
 {
-    assert(pin != static_cast<uint8_t>(-1));
+    assert(pin != (uint8_t)-1);
    digitalWrite(pin, !logicActive); // Off
    on = false;
    latched = false;
@@ -40,7 +40,7 @@ class LatchingBacklight
    CallbackObserver<LatchingBacklight, void *> deepSleepObserver =
        CallbackObserver<LatchingBacklight, void *>(this, &LatchingBacklight::beforeDeepSleep);

-    uint8_t pin = static_cast<uint8_t>(-1);
+    uint8_t pin = (uint8_t)-1;
    bool logicActive = HIGH; // Is light active HIGH or active LOW

    bool on = false;      // Is light on (either peek or latched)
@@ -1,5 +1,3 @@
-#include "graphics/niche/InkHUD/Tile.h"
-#include <cstdint>
 #ifdef MESHTASTIC_INCLUDE_INKHUD

 #include "./Applet.h"
@@ -34,7 +32,7 @@ void InkHUD::Applet::drawPixel(int16_t x, int16_t y, uint16_t color)
 {
    // Only render pixels if they fall within user's cropped region
    if (x >= cropLeft && x < (cropLeft + cropWidth) && y >= cropTop && y < (cropTop + cropHeight))
-        assignedTile->handleAppletPixel(x, y, static_cast<Color>(color));
+        assignedTile->handleAppletPixel(x, y, (Color)color);
 }

 // Link our applet to a tile
@@ -57,7 +55,7 @@ InkHUD::Tile *InkHUD::Applet::getTile()
 }

 // Draw the applet
-void InkHUD::Applet::render(bool full)
+void InkHUD::Applet::render()
 {
    assert(assignedTile);                              // Ensure that we have a tile
    assert(assignedTile->getAssignedApplet() == this); // Ensure that we have a reciprocal link with the tile
@@ -67,11 +65,10 @@ void InkHUD::Applet::render(bool full)
    wantRender = false;                                       // Flag set by requestUpdate
    wantAutoshow = false;                                     // Flag set by requestAutoShow. May or may not have been honored.
    wantUpdateType = Drivers::EInk::UpdateTypes::UNSPECIFIED; // Update type we wanted. May on may not have been granted.
-    wantFullRender = true;                                    // Default to a full render

    updateDimensions();
    resetDrawingSpace();
-    onRender(full); // Draw the applet
+    onRender(); // Derived applet's drawing takes place here

    // Handle "Tile Highlighting"
    // Some devices may use an auxiliary button to switch between tiles
@@ -118,11 +115,6 @@ Drivers::EInk::UpdateTypes InkHUD::Applet::wantsUpdateType()
    return wantUpdateType;
 }

-bool InkHUD::Applet::wantsFullRender()
-{
-    return wantFullRender;
-}
-
 // Get size of the applet's drawing space from its tile
 // Performed immediately before derived applet's drawing code runs
 void InkHUD::Applet::updateDimensions()
@@ -144,32 +136,16 @@ void InkHUD::Applet::resetDrawingSpace()
    setFont(fontSmall);
 }

-// Sets one or more inputs to enabled/disabled for this applet and if they should be sent to it
-void InkHUD::Applet::setInputsSubscribed(uint8_t input, bool captured)
-{
-    if (captured)
-        subscribedInputs |= input;
-    else
-        subscribedInputs &= ~input;
-}
-
-// Checks if a specific input is enabled for this applet and should be sent to it
-bool InkHUD::Applet::isInputSubscribed(InputMask input)
-{
-    return (subscribedInputs & input) == input;
-}
-
 // Tell InkHUD::Renderer that we want to render now
 // Applets should internally listen for events they are interested in, via MeshModule, CallbackObserver etc
 // When an applet decides it has heard something important, and wants to redraw, it calls this method
 // Once the renderer has given other applets a chance to process whatever event we just detected,
 // it will run Applet::render(), which may draw our applet to screen, if it is shown (foreground)
 // We should requestUpdate even if our applet is currently background, because this might be changed by autoshow
-void InkHUD::Applet::requestUpdate(Drivers::EInk::UpdateTypes type, bool full)
+void InkHUD::Applet::requestUpdate(Drivers::EInk::UpdateTypes type)
 {
    wantRender = true;
    wantUpdateType = type;
-    wantFullRender = full;
    inkhud->requestUpdate();
 }

@@ -327,7 +303,7 @@ void InkHUD::Applet::printAt(int16_t x, int16_t y, const char *text, HorizontalA
 }

 // Print text, specifying the position of any edge / corner of the textbox
-void InkHUD::Applet::printAt(int16_t x, int16_t y, const std::string &text, HorizontalAlignment ha, VerticalAlignment va)
+void InkHUD::Applet::printAt(int16_t x, int16_t y, std::string text, HorizontalAlignment ha, VerticalAlignment va)
 {
    printAt(x, y, text.c_str(), ha, va);
 }
@@ -349,7 +325,7 @@ InkHUD::AppletFont InkHUD::Applet::getFont()

 // Parse any text which might have "special characters"
 // Re-encodes UTF-8 characters to match our 8-bit encoded fonts
-std::string InkHUD::Applet::parse(const std::string &text)
+std::string InkHUD::Applet::parse(std::string text)
 {
    return getFont().decodeUTF8(text);
 }
@@ -376,10 +352,10 @@ std::string InkHUD::Applet::parseShortName(meshtastic_NodeInfoLite *node)
 }

 // Determine if all characters of a string are printable using the current font
-bool InkHUD::Applet::isPrintable(const std::string &text)
+bool InkHUD::Applet::isPrintable(std::string text)
 {
    // Scan for SUB (0x1A), which is the value assigned by AppletFont::applyEncoding if a unicode character is not handled
-    for (const char &c : text) {
+    for (char &c : text) {
        if (c == '\x1A')
            return false;
    }
@@ -402,7 +378,7 @@ uint16_t InkHUD::Applet::getTextWidth(const char *text)

 // Gets rendered width of a string
 // Wrapper for getTextBounds
-uint16_t InkHUD::Applet::getTextWidth(const std::string &text)
+uint16_t InkHUD::Applet::getTextWidth(std::string text)
 {
    return getTextWidth(text.c_str());
 }
@@ -450,7 +426,7 @@ std::string InkHUD::Applet::hexifyNodeNum(NodeNum num)

 // Print text, with word wrapping
 // Avoids splitting words in half, instead moving the entire word to a new line wherever possible
-void InkHUD::Applet::printWrapped(int16_t left, int16_t top, uint16_t width, const std::string &text)
+void InkHUD::Applet::printWrapped(int16_t left, int16_t top, uint16_t width, std::string text)
 {
    // Place the AdafruitGFX cursor to suit our "top" coord
    setCursor(left, top + getFont().heightAboveCursor());
@@ -507,15 +483,15 @@ void InkHUD::Applet::printWrapped(int16_t left, int16_t top, uint16_t width, con

                // Todo: rewrite making use of AdafruitGFX native text wrapping
                char cstr[] = {0, 0};
-                int16_t bx, by;
-                uint16_t bw, bh;
+                int16_t l, t;
+                uint16_t w, h;
                for (uint16_t c = 0; c < word.length(); c++) {
                    // Shove next char into a c string
                    cstr[0] = word[c];
-                    getTextBounds(cstr, getCursorX(), getCursorY(), &bx, &by, &bw, &bh);
+                    getTextBounds(cstr, getCursorX(), getCursorY(), &l, &t, &w, &h);

                    // Manual newline, if next character will spill beyond screen edge
-                    if ((bx + bw) > left + width)
+                    if ((l + w) > left + width)
                        setCursor(left, getCursorY() + getFont().lineHeight());

                    // Print next character
@@ -534,7 +510,7 @@ void InkHUD::Applet::printWrapped(int16_t left, int16_t top, uint16_t width, con

 // Simulate running printWrapped, to determine how tall the block of text will be.
 // This is a wasteful way of handling things. Maybe some way to optimize in future?
-uint32_t InkHUD::Applet::getWrappedTextHeight(int16_t left, uint16_t width, const std::string &text)
+uint32_t InkHUD::Applet::getWrappedTextHeight(int16_t left, uint16_t width, std::string text)
 {
    // Cache the current crop region
    int16_t cL = cropLeft;
@@ -664,7 +640,7 @@ uint16_t InkHUD::Applet::getActiveNodeCount()

    // For each node in db
    for (uint16_t i = 0; i < nodeDB->getNumMeshNodes(); i++) {
-        const meshtastic_NodeInfoLite *node = nodeDB->getMeshNodeByIndex(i);
+        meshtastic_NodeInfoLite *node = nodeDB->getMeshNodeByIndex(i);

        // Check if heard recently, and not our own node
        if (sinceLastSeen(node) < settings->recentlyActiveSeconds && node->num != nodeDB->getNodeNum())
@@ -717,7 +693,7 @@ std::string InkHUD::Applet::localizeDistance(uint32_t meters)
 }

 // Print text with a "faux bold" effect, by drawing it multiple times, offsetting slightly
-void InkHUD::Applet::printThick(int16_t xCenter, int16_t yCenter, const std::string &text, uint8_t thicknessX, uint8_t thicknessY)
+void InkHUD::Applet::printThick(int16_t xCenter, int16_t yCenter, std::string text, uint8_t thicknessX, uint8_t thicknessY)
 {
    // How many times to draw along x axis
    int16_t xStart;
@@ -785,7 +761,7 @@ bool InkHUD::Applet::approveNotification(NicheGraphics::InkHUD::Notification &n)
 │                               │
 └───────────────────────────────┘
 */
-void InkHUD::Applet::drawHeader(const std::string &text)
+void InkHUD::Applet::drawHeader(std::string text)
 {
    // Y position for divider
    // - between header text and messages
@@ -802,16 +778,6 @@ void InkHUD::Applet::drawHeader(const std::string &text)
        drawPixel(x, 0, BLACK);
        drawPixel(x, headerDivY, BLACK); // Dotted 50%
    }
-
-    // Dither near battery
-    if (settings->optionalFeatures.batteryIcon) {
-        constexpr uint16_t ditherSizePx = 4;
-        Tile *batteryTile = ((Applet *)inkhud->getSystemApplet("BatteryIcon"))->getTile();
-        const uint16_t batteryTileLeft = batteryTile->getLeft();
-        const uint16_t batteryTileTop = batteryTile->getTop();
-        const uint16_t batteryTileHeight = batteryTile->getHeight();
-        hatchRegion(batteryTileLeft - ditherSizePx, batteryTileTop, ditherSizePx, batteryTileHeight, 2, WHITE);
-    }
 }

 // Get the height of the standard applet header
@@ -64,11 +64,10 @@ class Applet : public GFX

    // Rendering

-    void render(bool full);                       // Draw the applet
+    void render();                                // Draw the applet
    bool wantsToRender();                         // Check whether applet wants to render
    bool wantsToAutoshow();                       // Check whether applet wants to become foreground
    Drivers::EInk::UpdateTypes wantsUpdateType(); // Check which display update type the applet would prefer
-    bool wantsFullRender();                       // Check whether applet wants to render over its previous render
    void updateDimensions();                      // Get current size from tile
    void resetDrawingSpace();                     // Makes sure every render starts with same parameters

@@ -83,15 +82,12 @@ class Applet : public GFX

    // Event handlers

-    virtual void onRender(bool full) = 0; // For drawing the applet
+    virtual void onRender() = 0; // All drawing happens here
    virtual void onActivate() {}
    virtual void onDeactivate() {}
    virtual void onForeground() {}
    virtual void onBackground() {}
    virtual void onShutdown() {}
-
-    // Input Events
-
    virtual void onButtonShortPress() {}
    virtual void onButtonLongPress() {}
    virtual void onExitShort() {}
@@ -100,21 +96,6 @@ class Applet : public GFX
    virtual void onNavDown() {}
    virtual void onNavLeft() {}
    virtual void onNavRight() {}
-    virtual void onFreeText(char c) {}
-    virtual void onFreeTextDone() {}
-    virtual void onFreeTextCancel() {}
-    // List of inputs which can be subscribed to
-    enum InputMask {      // | No Joystick  |     With Joystick     |
-        BUTTON_SHORT = 1, // | Button Click | Joystick Center Click |
-        BUTTON_LONG = 2,  // | Button Hold  | Joystick Center Hold  |
-        EXIT_SHORT = 4,   // | no-op        | Back Button Click     |
-        EXIT_LONG = 8,    // | no-op        | Back Button Hold      |
-        NAV_UP = 16,      // | no-op        | Joystick Up           |
-        NAV_DOWN = 32,    // | no-op        | Joystick Down         |
-        NAV_LEFT = 64,    // | no-op        | Joystick Left         |
-        NAV_RIGHT = 128   // | no-op        | Joystick Right        |
-    };
-    bool isInputSubscribed(InputMask input); // Check if input should be handled by applet, this should not be overloaded.

    virtual bool approveNotification(Notification &n); // Allow an applet to veto a notification

@@ -127,37 +108,28 @@ class Applet : public GFX
  protected:
    void drawPixel(int16_t x, int16_t y, uint16_t color) override; // Place a single pixel. All drawing output passes through here

-    void requestUpdate(EInk::UpdateTypes type = EInk::UpdateTypes::UNSPECIFIED,
-                       bool full = true); // Ask WindowManager to schedule a display update
-    void requestAutoshow();               // Ask for applet to be moved to foreground
+    void requestUpdate(EInk::UpdateTypes type = EInk::UpdateTypes::UNSPECIFIED); // Ask WindowManager to schedule a display update
+    void requestAutoshow();                                                      // Ask for applet to be moved to foreground

    uint16_t X(float f);                                                      // Map applet width, mapped from 0 to 1.0
    uint16_t Y(float f);                                                      // Map applet height, mapped from 0 to 1.0
    void setCrop(int16_t left, int16_t top, uint16_t width, uint16_t height); // Ignore pixels drawn outside a certain region
    void resetCrop();                                                         // Removes setCrop()

-    // User Input Handling
-
-    uint8_t subscribedInputs = 0b00000000; // Maybe uint16_t for futureproofing? other devices may need more inputs
-    void setInputsSubscribed(uint8_t input,
-                             bool captured); // Set if an input should be handled by applet or not, this should not be
-                                             // overloaded. Can take multiple inputs at once if you OR/`|` them together
-
    // Text

    void setFont(AppletFont f);
    AppletFont getFont();
-    uint16_t getTextWidth(const std::string &text);
+    uint16_t getTextWidth(std::string text);
    uint16_t getTextWidth(const char *text);
-    uint32_t getWrappedTextHeight(int16_t left, uint16_t width, const std::string &text); // Result of printWrapped
+    uint32_t getWrappedTextHeight(int16_t left, uint16_t width, std::string text); // Result of printWrapped
    void printAt(int16_t x, int16_t y, const char *text, HorizontalAlignment ha = LEFT, VerticalAlignment va = TOP);
-    void printAt(int16_t x, int16_t y, const std::string &text, HorizontalAlignment ha = LEFT, VerticalAlignment va = TOP);
-    void printThick(int16_t xCenter, int16_t yCenter, const std::string &text, uint8_t thicknessX,
-                    uint8_t thicknessY);                                                   // Faux bold
-    void printWrapped(int16_t left, int16_t top, uint16_t width, const std::string &text); // Per-word line wrapping
+    void printAt(int16_t x, int16_t y, std::string text, HorizontalAlignment ha = LEFT, VerticalAlignment va = TOP);
+    void printThick(int16_t xCenter, int16_t yCenter, std::string text, uint8_t thicknessX, uint8_t thicknessY); // Faux bold
+    void printWrapped(int16_t left, int16_t top, uint16_t width, std::string text); // Per-word line wrapping

    void hatchRegion(int16_t x, int16_t y, uint16_t w, uint16_t h, uint8_t spacing, Color color); // Fill with sparse lines
-    void drawHeader(const std::string &text); // Draw the standard applet header
+    void drawHeader(std::string text); // Draw the standard applet header

    // Meshtastic Logo

@@ -173,9 +145,9 @@ class Applet : public GFX
    std::string getTimeString();                               // Current time, human readable
    uint16_t getActiveNodeCount();                             // Duration determined by user, in onscreen menu
    std::string localizeDistance(uint32_t meters);             // Human readable distance, imperial or metric
-    std::string parse(const std::string &text);                // Handle text which might contain special chars
+    std::string parse(std::string text);                       // Handle text which might contain special chars
    std::string parseShortName(meshtastic_NodeInfoLite *node); // Get the shortname, or a substitute if has unprintable chars
-    bool isPrintable(const std::string &text);                 // Check for characters which the font can't print
+    bool isPrintable(std::string);                             // Check for characters which the font can't print

    // Convenient references

@@ -192,7 +164,6 @@ class Applet : public GFX
    bool wantAutoshow = false; // Does the applet have new data it would like to display in foreground?
    NicheGraphics::Drivers::EInk::UpdateTypes wantUpdateType =
        NicheGraphics::Drivers::EInk::UpdateTypes::UNSPECIFIED; // Which update method we'd prefer when redrawing the display
-    bool wantFullRender = true;                                 // Render with a fresh canvas

    using GFX::setFont;     // Make sure derived classes use AppletFont instead of AdafruitGFX fonts directly
    using GFX::setRotation; // Block setRotation calls. Rotation is handled globally by WindowManager.
@@ -39,11 +39,11 @@ InkHUD::AppletFont::AppletFont(const GFXfont &adafruitGFXFont, Encoding encoding
        // Caution: signed and unsigned types
        int8_t glyphAscender = 0 - gfxFont->glyph[i].yOffset;
        if (glyphAscender > 0)
-            this->ascenderHeight = max(this->ascenderHeight, static_cast<uint8_t>(glyphAscender));
+            this->ascenderHeight = max(this->ascenderHeight, (uint8_t)glyphAscender);

        int8_t glyphDescender = gfxFont->glyph[i].height + gfxFont->glyph[i].yOffset;
        if (glyphDescender > 0)
-            this->descenderHeight = max(this->descenderHeight, static_cast<uint8_t>(glyphDescender));
+            this->descenderHeight = max(this->descenderHeight, (uint8_t)glyphDescender);
    }

    // Apply any manual padding to grow or shrink the line size
@@ -52,7 +52,7 @@ InkHUD::AppletFont::AppletFont(const GFXfont &adafruitGFXFont, Encoding encoding
    descenderHeight += paddingBottom;

    // Find how far the cursor advances when we "print" a space character
-    spaceCharWidth = gfxFont->glyph[static_cast<uint8_t>(' ') - gfxFont->first].xAdvance;
+    spaceCharWidth = gfxFont->glyph[(uint8_t)' ' - gfxFont->first].xAdvance;
 }

 /*
@@ -98,7 +98,7 @@ uint8_t InkHUD::AppletFont::widthBetweenWords()

 // Convert a unicode char from set of UTF-8 bytes to UTF-32
 // Used by AppletFont::applyEncoding, which remaps unicode chars for extended ASCII fonts, based on their UTF-32 value
-uint32_t InkHUD::AppletFont::toUtf32(const std::string &utf8)
+uint32_t InkHUD::AppletFont::toUtf32(std::string utf8)
 {
    uint32_t utf32 = 0;

@@ -132,7 +132,7 @@ uint32_t InkHUD::AppletFont::toUtf32(const std::string &utf8)

 // Process a string, collating UTF-8 bytes, and sending them off for re-encoding to extended ASCII
 // Not all InkHUD text is passed through here, only text which could potentially contain non-ASCII chars
-std::string InkHUD::AppletFont::decodeUTF8(const std::string &encoded)
+std::string InkHUD::AppletFont::decodeUTF8(std::string encoded)
 {
    // Final processed output
    std::string decoded;
@@ -141,7 +141,7 @@ std::string InkHUD::AppletFont::decodeUTF8(const std::string &encoded)
    std::string utf8Char;
    uint8_t utf8CharSize = 0;

-    for (const char &c : encoded) {
+    for (char &c : encoded) {

        // If first byte
        if (utf8Char.empty()) {
@@ -178,7 +178,7 @@ std::string InkHUD::AppletFont::decodeUTF8(const std::string &encoded)

 // Re-encode a single UTF-8 character to extended ASCII
 // Target encoding depends on the font
-char InkHUD::AppletFont::applyEncoding(const std::string &utf8)
+char InkHUD::AppletFont::applyEncoding(std::string utf8)
 {
    // ##################################################### Syntactic Sugar #####################################################
 #define REMAP(in, out)                                                                                                           \
@@ -30,21 +30,20 @@ class AppletFont
    };

    AppletFont();
-    explicit AppletFont(const GFXfont &adafruitGFXFont, Encoding encoding = ASCII, int8_t paddingTop = 0,
-                        int8_t paddingBottom = 0);
+    AppletFont(const GFXfont &adafruitGFXFont, Encoding encoding = ASCII, int8_t paddingTop = 0, int8_t paddingBottom = 0);

    uint8_t lineHeight();
    uint8_t heightAboveCursor();
    uint8_t heightBelowCursor();
    uint8_t widthBetweenWords(); // Width of the space character

-    std::string decodeUTF8(const std::string &encoded);
+    std::string decodeUTF8(std::string encoded);

-    const GFXfont *gfxFont = nullptr; // Default value: in-built AdafruitGFX font
+    const GFXfont *gfxFont = NULL; // Default value: in-built AdafruitGFX font

  private:
-    uint32_t toUtf32(const std::string &utf8);
-    char applyEncoding(const std::string &utf8);
+    uint32_t toUtf32(std::string utf8);
+    char applyEncoding(std::string utf8);

    uint8_t height = 8;          // Default value: in-built AdafruitGFX font
    uint8_t ascenderHeight = 0;  // Default value: in-built AdafruitGFX font
@@ -4,7 +4,7 @@

 using namespace NicheGraphics;

-void InkHUD::MapApplet::onRender(bool full)
+void InkHUD::MapApplet::onRender()
 {
    // Abort if no markers to render
    if (!enoughMarkers()) {
@@ -27,7 +27,7 @@ namespace NicheGraphics::InkHUD
 class MapApplet : public Applet
 {
  public:
-    void onRender(bool full) override;
+    void onRender() override;

  protected:
    virtual bool shouldDrawNode(meshtastic_NodeInfoLite *node) { return true; } // Allow derived applets to filter the nodes
@@ -81,29 +81,29 @@ ProcessMessage InkHUD::NodeListApplet::handleReceived(const meshtastic_MeshPacke
 uint8_t InkHUD::NodeListApplet::maxCards()
 {
    // Cache result. Shouldn't change during execution
-    static uint8_t maxCardCount = 0;
+    static uint8_t cards = 0;

-    if (!maxCardCount) {
+    if (!cards) {
        const uint16_t height = Tile::maxDisplayDimension();

        // Use a loop instead of arithmetic, because it's easier for my brain to follow
        // Add cards one by one, until the latest card extends below screen

        uint16_t y = cardH; // First card: no margin above
-        maxCardCount = 1;
+        cards = 1;

        while (y < height) {
            y += cardMarginH;
            y += cardH;
-            maxCardCount++;
+            cards++;
        }
    }

-    return maxCardCount;
+    return cards;
 }

 // Draw, using info which derived applet placed into NodeListApplet::cards for us
-void InkHUD::NodeListApplet::onRender(bool full)
+void InkHUD::NodeListApplet::onRender()
 {

    // ================================
@@ -137,12 +137,12 @@ void InkHUD::NodeListApplet::onRender(bool full)

        // Gather info
        // ========================================
-        const NodeNum &nodeNum = card->nodeNum;
+        NodeNum &nodeNum = card->nodeNum;
        SignalStrength &signal = card->signal;
        std::string longName;  // handled below
        std::string shortName; // handled below
        std::string distance;  // handled below;
-        const uint8_t &hopsAway = card->hopsAway;
+        uint8_t &hopsAway = card->hopsAway;

        meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeNum);

@@ -46,7 +46,7 @@ class NodeListApplet : public Applet, public MeshModule
  public:
    NodeListApplet(const char *name);

-    void onRender(bool full) override;
+    void onRender() override;

    bool wantPacket(const meshtastic_MeshPacket *p) override;
    ProcessMessage handleReceived(const meshtastic_MeshPacket &mp) override;
@@ -6,7 +6,7 @@ using namespace NicheGraphics;

 // All drawing happens here
 // Our basic example doesn't do anything useful. It just passively prints some text.
-void InkHUD::BasicExampleApplet::onRender(bool full)
+void InkHUD::BasicExampleApplet::onRender()
 {
    printAt(0, 0, "Hello, World!");

@@ -28,7 +28,7 @@ class BasicExampleApplet : public Applet
    // You must have an onRender() method
    // All drawing happens here

-    void onRender(bool full) override;
+    void onRender() override;
 };

 } // namespace NicheGraphics::InkHUD
@@ -35,7 +35,7 @@ ProcessMessage InkHUD::NewMsgExampleApplet::handleReceived(const meshtastic_Mesh
 // We can trigger a render by calling requestUpdate()
 // Render might be called by some external source
 // We should always be ready to draw
-void InkHUD::NewMsgExampleApplet::onRender(bool full)
+void InkHUD::NewMsgExampleApplet::onRender()
 {
    printAt(0, 0, "Example: NewMsg", LEFT, TOP); // Print top-left corner of text at (0,0)

@@ -34,7 +34,7 @@ class NewMsgExampleApplet : public Applet, public SinglePortModule
    NewMsgExampleApplet() : SinglePortModule("NewMsgExampleApplet", meshtastic_PortNum_TEXT_MESSAGE_APP) {}

    // All drawing happens here
-    void onRender(bool full) override;
+    void onRender() override;

    // Your applet might also want to use some of these
    // Useful for setting up or tidying up
@@ -1,79 +0,0 @@
-#ifdef MESHTASTIC_INCLUDE_INKHUD
-#include "./UserAppletInputExample.h"
-
-using namespace NicheGraphics;
-
-void InkHUD::UserAppletInputExampleApplet::onActivate()
-{
-    setGrabbed(false);
-}
-
-void InkHUD::UserAppletInputExampleApplet::onRender(bool full)
-{
-    drawHeader("Input Example");
-    uint16_t headerHeight = getHeaderHeight();
-
-    std::string buttonName;
-    if (settings->joystick.enabled)
-        buttonName = "joystick center button";
-    else
-        buttonName = "user button";
-
-    std::string additional = " | Control is grabbed, long press " + buttonName + " to release controls";
-    if (!isGrabbed)
-        additional = " | Control is released, long press " + buttonName + " to grab controls";
-
-    printWrapped(0, headerHeight, width(), "Last button: " + lastInput + additional);
-}
-
-void InkHUD::UserAppletInputExampleApplet::setGrabbed(bool grabbed)
-{
-    isGrabbed = grabbed;
-    setInputsSubscribed(BUTTON_SHORT | EXIT_SHORT | EXIT_LONG | NAV_UP | NAV_DOWN | NAV_LEFT | NAV_RIGHT,
-                        grabbed);           // Enables/disables grabbing all inputs
-    setInputsSubscribed(BUTTON_LONG, true); // Always grab this input
-}
-
-void InkHUD::UserAppletInputExampleApplet::onButtonShortPress()
-{
-    lastInput = "BUTTON_SHORT";
-    requestUpdate();
-}
-void InkHUD::UserAppletInputExampleApplet::onButtonLongPress()
-{
-    lastInput = "BUTTON_LONG";
-    setGrabbed(!isGrabbed);
-    requestUpdate();
-}
-void InkHUD::UserAppletInputExampleApplet::onExitShort()
-{
-    lastInput = "EXIT_SHORT";
-    requestUpdate();
-}
-void InkHUD::UserAppletInputExampleApplet::onExitLong()
-{
-    lastInput = "EXIT_LONG";
-    requestUpdate();
-}
-void InkHUD::UserAppletInputExampleApplet::onNavUp()
-{
-    lastInput = "NAV_UP";
-    requestUpdate();
-}
-void InkHUD::UserAppletInputExampleApplet::onNavDown()
-{
-    lastInput = "NAV_DOWN";
-    requestUpdate();
-}
-void InkHUD::UserAppletInputExampleApplet::onNavLeft()
-{
-    lastInput = "NAV_LEFT";
-    requestUpdate();
-}
-void InkHUD::UserAppletInputExampleApplet::onNavRight()
-{
-    lastInput = "NAV_RIGHT";
-    requestUpdate();
-}
-
-#endif
@@ -1,36 +0,0 @@
-#ifdef MESHTASTIC_INCLUDE_INKHUD
-
-#pragma once
-
-#include "configuration.h"
-
-#include "graphics/niche/InkHUD/Applet.h"
-
-namespace NicheGraphics::InkHUD
-{
-
-class UserAppletInputExampleApplet : public Applet
-{
-  public:
-    void onActivate() override;
-
-    void onRender(bool full) override;
-    void onButtonShortPress() override;
-    void onButtonLongPress() override;
-    void onExitShort() override;
-    void onExitLong() override;
-    void onNavUp() override;
-    void onNavDown() override;
-    void onNavLeft() override;
-    void onNavRight() override;
-
-  private:
-    std::string lastInput = "None";
-    bool isGrabbed = false;
-
-    void setGrabbed(bool grabbed);
-};
-
-} // namespace NicheGraphics::InkHUD
-
-#endif
@@ -10,7 +10,7 @@ InkHUD::AlignStickApplet::AlignStickApplet()
        bringToForeground();
 }

-void InkHUD::AlignStickApplet::onRender(bool full)
+void InkHUD::AlignStickApplet::onRender()
 {
    setFont(fontMedium);
    printAt(0, 0, "Align Joystick:");
@@ -152,17 +152,19 @@ void InkHUD::AlignStickApplet::onBackground()

    // Need to force an update, as a polite request wouldn't be honored, seeing how we are now in the background
    // Usually, onBackground is followed by another applet's onForeground (which requests update), but not in this case
-    inkhud->forceUpdate(EInk::UpdateTypes::FULL, true);
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
 }

 void InkHUD::AlignStickApplet::onButtonLongPress()
 {
    sendToBackground();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
 }

 void InkHUD::AlignStickApplet::onExitLong()
 {
    sendToBackground();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
 }

 void InkHUD::AlignStickApplet::onNavUp()
@@ -170,6 +172,7 @@ void InkHUD::AlignStickApplet::onNavUp()
    settings->joystick.aligned = true;

    sendToBackground();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
 }

 void InkHUD::AlignStickApplet::onNavDown()
@@ -178,6 +181,7 @@ void InkHUD::AlignStickApplet::onNavDown()
    settings->joystick.aligned = true;

    sendToBackground();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
 }

 void InkHUD::AlignStickApplet::onNavLeft()
@@ -186,6 +190,7 @@ void InkHUD::AlignStickApplet::onNavLeft()
    settings->joystick.aligned = true;

    sendToBackground();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
 }

 void InkHUD::AlignStickApplet::onNavRight()
@@ -194,6 +199,7 @@ void InkHUD::AlignStickApplet::onNavRight()
    settings->joystick.aligned = true;

    sendToBackground();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
 }

 #endif
@@ -23,7 +23,7 @@ class AlignStickApplet : public SystemApplet
  public:
    AlignStickApplet();

-    void onRender(bool full) override;
+    void onRender() override;
    void onForeground() override;
    void onBackground() override;
    void onButtonLongPress() override;
@@ -6,8 +6,6 @@ using namespace NicheGraphics;

 InkHUD::BatteryIconApplet::BatteryIconApplet()
 {
-    alwaysRender = true; // render everytime the screen is updated
-
    // Show at boot, if user has previously enabled the feature
    if (settings->optionalFeatures.batteryIcon)
        bringToForeground();
@@ -29,10 +27,10 @@ int InkHUD::BatteryIconApplet::onPowerStatusUpdate(const meshtastic::Status *sta
    // If we get a different type of status, something has gone weird elsewhere
    assert(status->getStatusType() == STATUS_TYPE_POWER);

-    const meshtastic::PowerStatus *pwrStatus = (const meshtastic::PowerStatus *)status;
+    meshtastic::PowerStatus *powerStatus = (meshtastic::PowerStatus *)status;

    // Get the new state of charge %, and round to the nearest 10%
-    uint8_t newSocRounded = ((pwrStatus->getBatteryChargePercent() + 5) / 10) * 10;
+    uint8_t newSocRounded = ((powerStatus->getBatteryChargePercent() + 5) / 10) * 10;

    // If rounded value has changed, trigger a display update
    // It's okay to requestUpdate before we store the new value, as the update won't run until next loop()
@@ -46,29 +44,39 @@ int InkHUD::BatteryIconApplet::onPowerStatusUpdate(const meshtastic::Status *sta
    return 0; // Tell Observable to continue informing other observers
 }

-void InkHUD::BatteryIconApplet::onRender(bool full)
+void InkHUD::BatteryIconApplet::onRender()
 {
-    // Clear the region beneath the tile, including the border
+    // Fill entire tile
+    // - size of icon controlled by size of tile
+    int16_t l = 0;
+    int16_t t = 0;
+    uint16_t w = width();
+    int16_t h = height();
+
+    // Clear the region beneath the tile
    // Most applets are drawing onto an empty frame buffer and don't need to do this
    // We do need to do this with the battery though, as it is an "overlay"
-    fillRect(0, 0, width(), height(), WHITE);
+    fillRect(l, t, w, h, WHITE);
+
+    // Vertical centerline
+    const int16_t m = t + (h / 2);

    // =====================
    // Draw battery outline
    // =====================

    // Positive terminal "bump"
+    const int16_t &bumpL = l;
+    const uint16_t bumpH = h / 2;
+    const int16_t bumpT = m - (bumpH / 2);
    constexpr uint16_t bumpW = 2;
-    const int16_t &bumpL = 1;
-    const uint16_t bumpH = (height() - 2) / 2;
-    const int16_t bumpT = (1 + ((height() - 2) / 2)) - (bumpH / 2);
    fillRect(bumpL, bumpT, bumpW, bumpH, BLACK);

    // Main body of battery
-    const int16_t bodyL = 1 + bumpW;
-    const int16_t &bodyT = 1;
-    const int16_t &bodyH = height() - 2;         // Handle top/bottom padding
-    const int16_t bodyW = (width() - 1) - bumpW; // Handle 1px left pad
+    const int16_t bodyL = bumpL + bumpW;
+    const int16_t &bodyT = t;
+    const int16_t &bodyH = h;
+    const int16_t bodyW = w - bumpW;
    drawRect(bodyL, bodyT, bodyW, bodyH, BLACK);

    // Erase join between bump and body
@@ -79,13 +87,12 @@ void InkHUD::BatteryIconApplet::onRender(bool full)
    // ===================

    constexpr int16_t slicePad = 2;
-    int16_t sliceL = bodyL + slicePad;
+    const int16_t sliceL = bodyL + slicePad;
    const int16_t sliceT = bodyT + slicePad;
    const uint16_t sliceH = bodyH - (slicePad * 2);
    uint16_t sliceW = bodyW - (slicePad * 2);

-    sliceW = (sliceW * socRounded) / 100;          // Apply percentage
-    sliceL += ((bodyW - (slicePad * 2)) - sliceW); // Shift slice to the battery's negative terminal, correcting drain direction
+    sliceW = (sliceW * socRounded) / 100; // Apply percentage

    hatchRegion(sliceL, sliceT, sliceW, sliceH, 2, BLACK);
    drawRect(sliceL, sliceT, sliceW, sliceH, BLACK);
@@ -23,7 +23,7 @@ class BatteryIconApplet : public SystemApplet
  public:
    BatteryIconApplet();

-    void onRender(bool full) override;
+    void onRender() override;
    int onPowerStatusUpdate(const meshtastic::Status *status); // Called when new info about battery is available

  private:
@@ -1,257 +0,0 @@
-#ifdef MESHTASTIC_INCLUDE_INKHUD
-#include "./KeyboardApplet.h"
-
-using namespace NicheGraphics;
-
-InkHUD::KeyboardApplet::KeyboardApplet()
-{
-    // Calculate row widths
-    for (uint8_t row = 0; row < KBD_ROWS; row++) {
-        rowWidths[row] = 0;
-        for (uint8_t col = 0; col < KBD_COLS; col++)
-            rowWidths[row] += keyWidths[row * KBD_COLS + col];
-    }
-}
-
-void InkHUD::KeyboardApplet::onRender(bool full)
-{
-    uint16_t em = fontSmall.lineHeight(); // 16 pt
-    uint16_t keyH = Y(1.0) / KBD_ROWS;
-    int16_t keyTopPadding = (keyH - fontSmall.lineHeight()) / 2;
-
-    if (full) { // Draw full keyboard
-        for (uint8_t row = 0; row < KBD_ROWS; row++) {
-
-            // Calculate the remaining space to be used as padding
-            int16_t keyXPadding = X(1.0) - ((rowWidths[row] * em) >> 4);
-
-            // Draw keys
-            uint16_t xPos = 0;
-            for (uint8_t col = 0; col < KBD_COLS; col++) {
-                Color fgcolor = BLACK;
-                uint8_t index = row * KBD_COLS + col;
-                uint16_t keyX = ((xPos * em) >> 4) + ((col * keyXPadding) / (KBD_COLS - 1));
-                uint16_t keyY = row * keyH;
-                uint16_t keyW = (keyWidths[index] * em) >> 4;
-                if (index == selectedKey) {
-                    fgcolor = WHITE;
-                    fillRect(keyX, keyY, keyW, keyH, BLACK);
-                }
-                drawKeyLabel(keyX, keyY + keyTopPadding, keyW, keys[index], fgcolor);
-                xPos += keyWidths[index];
-            }
-        }
-    } else { // Only draw the difference
-        if (selectedKey != prevSelectedKey) {
-            // Draw previously selected key
-            uint8_t row = prevSelectedKey / KBD_COLS;
-            int16_t keyXPadding = X(1.0) - ((rowWidths[row] * em) >> 4);
-            uint16_t xPos = 0;
-            for (uint8_t i = prevSelectedKey - (prevSelectedKey % KBD_COLS); i < prevSelectedKey; i++)
-                xPos += keyWidths[i];
-            uint16_t keyX = ((xPos * em) >> 4) + (((prevSelectedKey % KBD_COLS) * keyXPadding) / (KBD_COLS - 1));
-            uint16_t keyY = row * keyH;
-            uint16_t keyW = (keyWidths[prevSelectedKey] * em) >> 4;
-            fillRect(keyX, keyY, keyW, keyH, WHITE);
-            drawKeyLabel(keyX, keyY + keyTopPadding, keyW, keys[prevSelectedKey], BLACK);
-
-            // Draw newly selected key
-            row = selectedKey / KBD_COLS;
-            keyXPadding = X(1.0) - ((rowWidths[row] * em) >> 4);
-            xPos = 0;
-            for (uint8_t i = selectedKey - (selectedKey % KBD_COLS); i < selectedKey; i++)
-                xPos += keyWidths[i];
-            keyX = ((xPos * em) >> 4) + (((selectedKey % KBD_COLS) * keyXPadding) / (KBD_COLS - 1));
-            keyY = row * keyH;
-            keyW = (keyWidths[selectedKey] * em) >> 4;
-            fillRect(keyX, keyY, keyW, keyH, BLACK);
-            drawKeyLabel(keyX, keyY + keyTopPadding, keyW, keys[selectedKey], WHITE);
-        }
-    }
-
-    prevSelectedKey = selectedKey;
-}
-
-// Draw the key label corresponding to the char
-// for most keys it draws the character itself
-// for ['\b', '\n', ' ', '\x1b'] it draws special glyphs
-void InkHUD::KeyboardApplet::drawKeyLabel(uint16_t left, uint16_t top, uint16_t width, char key, Color color)
-{
-    if (key == '\b') {
-        // Draw backspace glyph: 13 x 9 px
-        /**
-         *         [][][][][][][][][]
-         *       [][]              []
-         *     [][]    []      []  []
-         *   [][]        []  []    []
-         * [][]            []      []
-         *   [][]        []  []    []
-         *     [][]    []      []  []
-         *       [][]              []
-         *         [][][][][][][][][]
-         */
-        const uint8_t bsBitmap[] = {0x0f, 0xf8, 0x18, 0x08, 0x32, 0x28, 0x61, 0x48, 0xc0,
-                                    0x88, 0x61, 0x48, 0x32, 0x28, 0x18, 0x08, 0x0f, 0xf8};
-        uint16_t leftPadding = (width - 13) >> 1;
-        drawBitmap(left + leftPadding, top + 1, bsBitmap, 13, 9, color);
-    } else if (key == '\n') {
-        // Draw done glyph: 12 x 9 px
-        /**
-         *                     [][]
-         *                   [][]
-         *                 [][]
-         *               [][]
-         *             [][]
-         * [][]      [][]
-         *   [][]  [][]
-         *     [][][]
-         *       []
-         */
-        const uint8_t doneBitmap[] = {0x00, 0x30, 0x00, 0x60, 0x00, 0xc0, 0x01, 0x80, 0x03,
-                                      0x00, 0xc6, 0x00, 0x6c, 0x00, 0x38, 0x00, 0x10, 0x00};
-        uint16_t leftPadding = (width - 12) >> 1;
-        drawBitmap(left + leftPadding, top + 1, doneBitmap, 12, 9, color);
-    } else if (key == ' ') {
-        // Draw space glyph: 13 x 9 px
-        /**
-         *
-         *
-         *
-         *
-         * []                      []
-         * []                      []
-         * [][][][][][][][][][][][][]
-         *
-         *
-         */
-        const uint8_t spaceBitmap[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
-                                       0x08, 0x80, 0x08, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00};
-        uint16_t leftPadding = (width - 13) >> 1;
-        drawBitmap(left + leftPadding, top + 1, spaceBitmap, 13, 9, color);
-    } else if (key == '\x1b') {
-        setTextColor(color);
-        std::string keyText = "ESC";
-        uint16_t leftPadding = (width - getTextWidth(keyText)) >> 1;
-        printAt(left + leftPadding, top, keyText);
-    } else {
-        setTextColor(color);
-        if (key >= 0x61)
-            key -= 32; // capitalize
-        std::string keyText = std::string(1, key);
-        uint16_t leftPadding = (width - getTextWidth(keyText)) >> 1;
-        printAt(left + leftPadding, top, keyText);
-    }
-}
-
-void InkHUD::KeyboardApplet::onForeground()
-{
-    handleInput = true; // Intercept the button input for our applet
-
-    // Select the first key
-    selectedKey = 0;
-    prevSelectedKey = 0;
-}
-
-void InkHUD::KeyboardApplet::onBackground()
-{
-    handleInput = false;
-}
-
-void InkHUD::KeyboardApplet::onButtonShortPress()
-{
-    char key = keys[selectedKey];
-    if (key == '\n') {
-        inkhud->freeTextDone();
-        inkhud->closeKeyboard();
-    } else if (key == '\x1b') {
-        inkhud->freeTextCancel();
-        inkhud->closeKeyboard();
-    } else {
-        inkhud->freeText(key);
-    }
-}
-
-void InkHUD::KeyboardApplet::onButtonLongPress()
-{
-    char key = keys[selectedKey];
-    if (key == '\n') {
-        inkhud->freeTextDone();
-        inkhud->closeKeyboard();
-    } else if (key == '\x1b') {
-        inkhud->freeTextCancel();
-        inkhud->closeKeyboard();
-    } else {
-        if (key >= 0x61)
-            key -= 32; // capitalize
-        inkhud->freeText(key);
-    }
-}
-
-void InkHUD::KeyboardApplet::onExitShort()
-{
-    inkhud->freeTextCancel();
-    inkhud->closeKeyboard();
-}
-
-void InkHUD::KeyboardApplet::onExitLong()
-{
-    inkhud->freeTextCancel();
-    inkhud->closeKeyboard();
-}
-
-void InkHUD::KeyboardApplet::onNavUp()
-{
-    if (selectedKey < KBD_COLS) // wrap
-        selectedKey += KBD_COLS * (KBD_ROWS - 1);
-    else // move 1 row back
-        selectedKey -= KBD_COLS;
-
-    // Request rendering over the previously drawn render
-    requestUpdate(EInk::UpdateTypes::FAST, false);
-    // Force an update to bypass lockRequests
-    inkhud->forceUpdate(EInk::UpdateTypes::FAST);
-}
-
-void InkHUD::KeyboardApplet::onNavDown()
-{
-    selectedKey += KBD_COLS;
-    selectedKey %= (KBD_COLS * KBD_ROWS);
-
-    // Request rendering over the previously drawn render
-    requestUpdate(EInk::UpdateTypes::FAST, false);
-    // Force an update to bypass lockRequests
-    inkhud->forceUpdate(EInk::UpdateTypes::FAST);
-}
-
-void InkHUD::KeyboardApplet::onNavLeft()
-{
-    if (selectedKey % KBD_COLS == 0) // wrap
-        selectedKey += KBD_COLS - 1;
-    else // move 1 column back
-        selectedKey--;
-
-    // Request rendering over the previously drawn render
-    requestUpdate(EInk::UpdateTypes::FAST, false);
-    // Force an update to bypass lockRequests
-    inkhud->forceUpdate(EInk::UpdateTypes::FAST);
-}
-
-void InkHUD::KeyboardApplet::onNavRight()
-{
-    if (selectedKey % KBD_COLS == KBD_COLS - 1) // wrap
-        selectedKey -= KBD_COLS - 1;
-    else // move 1 column forward
-        selectedKey++;
-
-    // Request rendering over the previously drawn render
-    requestUpdate(EInk::UpdateTypes::FAST, false);
-    // Force an update to bypass lockRequests
-    inkhud->forceUpdate(EInk::UpdateTypes::FAST);
-}
-
-uint16_t InkHUD::KeyboardApplet::getKeyboardHeight()
-{
-    const uint16_t keyH = fontSmall.lineHeight() * 1.2;
-    return keyH * KBD_ROWS;
-}
-#endif
@@ -1,66 +0,0 @@
-#ifdef MESHTASTIC_INCLUDE_INKHUD
-
-/*
-
-System Applet to render an on-screeen keyboard
-
-*/
-
-#pragma once
-
-#include "configuration.h"
-#include "graphics/niche/InkHUD/InkHUD.h"
-#include "graphics/niche/InkHUD/SystemApplet.h"
-#include <string>
-namespace NicheGraphics::InkHUD
-{
-
-class KeyboardApplet : public SystemApplet
-{
-  public:
-    KeyboardApplet();
-
-    void onRender(bool full) override;
-    void onForeground() override;
-    void onBackground() override;
-    void onButtonShortPress() override;
-    void onButtonLongPress() override;
-    void onExitShort() override;
-    void onExitLong() override;
-    void onNavUp() override;
-    void onNavDown() override;
-    void onNavLeft() override;
-    void onNavRight() override;
-
-    static uint16_t getKeyboardHeight(); // used to set the keyboard tile height
-
-  private:
-    void drawKeyLabel(uint16_t left, uint16_t top, uint16_t width, char key, Color color);
-
-    static const uint8_t KBD_COLS = 11;
-    static const uint8_t KBD_ROWS = 4;
-
-    const char keys[KBD_COLS * KBD_ROWS] = {
-        '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '\b',  // row 0
-        'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p', '\n',  // row 1
-        'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', '!', ' ',   // row 2
-        'z', 'x', 'c', 'v', 'b', 'n', 'm', ',', '.', '?', '\x1b' // row 3
-    };
-
-    // This array represents the widths of each key in points
-    // 16 pt = line height of the text
-    const uint16_t keyWidths[KBD_COLS * KBD_ROWS] = {
-        16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 24, // row 0
-        16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 24, // row 1
-        16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 24, // row 2
-        16, 16, 16, 16, 16, 16, 16, 10, 10, 12, 40  // row 3
-    };
-
-    uint16_t rowWidths[KBD_ROWS];
-    uint8_t selectedKey = 0; // selected key index
-    uint8_t prevSelectedKey = 0;
-};
-
-} // namespace NicheGraphics::InkHUD
-
-#endif
@@ -30,7 +30,7 @@ InkHUD::LogoApplet::LogoApplet() : concurrency::OSThread("LogoApplet")
    // This is then drawn with a FULL refresh by Renderer::begin
 }

-void InkHUD::LogoApplet::onRender(bool full)
+void InkHUD::LogoApplet::onRender()
 {
    // Size  of the region which the logo should "scale to fit"
    uint16_t logoWLimit = X(0.8);
@@ -120,7 +120,7 @@ void InkHUD::LogoApplet::onBackground()

    // Need to force an update, as a polite request wouldn't be honored, seeing how we are now in the background
    // Usually, onBackground is followed by another applet's onForeground (which requests update), but not in this case
-    inkhud->forceUpdate(EInk::UpdateTypes::FULL, true);
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
 }

 // Begin displaying the screen which is shown at shutdown
@@ -138,10 +138,10 @@ void InkHUD::LogoApplet::onShutdown()
    // Intention is to restore display health.

    inverted = true;
-    inkhud->forceUpdate(Drivers::EInk::FULL, true, false);
+    inkhud->forceUpdate(Drivers::EInk::FULL, false);
    delay(1000); // Cooldown. Back to back updates aren't great for health.
    inverted = false;
-    inkhud->forceUpdate(Drivers::EInk::FULL, true, false);
+    inkhud->forceUpdate(Drivers::EInk::FULL, false);
    delay(1000); // Cooldown

    // Prepare for the powered-off screen now
@@ -176,7 +176,7 @@ void InkHUD::LogoApplet::onReboot()
    textTitle = "Rebooting...";
    fontTitle = fontSmall;

-    inkhud->forceUpdate(Drivers::EInk::FULL, true, false);
+    inkhud->forceUpdate(Drivers::EInk::FULL, false);
    // Perform the update right now, waiting here until complete
 }

@@ -21,7 +21,7 @@ class LogoApplet : public SystemApplet, public concurrency::OSThread
 {
  public:
    LogoApplet();
-    void onRender(bool full) override;
+    void onRender() override;
    void onForeground() override;
    void onBackground() override;
    void onShutdown() override;
@@ -19,10 +19,10 @@ namespace NicheGraphics::InkHUD
 enum MenuAction {
    NO_ACTION,
    SEND_PING,
-    FREE_TEXT,
    STORE_CANNEDMESSAGE_SELECTION,
    SEND_CANNEDMESSAGE,
    SHUTDOWN,
+    BACK,
    NEXT_TILE,
    TOGGLE_BACKLIGHT,
    TOGGLE_GPS,
@@ -90,8 +90,6 @@ void InkHUD::MenuApplet::onForeground()
    OSThread::setIntervalFromNow(MENU_TIMEOUT_SEC * 1000UL);
    OSThread::enabled = true;

-    freeTextMode = false;
-
    // Upgrade the refresh to FAST, for guaranteed responsiveness
    inkhud->forceUpdate(EInk::UpdateTypes::FAST);
 }
@@ -118,8 +116,6 @@ void InkHUD::MenuApplet::onBackground()
    SystemApplet::lockRequests = false;
    SystemApplet::handleInput = false;

-    handleFreeText = false;
-
    // Restore the user applet whose tile we borrowed
    if (borrowedTileOwner)
        borrowedTileOwner->bringToForeground();
@@ -329,6 +325,10 @@ void InkHUD::MenuApplet::execute(MenuItem item)
        }
        break;

+    case BACK:
+        showPage(item.nextPage);
+        return;
+
    case NEXT_TILE:
        inkhud->nextTile();
        // Unselect menu item after tile change
@@ -344,26 +344,12 @@ void InkHUD::MenuApplet::execute(MenuItem item)
        inkhud->forceUpdate(Drivers::EInk::UpdateTypes::FULL);
        break;

-    case FREE_TEXT:
-        OSThread::enabled = false;
-        handleFreeText = true;
-        cm.freeTextItem.rawText.erase(); // clear the previous freetext message
-        freeTextMode = true;             // render input field instead of normal menu
-        // Open the on-screen keyboard if the joystick is enabled
-        if (settings->joystick.enabled)
-            inkhud->openKeyboard();
-        break;
-
    case STORE_CANNEDMESSAGE_SELECTION:
-        if (!settings->joystick.enabled)
-            cm.selectedMessageItem = &cm.messageItems.at(cursor - 1); // Minus one: offset for the initial "Send Ping" entry
-        else
-            cm.selectedMessageItem = &cm.messageItems.at(cursor - 2); // Minus two: offset for the "Send Ping" and free text entry
+        cm.selectedMessageItem = &cm.messageItems.at(cursor - 1); // Minus one: offset for the initial "Send Ping" entry
        break;

    case SEND_CANNEDMESSAGE:
        cm.selectedRecipientItem = &cm.recipientItems.at(cursor);
-        // send selected message
        sendText(cm.selectedRecipientItem->dest, cm.selectedRecipientItem->channelIndex, cm.selectedMessageItem->rawText.c_str());
        inkhud->forceUpdate(Drivers::EInk::UpdateTypes::FULL); // Next refresh should be FULL. Lots of button pressing to get here
        break;
@@ -882,7 +868,6 @@ void InkHUD::MenuApplet::showPage(MenuPage page)

    switch (page) {
    case ROOT:
-        previousPage = MenuPage::EXIT;
        // Optional: next applet
        if (settings->optionalMenuItems.nextTile && settings->userTiles.count > 1)
            items.push_back(MenuItem("Next Tile", MenuAction::NEXT_TILE, MenuPage::ROOT)); // Only if multiple applets shown
@@ -893,6 +878,7 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
        items.push_back(MenuItem("Node Config", MenuPage::NODE_CONFIG));
        items.push_back(MenuItem("Save & Shut Down", MenuAction::SHUTDOWN));
        items.push_back(MenuItem("Exit", MenuPage::EXIT));
+        previousPage = MenuPage::EXIT;
        break;

    case SEND:
@@ -902,12 +888,11 @@ void InkHUD::MenuApplet::showPage(MenuPage page)

    case CANNEDMESSAGE_RECIPIENT:
        populateRecipientPage();
-        previousPage = MenuPage::SEND;
+        previousPage = MenuPage::OPTIONS;
        break;

    case OPTIONS:
-        previousPage = MenuPage::ROOT;
-        items.push_back(MenuItem("Back", previousPage));
+        items.push_back(MenuItem("Back", MenuAction::BACK, MenuPage::ROOT));
        // Optional: backlight
        if (settings->optionalMenuItems.backlight)
            items.push_back(MenuItem(backlight->isLatched() ? "Backlight Off" : "Keep Backlight On", // Label
@@ -931,32 +916,31 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
        invertedColors = (config.display.displaymode == meshtastic_Config_DisplayConfig_DisplayMode_INVERTED);
        items.push_back(MenuItem("Invert Color", MenuAction::TOGGLE_INVERT_COLOR, MenuPage::OPTIONS, &invertedColors));
        items.push_back(MenuItem("Exit", MenuPage::EXIT));
+        previousPage = MenuPage::ROOT;
        break;

    case APPLETS:
-        previousPage = MenuPage::OPTIONS;
        populateAppletPage(); // must be first
-        items.insert(items.begin(), MenuItem("Back", previousPage));
+        items.insert(items.begin(), MenuItem("Back", MenuAction::BACK, MenuPage::OPTIONS));
        items.push_back(MenuItem("Exit", MenuPage::EXIT));
+        previousPage = MenuPage::OPTIONS;
        break;

    case AUTOSHOW:
-        previousPage = MenuPage::OPTIONS;
        populateAutoshowPage(); // must be first
-        items.insert(items.begin(), MenuItem("Back", previousPage));
+        items.insert(items.begin(), MenuItem("Back", MenuAction::BACK, MenuPage::OPTIONS));
        items.push_back(MenuItem("Exit", MenuPage::EXIT));
+        previousPage = MenuPage::OPTIONS;
        break;

    case RECENTS:
-        previousPage = MenuPage::OPTIONS;
        populateRecentsPage(); // builds only the options
-        items.insert(items.begin(), MenuItem("Back", previousPage));
+        items.insert(items.begin(), MenuItem("Back", MenuAction::BACK, MenuPage::OPTIONS));
        items.push_back(MenuItem("Exit", MenuPage::EXIT));
        break;

    case NODE_CONFIG:
-        previousPage = MenuPage::ROOT;
-        items.push_back(MenuItem("Back", previousPage));
+        items.push_back(MenuItem("Back", MenuAction::BACK, MenuPage::ROOT));
        // Radio Config Section
        items.push_back(MenuItem::Header("Radio Config"));
        items.push_back(MenuItem("LoRa", MenuPage::NODE_CONFIG_LORA));
@@ -981,8 +965,8 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
        break;

    case NODE_CONFIG_DEVICE: {
-        previousPage = MenuPage::NODE_CONFIG;
-        items.push_back(MenuItem("Back", previousPage));
+
+        items.push_back(MenuItem("Back", MenuAction::BACK, MenuPage::NODE_CONFIG));

        const char *role = DisplayFormatters::getDeviceRole(config.device.role);
        nodeConfigLabels.emplace_back("Role: " + std::string(role));
@@ -997,8 +981,7 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
    }

    case NODE_CONFIG_POSITION: {
-        previousPage = MenuPage::NODE_CONFIG;
-        items.push_back(MenuItem("Back", previousPage));
+        items.push_back(MenuItem("Back", MenuAction::BACK, MenuPage::NODE_CONFIG));
 #if !MESHTASTIC_EXCLUDE_GPS && HAS_GPS
        const auto mode = config.position.gps_mode;
        if (mode == meshtastic_Config_PositionConfig_GpsMode_NOT_PRESENT) {
@@ -1013,8 +996,7 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
    }

    case NODE_CONFIG_POWER: {
-        previousPage = MenuPage::NODE_CONFIG;
-        items.push_back(MenuItem("Back", previousPage));
+        items.push_back(MenuItem("Back", MenuAction::BACK, MenuPage::NODE_CONFIG));
 #if defined(ARCH_ESP32)
        items.push_back(MenuItem("Powersave", MenuAction::TOGGLE_POWER_SAVE, MenuPage::EXIT, &config.power.is_power_saving));
 #endif
@@ -1047,8 +1029,7 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
    }

    case NODE_CONFIG_POWER_ADC_CAL: {
-        previousPage = MenuPage::NODE_CONFIG_POWER;
-        items.push_back(MenuItem("Back", previousPage));
+        items.push_back(MenuItem("Back", MenuAction::BACK, MenuPage::NODE_CONFIG_POWER));

        // Instruction text (header-style, non-selectable)
        items.push_back(MenuItem::Header("Run on full charge Only"));
@@ -1061,8 +1042,7 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
    }

    case NODE_CONFIG_NETWORK: {
-        previousPage = MenuPage::NODE_CONFIG;
-        items.push_back(MenuItem("Back", previousPage));
+        items.push_back(MenuItem("Back", MenuAction::BACK, MenuPage::NODE_CONFIG));

        const char *wifiLabel = config.network.wifi_enabled ? "WiFi: On" : "WiFi: Off";

@@ -1119,8 +1099,7 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
    }

    case NODE_CONFIG_DISPLAY: {
-        previousPage = MenuPage::NODE_CONFIG;
-        items.push_back(MenuItem("Back", previousPage));
+        items.push_back(MenuItem("Back", MenuAction::BACK, MenuPage::NODE_CONFIG));

        items.push_back(MenuItem("12-Hour Clock", MenuAction::TOGGLE_12H_CLOCK, MenuPage::NODE_CONFIG_DISPLAY,
                                 &config.display.use_12h_clock));
@@ -1135,8 +1114,7 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
    }

    case NODE_CONFIG_BLUETOOTH: {
-        previousPage = MenuPage::NODE_CONFIG;
-        items.push_back(MenuItem("Back", previousPage));
+        items.push_back(MenuItem("Back", MenuAction::BACK, MenuPage::NODE_CONFIG));

        const char *btLabel = config.bluetooth.enabled ? "Bluetooth: On" : "Bluetooth: Off";
        items.push_back(MenuItem(btLabel, MenuAction::TOGGLE_BLUETOOTH, MenuPage::EXIT));
@@ -1149,8 +1127,8 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
    }

    case NODE_CONFIG_LORA: {
-        previousPage = MenuPage::NODE_CONFIG;
-        items.push_back(MenuItem("Back", previousPage));
+
+        items.push_back(MenuItem("Back", MenuAction::BACK, MenuPage::NODE_CONFIG));

        const char *region = myRegion ? myRegion->name : "Unset";
        nodeConfigLabels.emplace_back("Region: " + std::string(region));
@@ -1172,11 +1150,10 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
    }

    case NODE_CONFIG_CHANNELS: {
-        previousPage = MenuPage::NODE_CONFIG;
-        items.push_back(MenuItem("Back", previousPage));
+        items.push_back(MenuItem("Back", MenuAction::BACK, MenuPage::NODE_CONFIG));

        for (uint8_t i = 0; i < MAX_NUM_CHANNELS; i++) {
-            const meshtastic_Channel &ch = channels.getByIndex(i);
+            meshtastic_Channel &ch = channels.getByIndex(i);

            if (!ch.has_settings)
                continue;
@@ -1204,8 +1181,7 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
    }

    case NODE_CONFIG_CHANNEL_DETAIL: {
-        previousPage = MenuPage::NODE_CONFIG_CHANNELS;
-        items.push_back(MenuItem("Back", previousPage));
+        items.push_back(MenuItem("Back", MenuAction::BACK, MenuPage::NODE_CONFIG_CHANNELS));

        meshtastic_Channel &ch = channels.getByIndex(selectedChannelIndex);

@@ -1250,9 +1226,8 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
    }

    case NODE_CONFIG_CHANNEL_PRECISION: {
-        previousPage = MenuPage::NODE_CONFIG_CHANNEL_DETAIL;
-        items.push_back(MenuItem("Back", previousPage));
-        const meshtastic_Channel &ch = channels.getByIndex(selectedChannelIndex);
+        items.push_back(MenuItem("Back", MenuAction::BACK, MenuPage::NODE_CONFIG_CHANNEL_DETAIL));
+        meshtastic_Channel &ch = channels.getByIndex(selectedChannelIndex);
        if (!ch.settings.has_module_settings || ch.settings.module_settings.position_precision == 0) {
            items.push_back(MenuItem("Position is Off", MenuPage::NODE_CONFIG_CHANNEL_DETAIL));
            break;
@@ -1272,8 +1247,7 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
    }

    case NODE_CONFIG_DEVICE_ROLE: {
-        previousPage = MenuPage::NODE_CONFIG_DEVICE;
-        items.push_back(MenuItem("Back", previousPage));
+        items.push_back(MenuItem("Back", MenuAction::BACK, MenuPage::NODE_CONFIG_DEVICE));
        items.push_back(MenuItem("Client", MenuAction::SET_ROLE_CLIENT, MenuPage::EXIT));
        items.push_back(MenuItem("Client Mute", MenuAction::SET_ROLE_CLIENT_MUTE, MenuPage::EXIT));
        items.push_back(MenuItem("Router", MenuAction::SET_ROLE_ROUTER, MenuPage::EXIT));
@@ -1283,8 +1257,7 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
    }

    case TIMEZONE:
-        previousPage = MenuPage::NODE_CONFIG_DEVICE;
-        items.push_back(MenuItem("Back", previousPage));
+        items.push_back(MenuItem("Back", MenuAction::BACK, MenuPage::NODE_CONFIG_DEVICE));
        items.push_back(MenuItem("US/Hawaii", SET_TZ_US_HAWAII, MenuPage::NODE_CONFIG_DEVICE));
        items.push_back(MenuItem("US/Alaska", SET_TZ_US_ALASKA, MenuPage::NODE_CONFIG_DEVICE));
        items.push_back(MenuItem("US/Pacific", SET_TZ_US_PACIFIC, MenuPage::NODE_CONFIG_DEVICE));
@@ -1306,8 +1279,7 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
        break;

    case REGION:
-        previousPage = MenuPage::NODE_CONFIG_LORA;
-        items.push_back(MenuItem("Back", previousPage));
+        items.push_back(MenuItem("Back", MenuAction::BACK, MenuPage::NODE_CONFIG_LORA));
        items.push_back(MenuItem("US", MenuAction::SET_REGION_US, MenuPage::EXIT));
        items.push_back(MenuItem("EU 868", MenuAction::SET_REGION_EU_868, MenuPage::EXIT));
        items.push_back(MenuItem("EU 433", MenuAction::SET_REGION_EU_433, MenuPage::EXIT));
@@ -1338,8 +1310,7 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
        break;

    case NODE_CONFIG_PRESET: {
-        previousPage = MenuPage::NODE_CONFIG_LORA;
-        items.push_back(MenuItem("Back", previousPage));
+        items.push_back(MenuItem("Back", MenuAction::BACK, MenuPage::NODE_CONFIG_LORA));
        items.push_back(MenuItem("Long Moderate", MenuAction::SET_PRESET_LONG_MODERATE, MenuPage::EXIT));
        items.push_back(MenuItem("Long Fast", MenuAction::SET_PRESET_LONG_FAST, MenuPage::EXIT));
        items.push_back(MenuItem("Medium Slow", MenuAction::SET_PRESET_MEDIUM_SLOW, MenuPage::EXIT));
@@ -1352,8 +1323,7 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
    }
    // Administration Section
    case NODE_CONFIG_ADMIN_RESET:
-        previousPage = MenuPage::NODE_CONFIG;
-        items.push_back(MenuItem("Back", previousPage));
+        items.push_back(MenuItem("Back", MenuAction::BACK, MenuPage::NODE_CONFIG));
        items.push_back(MenuItem("Reset All", MenuAction::RESET_NODEDB_ALL, MenuPage::EXIT));
        items.push_back(MenuItem("Keep Favorites Only", MenuAction::RESET_NODEDB_KEEP_FAVORITES, MenuPage::EXIT));
        items.push_back(MenuItem("Exit", MenuPage::EXIT));
@@ -1391,14 +1361,8 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
    currentPage = page;
 }

-void InkHUD::MenuApplet::onRender(bool full)
+void InkHUD::MenuApplet::onRender()
 {
-    // Free text mode draws a text input field and skips the normal rendering
-    if (freeTextMode) {
-        drawInputField(0, fontSmall.lineHeight(), X(1.0), Y(1.0) - fontSmall.lineHeight() - 1, cm.freeTextItem.rawText);
-        return;
-    }
-
    if (items.size() == 0)
        LOG_ERROR("Empty Menu");

@@ -1517,56 +1481,44 @@ void InkHUD::MenuApplet::onRender(bool full)

 void InkHUD::MenuApplet::onButtonShortPress()
 {
-    if (!freeTextMode) {
-        // Push the auto-close timer back
-        OSThread::setIntervalFromNow(MENU_TIMEOUT_SEC * 1000UL);
+    // Push the auto-close timer back
+    OSThread::setIntervalFromNow(MENU_TIMEOUT_SEC * 1000UL);

-        if (!settings->joystick.enabled) {
-            if (!cursorShown) {
-                cursorShown = true;
-                // Select the first item that isn't a header
-                cursor = 0;
-                while (cursor < items.size() && items.at(cursor).isHeader) {
-                    cursor++;
-                }
-                if (cursor >= items.size()) {
-                    cursorShown = false;
-                    cursor = 0;
-                }
-            } else {
-                do {
-                    cursor = (cursor + 1) % items.size();
-                } while (items.at(cursor).isHeader);
-            }
-            requestUpdate(Drivers::EInk::UpdateTypes::FAST);
+    if (!settings->joystick.enabled) {
+        if (!cursorShown) {
+            cursorShown = true;
+            cursor = 0;
        } else {
-            if (cursorShown)
-                execute(items.at(cursor));
-            else
-                showPage(MenuPage::EXIT);
-            if (!wantsToRender())
-                requestUpdate(Drivers::EInk::UpdateTypes::FAST);
+            do {
+                cursor = (cursor + 1) % items.size();
+            } while (items.at(cursor).isHeader);
        }
+        requestUpdate(Drivers::EInk::UpdateTypes::FAST);
+    } else {
+        if (cursorShown)
+            execute(items.at(cursor));
+        else
+            showPage(MenuPage::EXIT);
+        if (!wantsToRender())
+            requestUpdate(Drivers::EInk::UpdateTypes::FAST);
    }
 }

 void InkHUD::MenuApplet::onButtonLongPress()
 {
-    if (!freeTextMode) {
-        // Push the auto-close timer back
-        OSThread::setIntervalFromNow(MENU_TIMEOUT_SEC * 1000UL);
+    // Push the auto-close timer back
+    OSThread::setIntervalFromNow(MENU_TIMEOUT_SEC * 1000UL);

-        if (cursorShown)
-            execute(items.at(cursor));
-        else
-            showPage(MenuPage::EXIT); // Special case: Peek at root-menu; longpress again to close
+    if (cursorShown)
+        execute(items.at(cursor));
+    else
+        showPage(MenuPage::EXIT); // Special case: Peek at root-menu; longpress again to close

-        // If we didn't already request a specialized update, when handling a menu action,
-        // then perform the usual fast update.
-        // FAST keeps things responsive: important because we're dealing with user input
-        if (!wantsToRender())
-            requestUpdate(Drivers::EInk::UpdateTypes::FAST);
-    }
+    // If we didn't already request a specialized update, when handling a menu action,
+    // then perform the usual fast update.
+    // FAST keeps things responsive: important because we're dealing with user input
+    if (!wantsToRender())
+        requestUpdate(Drivers::EInk::UpdateTypes::FAST);
 }

 void InkHUD::MenuApplet::onExitShort()
@@ -1579,123 +1531,56 @@ void InkHUD::MenuApplet::onExitShort()

 void InkHUD::MenuApplet::onNavUp()
 {
-    if (!freeTextMode) {
-        OSThread::setIntervalFromNow(MENU_TIMEOUT_SEC * 1000UL);
+    OSThread::setIntervalFromNow(MENU_TIMEOUT_SEC * 1000UL);

-        if (!cursorShown) {
-            cursorShown = true;
-            // Select the last item that isn't a header
-            cursor = items.size() - 1;
-            while (items.at(cursor).isHeader) {
-                if (cursor == 0) {
-                    cursorShown = false;
-                    break;
-                }
+    if (!cursorShown) {
+        cursorShown = true;
+        cursor = 0;
+    } else {
+        do {
+            if (cursor == 0)
+                cursor = items.size() - 1;
+            else
                cursor--;
-            }
-        } else {
-            do {
-                if (cursor == 0)
-                    cursor = items.size() - 1;
-                else
-                    cursor--;
-            } while (items.at(cursor).isHeader);
-        }
-
-        requestUpdate(Drivers::EInk::UpdateTypes::FAST);
+        } while (items.at(cursor).isHeader);
    }
+
+    requestUpdate(Drivers::EInk::UpdateTypes::FAST);
 }

 void InkHUD::MenuApplet::onNavDown()
 {
-    if (!freeTextMode) {
-        OSThread::setIntervalFromNow(MENU_TIMEOUT_SEC * 1000UL);
+    OSThread::setIntervalFromNow(MENU_TIMEOUT_SEC * 1000UL);

-        if (!cursorShown) {
-            cursorShown = true;
-            // Select the first item that isn't a header
-            cursor = 0;
-            while (cursor < items.size() && items.at(cursor).isHeader) {
-                cursor++;
-            }
-            if (cursor >= items.size()) {
-                cursorShown = false;
-                cursor = 0;
-            }
-        } else {
-            do {
-                cursor = (cursor + 1) % items.size();
-            } while (items.at(cursor).isHeader);
-        }
-
-        requestUpdate(Drivers::EInk::UpdateTypes::FAST);
+    if (!cursorShown) {
+        cursorShown = true;
+        cursor = 0;
+    } else {
+        do {
+            cursor = (cursor + 1) % items.size();
+        } while (items.at(cursor).isHeader);
    }
+
+    requestUpdate(Drivers::EInk::UpdateTypes::FAST);
 }

 void InkHUD::MenuApplet::onNavLeft()
 {
-    if (!freeTextMode) {
-        OSThread::setIntervalFromNow(MENU_TIMEOUT_SEC * 1000UL);
+    OSThread::setIntervalFromNow(MENU_TIMEOUT_SEC * 1000UL);

-        // Go to the previous menu page
-        showPage(previousPage);
-        requestUpdate(Drivers::EInk::UpdateTypes::FAST);
-    }
+    // Go to the previous menu page
+    showPage(previousPage);
+    requestUpdate(Drivers::EInk::UpdateTypes::FAST);
 }

 void InkHUD::MenuApplet::onNavRight()
 {
-    if (!freeTextMode) {
-        OSThread::setIntervalFromNow(MENU_TIMEOUT_SEC * 1000UL);
-        if (cursorShown)
-            execute(items.at(cursor));
-        if (!wantsToRender())
-            requestUpdate(Drivers::EInk::UpdateTypes::FAST);
-    }
-}
-
-void InkHUD::MenuApplet::onFreeText(char c)
-{
-    if (cm.freeTextItem.rawText.length() >= menuTextLimit && c != '\b')
-        return;
-    if (c == '\b') {
-        if (!cm.freeTextItem.rawText.empty())
-            cm.freeTextItem.rawText.pop_back();
-    } else {
-        cm.freeTextItem.rawText += c;
-    }
-    requestUpdate(Drivers::EInk::UpdateTypes::FAST);
-}
-
-void InkHUD::MenuApplet::onFreeTextDone()
-{
-    // Restart the auto-close timeout
    OSThread::setIntervalFromNow(MENU_TIMEOUT_SEC * 1000UL);
-    OSThread::enabled = true;

-    handleFreeText = false;
-    freeTextMode = false;
-
-    if (!cm.freeTextItem.rawText.empty()) {
-        cm.selectedMessageItem = &cm.freeTextItem;
-        showPage(MenuPage::CANNEDMESSAGE_RECIPIENT);
-    }
-    requestUpdate(Drivers::EInk::UpdateTypes::FAST);
-}
-
-void InkHUD::MenuApplet::onFreeTextCancel()
-{
-    // Restart the auto-close timeout
-    OSThread::setIntervalFromNow(MENU_TIMEOUT_SEC * 1000UL);
-    OSThread::enabled = true;
-
-    handleFreeText = false;
-    freeTextMode = false;
-
-    // Clear the free text message
-    cm.freeTextItem.rawText.erase();
-
-    requestUpdate(Drivers::EInk::UpdateTypes::FAST);
+    if (cursorShown)
+        execute(items.at(cursor));
+    if (!wantsToRender())
+        requestUpdate(Drivers::EInk::UpdateTypes::FAST);
 }

 // Dynamically create MenuItem entries for activating / deactivating Applets, for the "Applet Selection" submenu
@@ -1750,10 +1635,6 @@ void InkHUD::MenuApplet::populateSendPage()
    // Position / NodeInfo packet
    items.push_back(MenuItem("Ping", MenuAction::SEND_PING, MenuPage::EXIT));

-    // If joystick is available, include the Free Text option
-    if (settings->joystick.enabled)
-        items.push_back(MenuItem("Free Text", MenuAction::FREE_TEXT, MenuPage::SEND));
-
    // One menu item for each canned message
    uint8_t count = cm.store->size();
    for (uint8_t i = 0; i < count; i++) {
@@ -1783,7 +1664,7 @@ void InkHUD::MenuApplet::populateRecipientPage()

    for (uint8_t i = 0; i < MAX_NUM_CHANNELS; i++) {
        // Get the channel, and check if it's enabled
-        const meshtastic_Channel &channel = channels.getByIndex(i);
+        meshtastic_Channel &channel = channels.getByIndex(i);
        if (!channel.has_settings || channel.role == meshtastic_Channel_Role_DISABLED)
            continue;

@@ -1853,48 +1734,6 @@ void InkHUD::MenuApplet::populateRecipientPage()
    items.push_back(MenuItem("Exit", MenuPage::EXIT));
 }

-void InkHUD::MenuApplet::drawInputField(uint16_t left, uint16_t top, uint16_t width, uint16_t height, const std::string &text)
-{
-    setFont(fontSmall);
-    uint16_t wrapMaxH = 0;
-
-    // Draw the text, input box, and cursor
-    // Adjusting the box for screen height
-    while (wrapMaxH < height - fontSmall.lineHeight()) {
-        wrapMaxH += fontSmall.lineHeight();
-    }
-
-    // If the text is so long that it goes outside of the input box, the text is actually rendered off screen.
-    uint32_t textHeight = getWrappedTextHeight(0, width - 5, text);
-    if (!text.empty()) {
-        uint16_t textPadding = X(1.0) > Y(1.0) ? wrapMaxH - textHeight : wrapMaxH - textHeight + 1;
-        if (textHeight > wrapMaxH)
-            printWrapped(2, textPadding, width - 5, text);
-        else
-            printWrapped(2, top + 2, width - 5, text);
-    }
-
-    uint16_t textCursorX = text.empty() ? 1 : getCursorX();
-    uint16_t textCursorY = text.empty() ? fontSmall.lineHeight() + 2 : getCursorY() - fontSmall.lineHeight() + 3;
-
-    if (textCursorX + 1 > width - 5) {
-        textCursorX = getCursorX() - width + 5;
-        textCursorY += fontSmall.lineHeight();
-    }
-
-    fillRect(textCursorX + 1, textCursorY, 1, fontSmall.lineHeight(), BLACK);
-
-    // A white rectangle clears the top part of the screen for any text that's printed beyond the input box
-    fillRect(0, 0, X(1.0), top, WHITE);
-
-    // Draw character limit
-    std::string ftlen = std::to_string(text.length()) + "/" + to_string(menuTextLimit);
-    uint16_t textLen = getTextWidth(ftlen);
-    printAt(X(1.0) - textLen - 2, 0, ftlen);
-
-    // Draw the border
-    drawRect(0, top, width, wrapMaxH + 5, BLACK);
-}
 // Renders the panel shown at the top of the root menu.
 // Displays the clock, and several other pieces of instantaneous system info,
 // which we'd prefer not to have displayed in a normal applet, as they update too frequently.
@@ -2036,4 +1875,4 @@ void InkHUD::MenuApplet::freeCannedMessageResources()
    cm.messageItems.clear();
    cm.recipientItems.clear();
 }
-#endif // MESHTASTIC_INCLUDE_INKHUD
+#endif // MESHTASTIC_INCLUDE_INKHUD
@@ -32,10 +32,7 @@ class MenuApplet : public SystemApplet, public concurrency::OSThread
    void onNavDown() override;
    void onNavLeft() override;
    void onNavRight() override;
-    void onFreeText(char c) override;
-    void onFreeTextDone() override;
-    void onFreeTextCancel() override;
-    void onRender(bool full) override;
+    void onRender() override;

    void show(Tile *t); // Open the menu, onto a user tile
    void setStartPage(MenuPage page);
@@ -54,8 +51,6 @@ class MenuApplet : public SystemApplet, public concurrency::OSThread
    void populateAutoshowPage();  // Dynamically create MenuItems for selecting which applets can autoshow
    void populateRecentsPage();   // Create menu items: a choice of values for settings.recentlyActiveSeconds

-    void drawInputField(uint16_t left, uint16_t top, uint16_t width, uint16_t height,
-                        const std::string &text); // Draw input field for free text
    uint16_t getSystemInfoPanelHeight();
    void drawSystemInfoPanel(int16_t left, int16_t top, uint16_t width,
                             uint16_t *height = nullptr);                   // Info panel at top of root menu
@@ -67,9 +62,8 @@ class MenuApplet : public SystemApplet, public concurrency::OSThread
    MenuPage previousPage = MenuPage::EXIT;
    uint8_t cursor = 0;       // Which menu item is currently highlighted
    bool cursorShown = false; // Is *any* item highlighted? (Root menu: no initial selection)
-    bool freeTextMode = false;
+
    uint16_t systemInfoPanelHeight = 0; // Need to know before we render
-    uint16_t menuTextLimit = 200;

    std::vector<MenuItem> items;               // MenuItems for the current page. Filled by ShowPage
    std::vector<std::string> nodeConfigLabels; // Persistent labels for Node Config pages
@@ -110,8 +104,6 @@ class MenuApplet : public SystemApplet, public concurrency::OSThread
        // Cleared onBackground (when MenuApplet closes)
        std::vector<MessageItem> messageItems;
        std::vector<RecipientItem> recipientItems;
-
-        MessageItem freeTextItem;
    } cm;

    Applet *borrowedTileOwner = nullptr; // Which applet we have temporarily replaced while displaying menu
@@ -65,7 +65,7 @@ int InkHUD::NotificationApplet::onReceiveTextMessage(const meshtastic_MeshPacket
    return 0;
 }

-void InkHUD::NotificationApplet::onRender(bool full)
+void InkHUD::NotificationApplet::onRender()
 {
    // Clear the region beneath the tile
    // Most applets are drawing onto an empty frame buffer and don't need to do this
@@ -139,47 +139,54 @@ void InkHUD::NotificationApplet::onForeground()
 void InkHUD::NotificationApplet::onBackground()
 {
    handleInput = false;
-    inkhud->forceUpdate(EInk::UpdateTypes::FULL, true);
 }

 void InkHUD::NotificationApplet::onButtonShortPress()
 {
    dismiss();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
 }

 void InkHUD::NotificationApplet::onButtonLongPress()
 {
    dismiss();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
 }

 void InkHUD::NotificationApplet::onExitShort()
 {
    dismiss();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
 }

 void InkHUD::NotificationApplet::onExitLong()
 {
    dismiss();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
 }

 void InkHUD::NotificationApplet::onNavUp()
 {
    dismiss();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
 }

 void InkHUD::NotificationApplet::onNavDown()
 {
    dismiss();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
 }

 void InkHUD::NotificationApplet::onNavLeft()
 {
    dismiss();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
 }

 void InkHUD::NotificationApplet::onNavRight()
 {
    dismiss();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
 }

 // Ask the WindowManager to check whether any displayed applets are already displaying the info from this notification
@@ -228,17 +235,17 @@ std::string InkHUD::NotificationApplet::getNotificationText(uint16_t widthAvaila
                  Notification::Type::NOTIFICATION_MESSAGE_BROADCAST)) {

        // Although we are handling DM and broadcast notifications together, we do need to treat them slightly differently
-        bool msgIsBroadcast = currentNotification.type == Notification::Type::NOTIFICATION_MESSAGE_BROADCAST;
+        bool isBroadcast = currentNotification.type == Notification::Type::NOTIFICATION_MESSAGE_BROADCAST;

        // Pick source of message
-        const MessageStore::Message *message =
-            msgIsBroadcast ? &inkhud->persistence->latestMessage.broadcast : &inkhud->persistence->latestMessage.dm;
+        MessageStore::Message *message =
+            isBroadcast ? &inkhud->persistence->latestMessage.broadcast : &inkhud->persistence->latestMessage.dm;

        // Find info about the sender
        meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(message->sender);

        // Leading tag (channel vs. DM)
-        text += msgIsBroadcast ? "From:" : "DM: ";
+        text += isBroadcast ? "From:" : "DM: ";

        // Sender id
        if (node && node->has_user)
@@ -252,7 +259,7 @@ std::string InkHUD::NotificationApplet::getNotificationText(uint16_t widthAvaila
            text.clear();

            // Leading tag (channel vs. DM)
-            text += msgIsBroadcast ? "Msg from " : "DM from ";
+            text += isBroadcast ? "Msg from " : "DM from ";

            // Sender id
            if (node && node->has_user)
@@ -26,7 +26,7 @@ class NotificationApplet : public SystemApplet
  public:
    NotificationApplet();

-    void onRender(bool full) override;
+    void onRender() override;
    void onForeground() override;
    void onBackground() override;
    void onButtonShortPress() override;
@@ -9,7 +9,7 @@ InkHUD::PairingApplet::PairingApplet()
    bluetoothStatusObserver.observe(&bluetoothStatus->onNewStatus);
 }

-void InkHUD::PairingApplet::onRender(bool full)
+void InkHUD::PairingApplet::onRender()
 {
    // Header
    setFont(fontMedium);
@@ -45,7 +45,7 @@ void InkHUD::PairingApplet::onBackground()

    // Need to force an update, as a polite request wouldn't be honored, seeing how we are now in the background
    // Usually, onBackground is followed by another applet's onForeground (which requests update), but not in this case
-    inkhud->forceUpdate(EInk::UpdateTypes::FULL, true);
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
 }

 int InkHUD::PairingApplet::onBluetoothStatusUpdate(const meshtastic::Status *status)
@@ -55,12 +55,12 @@ int InkHUD::PairingApplet::onBluetoothStatusUpdate(const meshtastic::Status *sta
    // We'll mimic that behavior, just to keep in line with the other Statuses,
    // even though I'm not sure what the original reason for jumping through these extra hoops was.
    assert(status->getStatusType() == STATUS_TYPE_BLUETOOTH);
-    const auto *btStatus = static_cast<const meshtastic::BluetoothStatus *>(status);
+    meshtastic::BluetoothStatus *bluetoothStatus = (meshtastic::BluetoothStatus *)status;

    // When pairing begins
-    if (btStatus->getConnectionState() == meshtastic::BluetoothStatus::ConnectionState::PAIRING) {
+    if (bluetoothStatus->getConnectionState() == meshtastic::BluetoothStatus::ConnectionState::PAIRING) {
        // Store the passkey for rendering
-        passkey = btStatus->getPasskey();
+        passkey = bluetoothStatus->getPasskey();

        // Show pairing screen
        bringToForeground();
@@ -22,7 +22,7 @@ class PairingApplet : public SystemApplet
  public:
    PairingApplet();

-    void onRender(bool full) override;
+    void onRender() override;
    void onForeground() override;
    void onBackground() override;

--- a/Show More
+++ b/Show More