@vanzxy/baileys 1.5.7 → 1.5.8

package/lib/Socket/chats.js

@@ -732,15 +732,37 @@ export const makeChatsSocket = (config) => {
             ev.on('creds.update', onUpdate);
         });
     };
+    // Vanz@Fix (perf) --- appPatch() unconditionally round-tripped resyncAppState() to the WA
+    // server on EVERY single call, even for back-to-back patches (e.g. updateProfileName then
+    // immediately archiving/muting a chat) where the local version was already fresh from the
+    // resync a few hundred ms ago. That round trip is the main source of the multi-second delay
+    // people notice on things like "ganti nama". Cache the last-synced timestamp per collection
+    // name and skip the resync if it happened within RESYNC_TTL_MS — WA's own client does the
+    // same kind of short-lived debouncing. Set RESYNC_TTL_MS to 0 to restore the old always-resync
+    // behavior if this ever causes a stale-version conflict in practice.
+    const RESYNC_TTL_MS = 4000;
+    const lastResyncAt = new Map();
     const appPatch = async (patchCreate) => {
         const name = patchCreate.type;
+        const t0 = Date.now();
         const myAppStateKeyId = await waitForAppStateKeyId();
+        const tKey = Date.now();
         let initial;
         let encodeResult;
         await appStatePatchMutex.mutex(async () => {
             await authState.keys.transaction(async () => {
                 logger.debug({ patch: patchCreate }, 'applying app patch');
-                await resyncAppState([name], false);
+                const lastSync = lastResyncAt.get(name) ?? 0;
+                const freshEnough = RESYNC_TTL_MS > 0 && Date.now() - lastSync < RESYNC_TTL_MS;
+                if (!freshEnough) {
+                    await resyncAppState([name], false);
+                    lastResyncAt.set(name, Date.now());
+                }
+                const tResync = Date.now();
+                logger.debug(
+                    { patch: name, waitedForKeyMs: tKey - t0, resyncMs: freshEnough ? 0 : tResync - tKey, skippedResync: freshEnough },
+                    'appPatch timing'
+                );
                 const { [name]: currentSyncVersion } = await authState.keys.get('app-state-sync-version', [name]);
                 initial = currentSyncVersion ? ensureLTHashStateVersion(currentSyncVersion) : newLTHashState();
                 encodeResult = await encodeSyncdPatch(patchCreate, myAppStateKeyId, initial, getAppStateSyncKey);
@@ -1068,6 +1090,11 @@ export const makeChatsSocket = (config) => {
             if (syncState === SyncState.Syncing) {
                 // All collections will be synced, so clear any blocked ones
                 blockedCollections.clear();
+                // Vanz@Fix (perf cache invalidation) --- a full sync is about to run for every
+                // collection, so any per-collection "recently resynced" cache from appPatch()
+                // is now stale by definition; drop it so the next appPatch() call resyncs fresh
+                // instead of trusting a pre-full-sync timestamp.
+                lastResyncAt.clear();
                 logger.info('Doing app state sync');
                 await resyncAppState(ALL_WA_PATCH_NAMES, true);
                 // Sync is complete, go online and flush everything
@@ -1129,6 +1156,9 @@ export const makeChatsSocket = (config) => {
     ev.on('connection.update', ({ connection, receivedPendingNotifications }) => {
         if (connection === 'close') {
             blockedCollections.clear();
+            // Vanz@Fix (perf cache invalidation) --- connection dropped, so any "recently
+            // resynced" timestamps are no longer trustworthy once we reconnect.
+            lastResyncAt.clear();
             clearTimeout(historySyncPausedTimeout);
             historySyncPausedTimeout = undefined;
         }

package/lib/Utils/MessageBuilder.js

@@ -336,6 +336,14 @@ class Toolkit {
 
 		const isWAUrl = (str) => /^https?:\/\/[^/]*\.whatsapp\.net\//i.test(str);
 
+		// Vanz@Fix (crash guard) --- keep the original raw url around so that if the
+		// resolveUrl=true upload-to-'@newsletter' round trip (Toolkit.toUrl -> prepareWAMessageMedia)
+		// throws/rejects (blocked account, network hiccup, WA server refusal, etc.), we can
+		// gracefully fall back to the raw url instead of letting the rejection bubble up
+		// unhandled through waitAllPromises() and take the whole process down. Only applies
+		// when the input was actually a url string; buffers/base64 have no such fallback.
+		const rawUrlFallback = typeof media === 'string' && isUrl(media) ? media : undefined;
+
 		if (Array.isArray(media)) {
 			return Promise.all(
 				media.map((item) =>
@@ -395,7 +403,16 @@ class Toolkit {
 		// same `Toolkit.toUrl(_client, media, mediaType)` call (dead branching left over from an
 		// earlier version that must have treated buffer vs non-buffer input differently). Collapsed
 		// to a single return; `originalIsBuffer` is now unused and removed below.
-		return Toolkit.toUrl(_client, media, mediaType);
+		//
+		// Vanz@Fix (crash guard) --- toUrl() uploads to WA's media server under a spoofed
+		// '@newsletter' jid; if that upload fails for any reason, fall back to the raw url
+		// (when we have one) instead of letting the exception propagate and crash the caller.
+		try {
+			return await Toolkit.toUrl(_client, media, mediaType);
+		} catch (err) {
+			if (rawUrlFallback) return rawUrlFallback;
+			throw err;
+		}
 	}
 
 	/** Read an mp4 buffer's duration (seconds) straight from its moov atom, no ffprobe needed. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vanzxy/baileys",
-  "version": "1.5.7",
+  "version": "1.5.8",
   "description": "Enhanced Baileys fork by Vanzxy — based on @itsliaaa/baileys + @whiskeysockets/baileys with fixes for audio group status and clean media without newsletter button.",
   "type": "module",
   "module": "./lib/index.js",