@lazyneoaz/metachat 6.0.9 → 6.0.10

package/dist/index.cjs

@@ -25552,6 +25552,7 @@ async function post(url2, reqJar, form, options, ctx, customHeader) {
     for (const key in form) {
       if (Object.prototype.hasOwnProperty.call(form, key)) {
         let value = form[key];
+        if (value == null) continue;
         if (getType(value) === "Object") {
           value = JSON.stringify(value);
         }
@@ -25589,6 +25590,7 @@ async function postFormData(url2, reqJar, form, qs2, options, ctx, customHeader)
   const formData = new import_form_data2.default();
   for (const key in form) {
     if (Object.prototype.hasOwnProperty.call(form, key)) {
+      if (form[key] == null) continue;
       formData.append(key, form[key]);
     }
   }
@@ -84842,6 +84844,165 @@ function _formatAttachment(attachment1, attachment2) {
         properties
       };
     }
+    // Legacy / Mercury attach_type cases. Every realtime NewMessage attachment
+    // is routed through this function, and Mercury (non-GraphQL) payloads carry
+    // attach_type values like "photo"/"video"/"file" — without these branches
+    // they all fell through to { type: "unknown" } and bots that switch on
+    // att.type saw nothing.
+    case "photo":
+      return {
+        type: "photo",
+        ID: attachment1.metadata?.fbid != null ? String(attachment1.metadata.fbid) : void 0,
+        filename: attachment1.fileName,
+        thumbnailUrl: attachment1.thumbnail_url,
+        previewUrl: attachment1.preview_url,
+        previewWidth: attachment1.preview_width,
+        previewHeight: attachment1.preview_height,
+        largePreviewUrl: attachment1.large_preview_url,
+        largePreviewWidth: attachment1.large_preview_width,
+        largePreviewHeight: attachment1.large_preview_height,
+        url: attachment1.metadata?.url,
+        width: attachment1.metadata?.dimensions != null ? String(attachment1.metadata.dimensions).split(",")[0] : void 0,
+        height: attachment1.metadata?.dimensions != null ? String(attachment1.metadata.dimensions).split(",")[1] : void 0,
+        name: attachment1.fileName
+      };
+    case "video":
+      return {
+        type: "video",
+        ID: attachment1.metadata?.fbid != null ? String(attachment1.metadata.fbid) : void 0,
+        filename: attachment1.name,
+        previewUrl: attachment1.preview_url,
+        previewWidth: attachment1.preview_width,
+        previewHeight: attachment1.preview_height,
+        url: attachment1.url,
+        width: attachment1.metadata?.dimensions?.width,
+        height: attachment1.metadata?.dimensions?.height,
+        duration: attachment1.metadata?.duration,
+        videoType: "unknown",
+        thumbnailUrl: attachment1.thumbnail_url
+      };
+    case "file":
+      return {
+        type: "file",
+        filename: attachment1.name,
+        ID: attachment2.id != null ? String(attachment2.id) : void 0,
+        url: attachment1.url,
+        isMalicious: attachment2.is_malicious,
+        contentType: attachment2.mime_type,
+        name: attachment1.name,
+        mimeType: attachment2.mime_type,
+        fileSize: attachment2.file_size
+      };
+    case "animated_image":
+      return {
+        type: "animated_image",
+        ID: attachment2.id != null ? String(attachment2.id) : void 0,
+        filename: attachment2.filename,
+        previewUrl: attachment1.preview_url,
+        previewWidth: attachment1.preview_width,
+        previewHeight: attachment1.preview_height,
+        url: attachment2.image_data?.url,
+        width: attachment2.image_data?.width,
+        height: attachment2.image_data?.height,
+        name: attachment1.name,
+        facebookUrl: attachment1.url,
+        thumbnailUrl: attachment1.thumbnail_url,
+        mimeType: attachment2.mime_type,
+        rawGifImage: attachment2.image_data?.raw_gif_image,
+        rawWebpImage: attachment2.image_data?.raw_webp_image,
+        animatedGifUrl: attachment2.image_data?.animated_gif_url,
+        animatedGifPreviewUrl: attachment2.image_data?.animated_gif_preview_url,
+        animatedWebpUrl: attachment2.image_data?.animated_webp_url,
+        animatedWebpPreviewUrl: attachment2.image_data?.animated_webp_preview_url
+      };
+    case "share": {
+      const share = attachment1.share || {};
+      const media = share.media || {};
+      const imageSize = media.image_size || {};
+      return {
+        type: "share",
+        ID: share.share_id != null ? String(share.share_id) : void 0,
+        url: attachment2.href,
+        title: share.title,
+        description: share.description,
+        source: share.source,
+        image: media.image,
+        width: imageSize.width,
+        height: imageSize.height,
+        playable: media.playable,
+        duration: media.duration,
+        subattachments: share.subattachments,
+        properties: {},
+        animatedImageSize: media.animated_image_size,
+        facebookUrl: share.uri,
+        target: share.target,
+        styleList: share.style_list
+      };
+    }
+    case "sticker": {
+      const meta2 = attachment1.metadata || {};
+      return {
+        type: "sticker",
+        ID: meta2.stickerID != null ? String(meta2.stickerID) : void 0,
+        url: attachment1.url,
+        packID: meta2.packID != null ? String(meta2.packID) : null,
+        spriteUrl: meta2.spriteURI,
+        spriteUrl2x: meta2.spriteURI2x,
+        width: meta2.width,
+        height: meta2.height,
+        caption: attachment2.caption,
+        description: attachment2.description,
+        frameCount: meta2.frameCount,
+        frameRate: meta2.frameRate,
+        framesPerRow: meta2.framesPerRow,
+        framesPerCol: meta2.framesPerCol,
+        stickerID: meta2.stickerID != null ? String(meta2.stickerID) : void 0,
+        spriteURI: meta2.spriteURI,
+        spriteURI2x: meta2.spriteURI2x
+      };
+    }
+    case "error":
+      return { type: "error", attachment1, attachment2 };
+    case "MessageLocation":
+    case "location": {
+      const story = blob && blob.story_attachment || attachment1.story_attachment || {};
+      const walkWhere = (raw) => {
+        try {
+          const outer = new URL(String(raw));
+          const u = outer.searchParams.get("u");
+          if (u) {
+            try {
+              const where1 = new URL(u).searchParams.get("where1");
+              if (where1) return where1;
+            } catch (_) {
+            }
+            const m = String(u).match(/where1=([^&]+)/);
+            if (m) return decodeURIComponent(m[1]);
+          }
+        } catch (_) {
+        }
+        return "";
+      };
+      const whereStr = walkWhere(story.url);
+      const address = whereStr.split(", ");
+      const latitude = Number.parseFloat(address[0]);
+      const longitude = Number.parseFloat(address[1]);
+      const image = story.media?.image;
+      return {
+        type: "location",
+        ID: blob?.legacy_attachment_id,
+        latitude: Number.isFinite(latitude) ? latitude : void 0,
+        longitude: Number.isFinite(longitude) ? longitude : void 0,
+        image: image?.uri,
+        width: image?.width,
+        height: image?.height,
+        url: whereStr || story.url,
+        address: whereStr,
+        facebookUrl: story.url,
+        target: story.target,
+        styleList: story.style_list
+      };
+    }
     default:
       return { type: "unknown", error: `Unrecognized attachment type: ${type}` };
   }
@@ -84914,7 +85075,11 @@ function getAdminTextMessageType(type) {
     case "unpin_messages_v2":
       return "log:unpin-message";
     case "pin_messages_v2":
-      return "log:pin-message";
+      return "log:thread-pinned";
+    case "joinable_group_link_mode_change":
+      return "log:link-status";
+    case "magic_words":
+      return "log:magic-words";
     case "change_thread_theme":
       return "log:thread-color";
     case "change_thread_icon":
@@ -84961,6 +85126,7 @@ function formatDeltaMessage(m) {
     author: senderID,
     userID: senderID,
     body,
+    args: body.trim().split(/\s+/),
     threadID: formatID((threadKey.threadFbId || threadKey.otherUserFbId || "").toString()),
     messageID: md.messageId,
     offlineThreadingId: md.offlineThreadingId,
@@ -85008,6 +85174,7 @@ function formatDeltaNewMessage(m) {
     author: senderID,
     userID: senderID,
     body,
+    args: body.trim().split(/\s+/),
     threadID,
     messageID: md.messageId,
     offlineThreadingId: md.offlineThreadingId,
@@ -85039,6 +85206,28 @@ function formatDeltaEvent(m) {
       logMessageType = "log:unsubscribe";
       logMessageData = { leftParticipantFbId: m.leftParticipantFbId };
       break;
+    case "UserLocation": {
+      const story = m.attachments?.[0]?.mercury?.extensible_attachment?.story_attachment || {};
+      logMessageType = "log:user-location";
+      logMessageData = {
+        Image: story.media?.image,
+        Location: story.target?.location_title,
+        coordinates: story.target?.coordinate,
+        url: story.url
+      };
+      break;
+    }
+    case "ApprovalQueue":
+      logMessageType = "log:approval-queue";
+      logMessageData = {
+        approvalQueue: {
+          action: m.action,
+          recipientFbId: m.recipientFbId,
+          requestSource: m.requestSource,
+          ...m.messageMetadata || {}
+        }
+      };
+      break;
     default:
       logMessageType = m.class;
       logMessageData = m;
@@ -85931,7 +86120,11 @@ async function scrapeTokens(ctx, defaultFuncs, state, force = false) {
 }
 function hasCometTokens(ctx) {
   const state = ctx.__cometTokens || {};
-  return Boolean(state.lsd && state.fb_dtsg);
+  if (tokenPairFresh(state)) return true;
+  if (!state.fetchedAt) {
+    return Boolean(state.lsd && state.fb_dtsg || ctx.lsd && ctx.fb_dtsg);
+  }
+  return false;
 }
 function invalidateCometTokens(ctx) {
   const state = tokenState(ctx);
@@ -87009,10 +87202,10 @@ function makeDefaults(html3, userID, ctx) {
       __req: reqId,
       __rev: ctx.revision || revision,
       __a: 1,
-      ...ctx && {
-        fb_dtsg: ctx.fb_dtsg,
-        jazoest: ctx.jazoest
-      },
+      // Only emit the document-token fields when they actually hold a value;
+      // spreading them unconditionally created `fb_dtsg=undefined` form entries.
+      ...ctx && ctx.fb_dtsg ? { fb_dtsg: ctx.fb_dtsg } : {},
+      ...ctx && ctx.jazoest ? { jazoest: ctx.jazoest } : {},
       // The Comet document token and its spin siblings gate GraphQL; include
       // them whenever they are known so no module has to remember.
       ...ctx && ctx.lsd ? { lsd: ctx.lsd } : {},
@@ -87116,6 +87309,11 @@ async function setOptions(globalOptions, options = {}) {
 
 // src/core/models/buildAPI.ts
 async function buildAPI(html3, jar2, netData, globalOptions, fbLinkFunc, errorRetrievingMsg) {
+  if (isLoggedOutDocument(html3)) {
+    throw new Error(
+      "Facebook returned the logged-out page for these cookies: the session is expired or invalid. Export a fresh appState from a logged-in browser and try again."
+    );
+  }
   const userID = (() => {
     const origins = [
       "https://www.facebook.com",
@@ -87985,6 +88183,115 @@ function editMessage_default(_defaultFuncs, _api, ctx) {
   };
 }
 
+// src/deltas/apis/mqtt/threadTasks.ts
+var THREAD_TASK_VERSIONS = {
+  // Thread settings mutations share one family: title, emoji, color, nickname,
+  // admin status, group image.
+  threadSettings: "8798795233522156",
+  addParticipant: "24502707779384158",
+  removeParticipant: "25002366262773827",
+  sendMessage: "24804310205905615",
+  forwardAttachment: "8768858626531631",
+  shareContact: "7214102258676893",
+  editMessage: "6903494529735864",
+  unsendMessage: "25393437286970779",
+  deleteMessage: "25909428212080747",
+  setReaction: "24585299697835063",
+  typingIndicator: "8965252033599983",
+  createPoll: "34195258046739157"
+};
+var APP_ID_LS = "2220391788200892";
+function mqttReady(ctx) {
+  return !!(ctx && ctx.mqttClient && ctx.mqttClient.connected);
+}
+async function publishThreadTask(ctx, label, queueName, payload, versionId, appId = APP_ID_LS) {
+  const task = {
+    failure_count: null,
+    label,
+    payload: JSON.stringify(payload),
+    queue_name: queueName
+  };
+  const content = buildWsTaskContent(ctx, [task], versionId, appId);
+  return publishLsRequestWithAck({
+    client: ctx.mqttClient,
+    content,
+    requestId: content.request_id,
+    extract: (parsed) => {
+      const body = parsed && parsed.payload;
+      if (!body || typeof body !== "object") return { success: true };
+      return body;
+    }
+  });
+}
+
+// src/deltas/apis/messaging/deleteMessage.ts
+function deleteMessage_default(defaultFuncs, _api, ctx) {
+  return function deleteMessage(messageOrMessages, callback) {
+    const cb = typeof callback === "function" ? callback : void 0;
+    let _resolve = () => {
+    };
+    let _reject = () => {
+    };
+    const returnPromise = new Promise((resolve, reject) => {
+      _resolve = resolve;
+      _reject = reject;
+    });
+    returnPromise.catch(() => {
+    });
+    const done = (err, data2) => {
+      if (cb) {
+        cb(err, data2);
+        return;
+      }
+      if (err) _reject(err);
+      else _resolve(data2);
+    };
+    const messages = Array.isArray(messageOrMessages) ? messageOrMessages : [messageOrMessages];
+    if (messages.length === 0 || messages.some((value) => value === null || typeof value === "undefined" || value === "")) {
+      done({ error: "deleteMessage: messageID is required." });
+      return returnPromise;
+    }
+    if (!mqttReady(ctx)) {
+      done({ error: "deleteMessage: not connected to MQTT." });
+      return returnPromise;
+    }
+    const tasks = messages.map((messageID) => {
+      const queueName = String(messageID);
+      return {
+        failure_count: null,
+        label: "146",
+        payload: JSON.stringify({
+          thread_key: queueName,
+          remove_type: 0,
+          sync_group: 1
+        }),
+        queue_name: queueName
+      };
+    });
+    let content;
+    try {
+      content = buildWsTaskContent(ctx, tasks, THREAD_TASK_VERSIONS.deleteMessage, APP_ID_LS);
+    } catch (error2) {
+      done(error2);
+      return returnPromise;
+    }
+    publishLsRequestWithAck({
+      client: ctx.mqttClient,
+      content,
+      requestId: content.request_id,
+      extract: (parsed) => {
+        const body = parsed && parsed.payload;
+        if (!body || typeof body !== "object") return { success: true };
+        return body;
+      }
+    }).then((result) => done(null, result)).catch((error2) => {
+      error("deleteMessage", error2?.error || error2?.message || error2);
+      done(error2);
+    });
+    return returnPromise;
+  };
+}
+
 // src/deltas/apis/messaging/getMessage.ts
 function formatExtensibleAttachment(ext) {
   if (!ext || Object.keys(ext).length === 0) return [];
@@ -89431,7 +89738,11 @@ function sendTypingIndicator_default(defaultFuncs, api, ctx) {
     options = options || {};
     let actualThreadID;
     let actualSendTyping;
-    if (typeof sendTyping === "string" || typeof sendTyping === "number") {
+    const firstLooksLikeThread = typeof sendTyping === "string" || typeof sendTyping === "number";
+    if (firstLooksLikeThread && typeof threadID === "boolean") {
+      actualThreadID = sendTyping;
+      actualSendTyping = threadID;
+    } else if (firstLooksLikeThread) {
       actualThreadID = sendTyping;
       actualSendTyping = true;
     } else {
@@ -90150,47 +90461,6 @@ function makeAiTheme_default(defaultFuncs, _api, ctx) {
   };
 }
 
-// src/deltas/apis/mqtt/threadTasks.ts
-var THREAD_TASK_VERSIONS = {
-  // Thread settings mutations share one family: title, emoji, color, nickname,
-  // admin status, group image.
-  threadSettings: "8798795233522156",
-  addParticipant: "24502707779384158",
-  removeParticipant: "25002366262773827",
-  sendMessage: "24804310205905615",
-  forwardAttachment: "8768858626531631",
-  shareContact: "7214102258676893",
-  editMessage: "6903494529735864",
-  unsendMessage: "25393437286970779",
-  deleteMessage: "25909428212080747",
-  setReaction: "24585299697835063",
-  typingIndicator: "8965252033599983",
-  createPoll: "34195258046739157"
-};
-var APP_ID_LS = "2220391788200892";
-function mqttReady(ctx) {
-  return !!(ctx && ctx.mqttClient && ctx.mqttClient.connected);
-}
-async function publishThreadTask(ctx, label, queueName, payload, versionId, appId = APP_ID_LS) {
-  const task = {
-    failure_count: null,
-    label,
-    payload: JSON.stringify(payload),
-    queue_name: queueName
-  };
-  const content = buildWsTaskContent(ctx, [task], versionId, appId);
-  return publishLsRequestWithAck({
-    client: ctx.mqttClient,
-    content,
-    requestId: content.request_id,
-    extract: (parsed) => {
-      const body = parsed && parsed.payload;
-      if (!body || typeof body !== "object") return { success: true };
-      return body;
-    }
-  });
-}
-
 // src/deltas/apis/messaging/unsendMessage.ts
 function extractUnsend(message) {
   try {
@@ -90462,9 +90732,15 @@ function searchMusic_default(defaultFuncs, _api, ctx) {
       cacheResult(ctx, cacheKey, result);
       return result;
     }
-    for (let retry = 0; retry < 6; retry++) {
-      await sleep(1e3 + retry * 600 + Math.floor(Math.random() * 350));
-      const retried = await attempt(retry >= 3 || !hasCometTokens(ctx));
+    let forcedScrape = false;
+    for (let retry = 0; retry < 2; retry++) {
+      await sleep(900 + retry * 1100 + Math.floor(Math.random() * 350));
+      let force = false;
+      if (!forcedScrape && !hasCometTokens(ctx)) {
+        force = true;
+        forcedScrape = true;
+      }
+      const retried = await attempt(force);
       if (isStaleTokenError(retried) || retried?.error || (retried?.errors || []).length) continue;
       const retryPage = collectTracks(retried);
       const retryTracks = retryPage.tracks.slice(0, count);
@@ -92210,6 +92486,22 @@ function formatMessagesGraphQLResponse(data2) {
               return "other";
           }
         })();
+        const logMessageData = (() => {
+          switch (d.__typename) {
+            case "ThreadNameMessage":
+              return { name: d.thread_name };
+            case "ParticipantLeftMessage":
+              return {
+                leftParticipantFbId: (d.participants_removed || []).map((p) => String(p.id))
+              };
+            case "ParticipantsAddedMessage":
+              return {
+                addedParticipants: (d.participants_added || []).map((p) => String(p.id))
+              };
+            default:
+              return d.extensible_message_admin_text || d.extensible_message_admin_text_type || d;
+          }
+        })();
         return {
           type: "event",
           messageID: d.message_id,
@@ -92220,7 +92512,8 @@ function formatMessagesGraphQLResponse(data2) {
           timestamp: d.timestamp_precise,
           snippet: d.snippet,
           logMessageType,
-          logMessageData: d.extensible_message_admin_text || d.extensible_message_admin_text_type || d
+          logMessageData,
+          eventData: d
         };
       }
       default:
@@ -92523,7 +92816,10 @@ function formatThreadGraphQLResponse2(messageThread) {
       },
       {}
     ) : {},
-    adminIDs: messageThread.thread_admins || [],
+    // thread_admins is [{id:"…"}]; callers test `adminIDs.includes(userID)`
+    // (the bot's getRole does exactly that), so hand back id strings like the
+    // reference. Returning the raw objects made every admin check false.
+    adminIDs: (messageThread.thread_admins || []).map((a) => String(a.id)),
     approvalMode: Boolean(messageThread.approval_mode),
     approvalQueue: (messageThread.group_approval_queue && messageThread.group_approval_queue.nodes || []).map((a) => ({
       inviterID: a.inviter.id,
@@ -92630,24 +92926,25 @@ function getThreadList_default(defaultFuncs, api, ctx) {
 }
 
 // src/deltas/apis/threads/getThreadPictures.ts
-function getThreadPictures_default(defaultFuncs, api, ctx) {
+var SHARED_PHOTOS_URL = "https://www.facebook.com/ajax/messaging/attachments/sharedphotos.php";
+function getThreadPictures_default(defaultFuncs, _api, ctx) {
+  const postSharedPhotos = (form) => defaultFuncs.post(SHARED_PHOTOS_URL, ctx.jar, form).then(parseAndCheckLogin(ctx, defaultFuncs));
   return async function getThreadPictures(threadID, offset = 0, limit = 5) {
-    const fetchAmount = Math.max(limit + offset, 20);
-    const history = await api.getThreadHistory(threadID, fetchAmount);
-    const urls = [];
-    for (const message of history || []) {
-      const attachments = message && message.attachments;
-      if (!Array.isArray(attachments)) continue;
-      for (const attachment of attachments) {
-        if (!attachment) continue;
-        if (attachment.type === "photo" || attachment.type === "image") {
-          const url2 = attachment.previewUrl || attachment.thumbnailUrl || attachment.url;
-          if (url2) urls.push(url2);
-        }
-      }
-    }
-    urls.reverse();
-    return urls.slice(offset, offset + limit);
+    const resData = await postSharedPhotos({ thread_id: threadID, offset, limit });
+    if (resData && resData.error) throw resData;
+    const images = resData && resData.payload && resData.payload.imagesData || [];
+    const urls = await Promise.all(
+      images.map(
+        (image) => postSharedPhotos({ thread_id: threadID, image_id: image.fbid }).then((detail) => {
+          if (detail && detail.error) throw detail;
+          const require2 = detail && detail.jsmods && detail.jsmods.require;
+          const block = require2 && require2[0] && require2[0][3] && require2[0][3][1];
+          const queryThreadID = block && block.query_metadata && block.query_metadata.query_path ? block.query_metadata.query_path[0]?.message_thread : void 0;
+          return block && block.query_results && block.query_results[queryThreadID] ? block.query_results[queryThreadID]?.message_images?.edges?.[0]?.node?.image2 : void 0;
+        })
+      )
+    );
+    return urls.filter(Boolean);
   };
 }
 
@@ -93927,6 +94224,18 @@ function parseDelta(defaultFuncs, api, ctx, globalCallback, v) {
   if (!v || !v.delta || typeof v.delta !== "object") return;
   if (v.delta.class == "NewMessage") {
     if (ctx.globalOptions.pageID && ctx.globalOptions.pageID != v.queue) return;
+    const liveAttachment = v.delta.attachments && v.delta.attachments.length === 1 ? v.delta.attachments[0]?.mercury?.extensible_attachment : void 0;
+    const liveStyles = liveAttachment?.story_attachment?.style_list;
+    if (Array.isArray(liveStyles) && liveStyles.includes("message_live_location")) {
+      v.delta.class = "UserLocation";
+      let fmtLive;
+      try {
+        fmtLive = formatDeltaEvent(v.delta);
+      } catch (err) {
+        return;
+      }
+      return globalCallback(null, fmtLive);
+    }
     (function resolveAttachmentUrl(i2) {
       if (!v.delta.attachments || !Array.isArray(v.delta.attachments) || i2 >= v.delta.attachments.length) {
         let fmtMsg;
@@ -94101,6 +94410,8 @@ function parseDelta(defaultFuncs, api, ctx, globalCallback, v) {
     case "ThreadName":
     case "ParticipantsAddedToGroupThread":
     case "ParticipantLeftGroupThread":
+    case "UserLocation":
+    case "ApprovalQueue":
       let fmtEvent;
       try {
         fmtEvent = formatDeltaEvent(v.delta);
@@ -94108,6 +94419,89 @@ function parseDelta(defaultFuncs, api, ctx, globalCallback, v) {
         return globalCallback({ error: "Problem parsing event", detail: err, res: v.delta, type: "parse_error" });
       }
       return globalCallback(null, fmtEvent);
+    case "ForcedFetch": {
+      const delta = v.delta;
+      if (!delta.threadKey) return;
+      const mid = delta.messageId;
+      const tid = delta.threadKey.threadFbId;
+      if (!mid || !tid) return;
+      const form = {
+        av: ctx.globalOptions.pageID || ctx.userID,
+        queries: JSON.stringify({
+          o0: {
+            doc_id: "2848441488556444",
+            query_params: {
+              thread_and_message_id: { thread_id: tid.toString(), message_id: mid }
+            }
+          }
+        })
+      };
+      defaultFuncs.post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form).then(parseAndCheckLogin(ctx, defaultFuncs)).then((resData) => {
+        if (!Array.isArray(resData) || !resData.length) return;
+        const last2 = resData[resData.length - 1] || {};
+        if (last2.error_results > 0) throw resData[0]?.o0?.errors;
+        if (last2.successful_results === 0) throw { error: "forcedFetch: there was no successful_results", res: resData };
+        const fetchData = resData[0]?.o0?.data?.message;
+        if (!fetchData || typeof fetchData !== "object") return;
+        if (ctx.loggedIn === false) return;
+        if (!ctx.globalOptions.selfListen && String(fetchData.message_sender?.id) === String(ctx.userID)) return;
+        if (fetchData.__typename === "ThreadImageMessage") {
+          const meta2 = fetchData.image_with_metadata || {};
+          return globalCallback(null, {
+            type: "event",
+            threadID: formatID(tid.toString()),
+            logMessageType: "log:thread-image",
+            logMessageData: {
+              image: {
+                attachmentID: meta2.legacy_attachment_id,
+                width: meta2.original_dimensions?.x,
+                height: meta2.original_dimensions?.y,
+                url: meta2.preview?.uri
+              }
+            },
+            logMessageBody: fetchData.snippet,
+            timestamp: fetchData.timestamp_precise,
+            author: fetchData.message_sender?.id
+          });
+        }
+        if (fetchData.__typename === "UserMessage") {
+          const ext = fetchData.extensible_attachment || {};
+          const story = ext.story_attachment || {};
+          const media = story.media || {};
+          const image = media.image || {};
+          return globalCallback(null, {
+            type: "message",
+            senderID: formatID(String(fetchData.message_sender?.id)),
+            body: fetchData.message?.text || "",
+            threadID: formatID(tid.toString()),
+            messageID: fetchData.message_id,
+            attachments: [
+              {
+                type: "share",
+                ID: ext.legacy_attachment_id,
+                url: story.url,
+                title: story.title_with_entities?.text,
+                description: story.description?.text,
+                source: story.source,
+                image: image.uri,
+                width: image.width,
+                height: image.height,
+                playable: media.is_playable || false,
+                duration: media.playable_duration_in_ms || 0,
+                subattachments: ext.subattachments,
+                properties: story.properties
+              }
+            ],
+            mentions: {},
+            timestamp: parseInt(String(fetchData.timestamp_precise)),
+            isGroup: String(fetchData.message_sender?.id) !== tid.toString()
+          });
+        }
+      }).catch((err) => {
+        warn("parseDelta", `ForcedFetch error: ${err?.message || err}`);
+      });
+      return;
+    }
   }
 }
 
@@ -94308,13 +94702,19 @@ var listenMqtt_default = (defaultFuncs, api, ctx) => {
     clearReconnectTimer();
     let delay3;
     if (throttled) {
-      delay3 = Math.min(lifecycle.throttleDelay + getJitter(8e3), MQTT_CONFIG.MAX_THROTTLE_DELAY);
+      delay3 = Math.min(
+        Math.max(MQTT_CONFIG.THROTTLE_DELAY, lifecycle.throttleDelay) + Math.abs(getJitter(8e3)),
+        MQTT_CONFIG.MAX_THROTTLE_DELAY
+      );
       lifecycle.throttleDelay = Math.min(
         lifecycle.throttleDelay * MQTT_CONFIG.RETRY_MULTIPLIER,
         MQTT_CONFIG.MAX_THROTTLE_DELAY
       );
     } else {
-      delay3 = Math.min(lifecycle.delay + getJitter(1500), MQTT_CONFIG.MAX_RETRY_DELAY);
+      delay3 = Math.min(
+        Math.max(MQTT_CONFIG.INITIAL_RETRY_DELAY, lifecycle.delay) + Math.abs(getJitter(1500)),
+        MQTT_CONFIG.MAX_RETRY_DELAY
+      );
       lifecycle.delay = Math.min(lifecycle.delay * MQTT_CONFIG.RETRY_MULTIPLIER, MQTT_CONFIG.MAX_RETRY_DELAY);
     }
     lifecycle.attempts++;
@@ -94698,6 +95098,7 @@ var apiModules = {
   refreshFbDtsg: refreshFbDtsg_default,
   enableAutoSaveAppState: enableAutoSaveAppState_default,
   editMessage: editMessage_default,
+  deleteMessage: deleteMessage_default,
   getMessage: getMessage_default,
   emoji: emoji_default,
   gcmember: gcmember_default,