Please address the comments from this code review:
## Individual Comments
### Comment 1
<location> `frontend/rust-lib/collab-integrate/src/instant_indexed_data_provider.rs:260` </location>
<code_context>
-  None => Err(FlowyError::internal().with_context("Failed to create unindexed collab")),
-  Some(data) => {
-  self.index_unindexed_collab(data).await?;
+ pub async fn index_unindexed_collab(&self, data: UnindexedCollab) -> FlowyResult<()> {
+  let consumers_guard = self.consumers.read().await;
+  for consumer in consumers_guard.iter() {
</code_context>
<issue_to_address>
**nitpick:** Error handling for consumer failures is inconsistent with periodic provider.
Use the same log level for consumer errors as in the periodic provider to maintain consistency.
</issue_to_address>
### Comment 2
<location> `frontend/rust-lib/collab-integrate/src/instant_indexed_data_provider.rs:69` </location>
<code_context>
- guard.push(consumer);
- }
-
- pub async fn spawn_instant_indexed_provider(&self, runtime: &Runtime) -> FlowyResult<()> {
- let weak_collab_by_object = Arc::downgrade(&self.collab_by_object);
- let consumers_weak = Arc::downgrade(&self.consumers);
</code_context>
<issue_to_address>
**issue (complexity):** Consider extracting the snapshot and cleanup logic into helper functions to simplify and clarify the core spawn loop.
Consider moving the in‐loop "snapshot" and "cleanup" bits into small helpers to keep the spawn loop focused. For example, after you upgrade the Arcs you could:
```rust
// new helper at impl InstantIndexedDataWriter
async fn snapshot_entries(
 collab_by_object: &RwLock<HashMap<String, WriteObject>>,
) -> Vec<(String, CollabObject, Weak<dyn CollabIndexedData>)> {
 let guard = collab_by_object.read().await;
 guard
 .iter()
 .map(|(id, wo)| (id.clone(), wo.collab_object.clone(), wo.collab.clone()))
 .collect()
}
async fn remove_stale(
 collab_by_object: &RwLock<HashMap<String, WriteObject>>,
 to_remove: &[String],
) {
 if to_remove.is_empty() {
 return;
 }
 let mut guard = collab_by_object.write().await;
 guard.retain(|k, _| !to_remove.contains(k));
}
```
Then your spawn loop reduces to:
```rust
// inside runtime.spawn(async move { ... })
let object_snapshots = Self::snapshot_entries(&collab_by_object).await;
let consumers = consumers.read().await;
if consumers.is_empty() { continue; }
let mut to_remove = Vec::new();
for (id, collab_object, weak_rc) in object_snapshots {
 if let Some(rc) = weak_rc.upgrade() {
 if let Err(e) =
 Self::process_single_collab(id.clone(), collab_object, rc, &consumers).await
 {
 error!("[Indexing] process failed {}: {}", id, e);
 }
 } else {
 to_remove.push(id);
 }
}
Self::remove_stale(&collab_by_object, &to_remove).await;
```
This trims down the body of your core loop by ~40 lines, isolates snapshot/cleanup logic for easier testing, and keeps all functionality intact.
</issue_to_address>