Misc bugs around dm region scope + scope display, and flood-scope leak

app/packet_processor.py

@@ -115,6 +115,8 @@ async def create_dm_message_from_decrypted(
     outgoing: bool = False,
     realtime: bool = True,
     packet_hash: str | None = None,
+    transport_code: int | None = None,
+    region: str | None = None,
 ) -> int | None:
     """Store a decrypted direct message via the shared message service."""
     return await _create_dm_message_from_decrypted(
@@ -131,6 +133,8 @@ async def create_dm_message_from_decrypted(
         realtime=realtime,
         broadcast_fn=broadcast_event,
         packet_hash=packet_hash,
+        transport_code=transport_code,
+        region=region,
     )
 
 
@@ -391,7 +395,15 @@ async def process_raw_packet(
     elif payload_type == PayloadType.TEXT_MESSAGE:
         # Try to decrypt direct messages using stored private key and known contacts
         decrypt_result = await _process_direct_message(
-            raw_bytes, packet_id, ts, packet_info, rssi=rssi, snr=snr, packet_hash=pkt_hash
+            raw_bytes,
+            packet_id,
+            ts,
+            packet_info,
+            rssi=rssi,
+            snr=snr,
+            packet_hash=pkt_hash,
+            transport_code=transport_code,
+            region=region,
         )
         if decrypt_result:
             result.update(decrypt_result)
@@ -656,6 +668,8 @@ async def _process_direct_message(
     rssi: int | None = None,
     snr: float | None = None,
     packet_hash: str | None = None,
+    transport_code: int | None = None,
+    region: str | None = None,
 ) -> dict | None:
     """
     Process a TEXT_MESSAGE (direct message) packet.
@@ -780,6 +794,8 @@ async def _process_direct_message(
                 snr=snr,
                 outgoing=effective_outgoing,
                 packet_hash=packet_hash,
+                transport_code=transport_code,
+                region=region,
             )
 
             return {

app/services/dm_ingest.py

@@ -155,6 +155,8 @@ async def _store_direct_message(
     best_effort_content_dedup: bool,
     linked_packet_dedup: bool,
     packet_hash: str | None = None,
+    transport_code: int | None = None,
+    region: str | None = None,
     message_repository=MessageRepository,
     contact_repository=ContactRepository,
     raw_packet_repository=RawPacketRepository,
@@ -213,6 +215,8 @@ async def _store_direct_message(
             outgoing=outgoing,
             sender_key=sender_key,
             sender_name=sender_name,
+            transport_code=transport_code,
+            region=region,
         )
         if msg_id is None:
             await handle_duplicate_message(
@@ -248,6 +252,8 @@ async def _store_direct_message(
             outgoing=outgoing,
             sender_name=sender_name,
             packet_id=packet_id,
+            transport_code=transport_code,
+            region=region,
         )
         broadcast_message(
             message=message, broadcast_fn=broadcast_fn, realtime=realtime, packet_hash=packet_hash
@@ -283,6 +289,8 @@ async def ingest_decrypted_direct_message(
     realtime: bool = True,
     broadcast_fn: BroadcastFn,
     packet_hash: str | None = None,
+    transport_code: int | None = None,
+    region: str | None = None,
     contact_repository=ContactRepository,
 ) -> Message | None:
     conversation_key = their_public_key.lower()
@@ -343,6 +351,8 @@ async def ingest_decrypted_direct_message(
         best_effort_content_dedup=outgoing,
         linked_packet_dedup=True,
         packet_hash=packet_hash,
+        transport_code=transport_code,
+        region=region,
     )
     if message is None:
         return None

app/services/message_send.py

@@ -191,30 +191,6 @@ async def send_channel_message_with_effective_scope(
     # (channel-default) path leaves the radio untouched when no override is set.
     apply_scope = desired_scope != baseline_scope and (bool(desired_scope) or scope_explicit)
 
-    if apply_scope:
-        logger.info(
-            "Temporarily applying flood_scope %s for %s",
-            desired_scope or "(unscoped)",
-            channel.name,
-        )
-        override_result = await set_radio_flood_scope(
-            mc, desired_scope, fw_ver=radio_manager.firmware_ver_code
-        )
-        if override_result is not None and override_result.type == EventType.ERROR:
-            logger.warning(
-                "Failed to apply flood_scope %r for %s: %s",
-                desired_scope,
-                channel.name,
-                override_result.payload,
-            )
-            raise HTTPException(
-                status_code=422,
-                detail=(
-                    f"Failed to apply regional override {desired_scope!r} before {action_label}: "
-                    f"{override_result.payload}"
-                ),
-            )
-
     # Path hash mode per-channel override
     override_phm = channel.path_hash_mode_override
     baseline_phm = radio_manager.path_hash_mode
@@ -224,28 +200,59 @@ async def send_channel_message_with_effective_scope(
         and override_phm != baseline_phm
     )
 
-    if apply_phm:
-        logger.info(
-            "Temporarily applying channel path_hash_mode override for %s: %d",
-            channel.name,
-            override_phm,
-        )
-        phm_result = await mc.commands.set_path_hash_mode(override_phm)
-        if phm_result is not None and phm_result.type == EventType.ERROR:
-            logger.warning(
-                "Failed to apply channel path_hash_mode override for %s: %s",
-                channel.name,
-                phm_result.payload,
-            )
-            raise HTTPException(
-                status_code=422,
-                detail=(
-                    f"Failed to apply path hash mode override before {action_label}: "
-                    f"{phm_result.payload}"
-                ),
-            )
-
+    # Apply the temporary overrides and send inside the try so the finally below
+    # always restores the radio's baseline scope/hash-mode -- even when applying an
+    # override raises (e.g. the radio rejects the scope, or the path-hash-mode apply
+    # fails) or the send itself throws. ``apply_scope``/``apply_phm`` are computed
+    # above so the finally can reference them regardless of where we fail, and
+    # restoring to baseline is idempotent, so forcing baseline back after an apply
+    # whose effect on the radio is unknown is safe.
     try:
+        if apply_scope:
+            logger.info(
+                "Temporarily applying flood_scope %s for %s",
+                desired_scope or "(unscoped)",
+                channel.name,
+            )
+            override_result = await set_radio_flood_scope(
+                mc, desired_scope, fw_ver=radio_manager.firmware_ver_code
+            )
+            if override_result is not None and override_result.type == EventType.ERROR:
+                logger.warning(
+                    "Failed to apply flood_scope %r for %s: %s",
+                    desired_scope,
+                    channel.name,
+                    override_result.payload,
+                )
+                raise HTTPException(
+                    status_code=422,
+                    detail=(
+                        f"Failed to apply regional override {desired_scope!r} before {action_label}: "
+                        f"{override_result.payload}"
+                    ),
+                )
+
+        if apply_phm:
+            logger.info(
+                "Temporarily applying channel path_hash_mode override for %s: %d",
+                channel.name,
+                override_phm,
+            )
+            phm_result = await mc.commands.set_path_hash_mode(override_phm)
+            if phm_result is not None and phm_result.type == EventType.ERROR:
+                logger.warning(
+                    "Failed to apply channel path_hash_mode override for %s: %s",
+                    channel.name,
+                    phm_result.payload,
+                )
+                raise HTTPException(
+                    status_code=422,
+                    detail=(
+                        f"Failed to apply path hash mode override before {action_label}: "
+                        f"{phm_result.payload}"
+                    ),
+                )
+
         channel_slot, needs_configure, evicted_channel_key = radio_manager.plan_channel_send_slot(
             channel_key,
             preferred_slot=temp_radio_slot,

app/services/messages.py

@@ -408,6 +408,8 @@ async def create_dm_message_from_decrypted(
     realtime: bool = True,
     broadcast_fn: BroadcastFn,
     packet_hash: str | None = None,
+    transport_code: int | None = None,
+    region: str | None = None,
 ) -> int | None:
     """Store and broadcast a decrypted direct message."""
     from app.services.dm_ingest import ingest_decrypted_direct_message
@@ -425,6 +427,8 @@ async def create_dm_message_from_decrypted(
         realtime=realtime,
         broadcast_fn=broadcast_fn,
         packet_hash=packet_hash,
+        transport_code=transport_code,
+        region=region,
     )
     return message.id if message is not None else None