diff --git a/language/test.py b/language/test.py
index 8a9e14582f..5ddbfdef05 100755
--- a/language/test.py
+++ b/language/test.py
@@ -165,6 +165,20 @@ def run_prof_rs(out_dir, logfiles, verbose, legion_prof_rs):
         raise TestFailure(' '.join(cmd), retcode, output.decode('utf-8') if output is not None else None)
     return result_dir
 
+def run_prof_rs_archive(out_dir, logfiles, verbose, legion_prof_rs):
+    result_dir = os.path.join(out_dir, 'legion_prof_rs_archive')
+    cmd = [legion_prof_rs, '--archive', '--levels', '3', '--zstd-compression', '1', '-o', result_dir,] + logfiles
+    if verbose: print('Running', ' '.join(cmd))
+    proc = subprocess.Popen(
+        cmd,
+        stdout=None if verbose else subprocess.PIPE,
+        stderr=None if verbose else subprocess.STDOUT)
+    output, _ = proc.communicate()
+    retcode = proc.wait()
+    if retcode != 0:
+        raise TestFailure(' '.join(cmd), retcode, output.decode('utf-8') if output is not None else None)
+    return result_dir
+
 def run_prof_subnode(out_dir, logfiles, verbose, subnodes, py_exe_path):
     result_dir = os.path.join(out_dir, 'legion_prof_filter_input')
     cmd = [
@@ -326,6 +340,7 @@ def test_prof(filename, debug, verbose, short, timelimit, py_exe_path, legion_pr
             result_py = run_prof(prof_dir, prof_logs, verbose, py_exe_path)
             result_rs = run_prof_rs(prof_dir, prof_logs, verbose, legion_prof_rs)
             compare_prof_results(verbose, py_exe_path, [result_py, result_rs])
+            run_prof_rs_archive(prof_dir, prof_logs, verbose, legion_prof_rs)
             # we only test subnodes when running on multi-node
             if os.environ.get('LAUNCHER'):
                 result_subnodes_py = run_prof_subnode(prof_dir, prof_logs, verbose, 1, py_exe_path)
diff --git a/tools/legion_prof_rs/src/backend/data_source.rs b/tools/legion_prof_rs/src/backend/data_source.rs
index a4373d0cea..62ed60eef3 100644
--- a/tools/legion_prof_rs/src/backend/data_source.rs
+++ b/tools/legion_prof_rs/src/backend/data_source.rs
@@ -278,8 +278,8 @@ impl StateDataSource {
 
                 let mut mem_slots = Vec::new();
                 if node.is_some() {
-                    let mems = mem_groups.get(&group).unwrap();
-                    for (mem_index, mem) in mems.iter().enumerate() {
+                    let mems = mem_groups.get(&group);
+                    for (mem_index, mem) in mems.iter().copied().flatten().enumerate() {
                         let mem_id = kind_id.child(mem_index as u64);
                         entry_map.insert(mem_id.clone(), EntryKind::Mem(*mem));
                         mem_entries.insert(*mem, mem_id);
@@ -298,15 +298,17 @@ impl StateDataSource {
                     }
                 }
 
-                let summary_id = kind_id.summary();
-                entry_map.insert(summary_id, EntryKind::MemKind(group));
+                if !mem_slots.is_empty() {
+                    let summary_id = kind_id.summary();
+                    entry_map.insert(summary_id, EntryKind::MemKind(group));
 
-                kind_slots.push(EntryInfo::Panel {
-                    short_name: kind_name.to_lowercase(),
-                    long_name: format!("{} {}", node_long_name, kind_name),
-                    summary: Some(Box::new(EntryInfo::Summary { color })),
-                    slots: mem_slots,
-                });
+                    kind_slots.push(EntryInfo::Panel {
+                        short_name: kind_name.to_lowercase(),
+                        long_name: format!("{} {}", node_long_name, kind_name),
+                        summary: Some(Box::new(EntryInfo::Summary { color })),
+                        slots: mem_slots,
+                    });
+                }
             }
 
             // Channels
@@ -317,8 +319,8 @@ impl StateDataSource {
 
                 let mut chan_slots = Vec::new();
                 if node.is_some() {
-                    let chans = chan_groups.get(node).unwrap();
-                    for (chan_index, chan) in chans.iter().enumerate() {
+                    let chans = chan_groups.get(node);
+                    for (chan_index, chan) in chans.iter().copied().flatten().enumerate() {
                         let chan_id = kind_id.child(chan_index as u64);
                         entry_map.insert(chan_id, EntryKind::Chan(*chan));
 
@@ -389,15 +391,17 @@ impl StateDataSource {
                     }
                 }
 
-                let summary_id = kind_id.summary();
-                entry_map.insert(summary_id, EntryKind::ChanKind(*node));
+                if !chan_slots.is_empty() {
+                    let summary_id = kind_id.summary();
+                    entry_map.insert(summary_id, EntryKind::ChanKind(*node));
 
-                kind_slots.push(EntryInfo::Panel {
-                    short_name: "chan".to_owned(),
-                    long_name: format!("{} Channel", node_long_name),
-                    summary: Some(Box::new(EntryInfo::Summary { color })),
-                    slots: chan_slots,
-                });
+                    kind_slots.push(EntryInfo::Panel {
+                        short_name: "chan".to_owned(),
+                        long_name: format!("{} Channel", node_long_name),
+                        summary: Some(Box::new(EntryInfo::Summary { color })),
+                        slots: chan_slots,
+                    });
+                }
             }
             node_slots.push(EntryInfo::Panel {
                 short_name: node_short_name,