perf(frontend): kill O(n^2) scans in group-member sort + chat-open system events

Two more quadratics:
- group-member picker sort ran arrSelectedGroupMembers.indexOf AND arrChats.find
  inside the comparator -> O(profiles * (members + chats) * log). Pre-index both
  into Maps; comparator is O(1) per lookup.
- on chat open, system-event ingest deduped against loaded messages via
  initialMessages.find and checked known profiles via arrProfiles.some, both per
  event -> O(systemEvents * messages) + O(systemEvents * profiles). Hoist both to
  Sets, O(1) per check.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: JSKitty

src/main.js

@@ -8371,16 +8371,20 @@ async function openChat(contact) {
     // messages into view (same on-demand windowing as messages).
     try {
         const systemEvents = await invoke('get_system_events', { conversationId: contact });
+        // Index once: dedup-vs-loaded-messages and the known-profile check were each O(n) per
+        // system event (O(systemEvents * messages) + O(systemEvents * profiles)) on chat open.
+        const initialMsgIds = new Set(initialMessages.map(m => m.id));
+        const knownProfileIds = new Set(arrProfiles.map(p => p.id));
         const buffer = (systemEvents || [])
-            .filter(event => !initialMessages.find(m => m.id === event.id))
+            .filter(event => !initialMsgIds.has(event.id))
             .map(event => ({
                 id: event.id,
                 at: event.at,
                 // Rebuild from the actor's CURRENT cached name rather than the npub-baked
                 // stored content. Fetch unknown profiles so the next open resolves them.
                 content: (() => {
                     const np = event.member_npub;
-                    if (np && !arrProfiles.some(p => p.id === np) && !strangerProfileRequested.has(np)) {
+                    if (np && !knownProfileIds.has(np) && !strangerProfileRequested.has(np)) {
                         strangerProfileRequested.add(np);
                         invoke('load_profile', { npub: np }).catch(() => {});
                     }
@@ -12892,9 +12896,13 @@ function renderCreateGroupList(filterText = '') {
     }
 
     // Sort profiles: selected members first (by selection order), then unselected by last message time
+    // Pre-index selection order + chat timestamps so the comparator is O(1) per lookup — `indexOf`
+    // + `arrChats.find` per comparison made this O(profiles * (members + chats) * log).
+    const selIndexById = new Map(arrSelectedGroupMembers.map((id, i) => [id, i]));
+    const chatTsById = new Map(arrChats.map(c => [c.id, getChatSortTimestamp(c)]));
     const sortedProfiles = [...arrProfiles].sort((a, b) => {
-        const aSelectedIndex = arrSelectedGroupMembers.indexOf(a?.id);
-        const bSelectedIndex = arrSelectedGroupMembers.indexOf(b?.id);
+        const aSelectedIndex = selIndexById.get(a?.id) ?? -1;
+        const bSelectedIndex = selIndexById.get(b?.id) ?? -1;
         const aSelected = aSelectedIndex !== -1;
         const bSelected = bSelectedIndex !== -1;
 
@@ -12908,8 +12916,8 @@ function renderCreateGroupList(filterText = '') {
         }
 
         // For unselected members: sort by last message time (most recent first)
-        const aChatTimestamp = getChatSortTimestamp(arrChats.find(c => c.id === a?.id) || {});
-        const bChatTimestamp = getChatSortTimestamp(arrChats.find(c => c.id === b?.id) || {});
+        const aChatTimestamp = chatTsById.get(a?.id) || 0;
+        const bChatTimestamp = chatTsById.get(b?.id) || 0;
 
         // If both have timestamps, sort by most recent
         if (aChatTimestamp && bChatTimestamp) {