fix: tolerate null values when normalizing cast payload maps

deepNormalizeJson's fallback rebuilt the map via raw.entries, which throws on a
CastMap<String, Object>: the call sites pass `.cast<String, Object>()` over a
JSON-decoded payload that legitimately holds null fields, and reading a null
through the non-nullable Object cast raises "type 'Null' is not a subtype of
type 'Object'". The jsonEncode fast path above fails the same way, so a single
null field aborted the whole Chat/Attachment parse and dropped the event.

Rebuild key-by-key with a guarded per-value lookup so a null can't blow up the
normalize.

Author: blue-archon

lib/utils/deep_map_normalize.dart

@@ -17,11 +17,23 @@ dynamic deepNormalizeJson(dynamic raw) {
       return jsonDecode(jsonEncode(raw));
     } catch (_) {
       if (raw is Map) {
-        return Map<String, dynamic>.fromEntries(
-          raw.entries.map(
-            (e) => MapEntry(e.key.toString(), deepNormalizeJson(e.value)),
-          ),
-        );
+        // Rebuild key-by-key. `raw` may be a CastMap<String, Object> (produced by
+        // `.cast<String, Object>()` on a JSON-decoded socket/method-channel payload):
+        // iterating its entries — or the jsonEncode above — casts each value to the
+        // non-nullable Object, which throws on a genuinely-null field before we ever
+        // reach the recursive normalize. Read each value through a guarded lookup so
+        // a single null can't abort the whole parse (dropping the chat/attachment).
+        final result = <String, dynamic>{};
+        for (final key in raw.keys) {
+          dynamic value;
+          try {
+            value = raw[key];
+          } catch (_) {
+            value = null;
+          }
+          result[key.toString()] = deepNormalizeJson(value);
+        }
+        return result;
       }
       if (raw is List) {
         return raw.map(deepNormalizeJson).toList();