chore: bump version to 1.2.34 in Cargo.toml and package.json; enhance createWorkerClient with Web Worker support and update conversation merging logic

Author: shenjinti

crates/restsend-wasm/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "restsend-wasm"
-version = "1.2.33"
+version = "1.2.34"
 edition = "2021"
 description = "Restsend  Instant Messaging Javascript/Wasm SDK"
 authors = ["Restsend Team <kui@fourz.cn>"]

crates/restsend-wasm/test/worker.spec.js

@@ -6,7 +6,7 @@ import { endpoint } from './common.js'
 describe('Worker quick path', async function () {
     it('#sync chat logs in worker', async () => {
         const info = await signin(endpoint, 'vitalik', 'vitalik:demo')
-        const workerClient = await createWorkerClient(info, '')
+        const workerClient = await createWorkerClient(info, '', { enableWorker: true })
 
         const result = await workerClient.syncChatLogs('vitalik:guido', undefined, { limit: 5 })
 

crates/restsend-wasm/worker/client.d.ts

@@ -1,8 +1,14 @@
 export interface WorkerClientOptions {
+    /** Set to true to offload syncChatLogs to a Web Worker. Default: false */
+    enableWorker?: boolean
+    /** @deprecated Use enableWorker instead */
+    forceFallback?: boolean
+    /** Custom worker entry URL */
     workerUrl?: string | URL
+    /** Worker RPC call timeout (ms). Default: 8000 */
     rpcTimeoutMs?: number
+    /** Worker init timeout (ms). Default: 5000 */
     initTimeoutMs?: number
-    forceFallback?: boolean
 }
 
 export declare function createWorkerClient(

crates/restsend-wasm/worker/client.mjs

@@ -73,23 +73,32 @@ function buildProxy(facade, client) {
 }
 
 /**
- * Create a worker-backed client wrapper.
+ * Create a client wrapper with optional Web Worker support for syncChatLogs.
  *
- * The returned object is API-compatible with `new Client(info, dbName)` and forwards
- * all methods/properties to the underlying client except `syncChatLogs`, which is routed
- * to worker by default for better UI responsiveness.
+ * By default the worker is **disabled**. Set `options.enableWorker = true` to offload
+ * `syncChatLogs` calls to a Web Worker, keeping the main thread responsive during
+ * heavy log fetching.
+ *
+ * @param {Object} info - Auth info (same as `new Client(info, dbName)`)
+ * @param {string} [dbName=''] - IndexedDB database name
+ * @param {Object} [options={}]
+ * @param {boolean} [options.enableWorker=false] - Set to true to use a Web Worker for syncChatLogs
+ * @param {number} [options.rpcTimeoutMs=8000] - Worker RPC call timeout (ms)
+ * @param {number} [options.initTimeoutMs=5000] - Worker init timeout (ms)
+ * @param {string} [options.workerUrl] - Custom worker entry URL
+ * @returns {Promise<Object>} A proxy object that delegates to the underlying client
  */
 export async function createWorkerClient(info, dbName = '', options = {}) {
     const rpcTimeoutMs = options.rpcTimeoutMs ?? 8000;
     const initTimeoutMs = options.initTimeoutMs ?? 5000;
-    const forceFallback = options.forceFallback ?? false;
+    const enableWorker = options.enableWorker === true;
 
     const client = new Client(info, dbName);
 
     let workerEnabled = false;
     let rpc = null;
 
-    if (!forceFallback) {
+    if (enableWorker) {
         try {
             const workerUrl = options.workerUrl ?? new URL('./entry.mjs', import.meta.url);
             const worker = new Worker(workerUrl, { type: 'module' });

crates/restsend/src/client/store/conversations.rs

@@ -395,6 +395,41 @@ impl ClientStore {
                 }
 
                 conversation.merge_local_read_state(&old_conversation);
+
+                // Prefer local last_message when it is newer or server's is unreadable,
+                // mirroring the single merge_conversation logic.
+                let server_last_message_seq = conversation.last_message_seq;
+                let local_last_message_readable = old_conversation
+                    .last_message
+                    .as_ref()
+                    .map(|c| !c.unreadable)
+                    .unwrap_or(false);
+                let server_last_message_unreadable = conversation
+                    .last_message
+                    .as_ref()
+                    .map(|c| c.unreadable)
+                    .unwrap_or(false);
+
+                if let Some(local_seq) = old_conversation.last_message_seq {
+                    let should_use_local = match server_last_message_seq {
+                        Some(server_seq) if server_last_message_unreadable => {
+                            local_last_message_readable
+                        }
+                        Some(server_seq) => {
+                            local_last_message_readable && local_seq >= server_seq
+                        }
+                        None => local_last_message_readable,
+                    };
+                    if should_use_local {
+                        conversation.last_message = old_conversation.last_message.clone();
+                        conversation.last_message_at =
+                            old_conversation.last_message_at.clone();
+                        conversation.last_sender_id =
+                            old_conversation.last_sender_id.clone();
+                        conversation.last_message_seq =
+                            old_conversation.last_message_seq;
+                    }
+                }
             }
 
             if needs_last_readable_refresh(&conversation) {
@@ -762,6 +797,10 @@ impl ClientStore {
                         new_conversation.last_read_at = conversation.last_read_at;
                         new_conversation.last_read_seq = conversation.last_read_seq;
                         new_conversation.unread = conversation.unread;
+                        new_conversation.last_message = conversation.last_message.clone();
+                        new_conversation.last_message_at = conversation.last_message_at.clone();
+                        new_conversation.last_sender_id = conversation.last_sender_id.clone();
+                        new_conversation.last_message_seq = conversation.last_message_seq;
                     }
                     self.ensure_topic_owner_id(&mut new_conversation).await;
                     if let Ok(t) = self.message_storage.table::<Conversation>().await {
@@ -1579,4 +1618,241 @@ mod tests {
         assert_eq!(second.items[0].id, "chat-3");
         assert_eq!(second.items[2].id, "chat-1");
     }
+
+    #[tokio::test]
+    async fn merge_conversations_prefers_local_newer_last_message_over_server_stale() {
+        let store = ClientStore::new("", ":memory:", "http://test", "token", "user1");
+
+        let agent_reply = ChatLog {
+            id: "log_101".to_string(),
+            topic_id: "topic-1".to_string(),
+            seq: 101,
+            sender_id: "user1".to_string(),
+            created_at: "2026-05-21T10:00:01Z".to_string(),
+            content: Content {
+                content_type: "text".to_string(),
+                text: "agent reply".to_string(),
+                unreadable: false,
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+        let log_table = store.message_storage.table::<ChatLog>().await.unwrap();
+        log_table
+            .set(&agent_reply.topic_id, &agent_reply.id, Some(&agent_reply))
+            .await
+            .unwrap();
+
+        let local_conversation = Conversation {
+            topic_id: "topic-1".to_string(),
+            last_seq: 101,
+            last_read_seq: 101,
+            unread: 0,
+            last_message_seq: Some(101),
+            last_message: Some(agent_reply.content.clone()),
+            last_message_at: agent_reply.created_at.clone(),
+            last_sender_id: agent_reply.sender_id.clone(),
+            ..Default::default()
+        };
+        let conv_table = store.message_storage.table::<Conversation>().await.unwrap();
+        conv_table
+            .set("", &local_conversation.topic_id, Some(&local_conversation))
+            .await
+            .unwrap();
+
+        let server_conversations = vec![Conversation {
+            topic_id: "topic-1".to_string(),
+            last_seq: 100,
+            last_read_seq: 101,
+            unread: 0,
+            last_message_seq: Some(100),
+            last_message: Some(Content {
+                content_type: "text".to_string(),
+                text: "customer message".to_string(),
+                unreadable: false,
+                ..Default::default()
+            }),
+            last_message_at: "2026-05-21T10:00:00Z".to_string(),
+            last_sender_id: "user2".to_string(),
+            ..Default::default()
+        }];
+
+        let merged = store.merge_conversations(server_conversations).await;
+        assert_eq!(merged.len(), 1);
+        assert_eq!(merged[0].last_message_seq, Some(101));
+        assert_eq!(
+            merged[0].last_message.as_ref().unwrap().text,
+            "agent reply"
+        );
+        assert_eq!(merged[0].unread, 0);
+    }
+
+    #[tokio::test]
+    async fn merge_conversations_keeps_server_last_message_when_server_is_newer() {
+        let store = ClientStore::new("", ":memory:", "http://test", "token", "user1");
+
+        let old_local = Conversation {
+            topic_id: "topic-1".to_string(),
+            last_seq: 100,
+            last_read_seq: 100,
+            unread: 0,
+            last_message_seq: Some(100),
+            last_message: Some(Content {
+                content_type: "text".to_string(),
+                text: "old message".to_string(),
+                unreadable: false,
+                ..Default::default()
+            }),
+            last_message_at: "2026-05-21T10:00:00Z".to_string(),
+            last_sender_id: "user2".to_string(),
+            ..Default::default()
+        };
+        let conv_table = store.message_storage.table::<Conversation>().await.unwrap();
+        conv_table
+            .set("", &old_local.topic_id, Some(&old_local))
+            .await
+            .unwrap();
+
+        let server_conversations = vec![Conversation {
+            topic_id: "topic-1".to_string(),
+            last_seq: 102,
+            last_read_seq: 101,
+            unread: 1,
+            last_message_seq: Some(102),
+            last_message: Some(Content {
+                content_type: "text".to_string(),
+                text: "newer server message".to_string(),
+                unreadable: false,
+                ..Default::default()
+            }),
+            last_message_at: "2026-05-21T10:00:02Z".to_string(),
+            last_sender_id: "user3".to_string(),
+            ..Default::default()
+        }];
+
+        let merged = store.merge_conversations(server_conversations).await;
+        assert_eq!(merged.len(), 1);
+        assert_eq!(merged[0].last_message_seq, Some(102));
+        assert_eq!(
+            merged[0].last_message.as_ref().unwrap().text,
+            "newer server message"
+        );
+    }
+
+    #[tokio::test]
+    async fn merge_conversations_preserves_local_read_state_with_zero_unread() {
+        let store = ClientStore::new("", ":memory:", "http://test", "token", "user1");
+
+        // Scenario: user read the conversation locally, unread=0
+        // Server still has unread>0 (read not synced, or server counts differently)
+        let local = Conversation {
+            topic_id: "topic-1".to_string(),
+            last_seq: 105,
+            last_read_seq: 100,
+            unread: 0,
+            last_message_seq: Some(105),
+            last_message: Some(Content {
+                content_type: "text".to_string(),
+                text: "readable".to_string(),
+                unreadable: false,
+                ..Default::default()
+            }),
+            last_message_at: "2026-05-21T10:00:05Z".to_string(),
+            last_sender_id: "user1".to_string(),
+            ..Default::default()
+        };
+        let conv_table = store.message_storage.table::<Conversation>().await.unwrap();
+        conv_table
+            .set("", &local.topic_id, Some(&local))
+            .await
+            .unwrap();
+
+        let server = Conversation {
+            topic_id: "topic-1".to_string(),
+            last_seq: 105,
+            last_read_seq: 100,
+            unread: 3,
+            last_message_seq: Some(105),
+            last_message: Some(Content {
+                content_type: "text".to_string(),
+                text: "same readable".to_string(),
+                unreadable: false,
+                ..Default::default()
+            }),
+            last_message_at: "2026-05-21T10:00:05Z".to_string(),
+            last_sender_id: "user2".to_string(),
+            ..Default::default()
+        };
+
+        let merged = store.merge_conversations(vec![server]).await;
+        assert_eq!(merged.len(), 1);
+        assert_eq!(merged[0].unread, 0);
+    }
+
+    #[tokio::test]
+    async fn merge_conversations_prefers_local_last_message_when_server_is_unreadable() {
+        let store = ClientStore::new("", ":memory:", "http://test", "token", "user1");
+
+        let readable_log = ChatLog {
+            id: "log_100".to_string(),
+            topic_id: "topic-1".to_string(),
+            seq: 100,
+            sender_id: "user2".to_string(),
+            created_at: "2026-05-21T10:00:00Z".to_string(),
+            content: Content {
+                content_type: "text".to_string(),
+                text: "readable summary".to_string(),
+                unreadable: false,
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+        let log_table = store.message_storage.table::<ChatLog>().await.unwrap();
+        log_table
+            .set(&readable_log.topic_id, &readable_log.id, Some(&readable_log))
+            .await
+            .unwrap();
+
+        let local = Conversation {
+            topic_id: "topic-1".to_string(),
+            last_seq: 100,
+            last_read_seq: 100,
+            unread: 0,
+            last_message_seq: Some(100),
+            last_message: Some(readable_log.content.clone()),
+            last_message_at: readable_log.created_at.clone(),
+            last_sender_id: "user2".to_string(),
+            ..Default::default()
+        };
+        let conv_table = store.message_storage.table::<Conversation>().await.unwrap();
+        conv_table
+            .set("", &local.topic_id, Some(&local))
+            .await
+            .unwrap();
+
+        let server = Conversation {
+            topic_id: "topic-1".to_string(),
+            last_seq: 101,
+            last_read_seq: 100,
+            unread: 1,
+            last_message_seq: Some(101),
+            last_message: Some(Content {
+                content_type: "text".to_string(),
+                text: "hidden system message".to_string(),
+                unreadable: true,
+                ..Default::default()
+            }),
+            last_message_at: "2026-05-21T10:00:01Z".to_string(),
+            last_sender_id: "system".to_string(),
+            ..Default::default()
+        };
+
+        let merged = store.merge_conversations(vec![server]).await;
+        assert_eq!(merged.len(), 1);
+        assert_eq!(merged[0].last_message_seq, Some(100));
+        assert_eq!(
+            merged[0].last_message.as_ref().unwrap().text,
+            "readable summary"
+        );
+    }
 }