bb-fca 2.0.7 → 2.0.9

package/src/deltas/apis/posting/post.ts

@@ -24,6 +24,7 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
       let privacy = 'SELF';
       let photos = [];
       let videoId: string | null = null;
+      let groupID: string | null = null;
 
       if (typeof options === 'string') {
         postMessage = options;
@@ -32,6 +33,7 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
         privacy = options.privacy || 'SELF';
         photos = options.photos || [];
         videoId = options.video || null;
+        groupID = options.groupID || null;
       } else {
         throw new Error('Invalid input: expected string or object.');
       }
@@ -59,10 +61,12 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
         .substring(2)}`;
       const idempotenceToken = `${composerSessionId}_FEED`;
 
+      const isGroup = !!groupID;
+
       const variables: any = {
         input: {
           composer_entry_point: 'inline_composer',
-          composer_source_surface: 'newsfeed',
+          composer_source_surface: isGroup ? 'group' : 'newsfeed',
           composer_type: 'feed',
           idempotence_token: idempotenceToken,
           source: 'WWW',
@@ -97,11 +101,11 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
           actor_id: ctx.userID,
           client_mutation_id: '1',
         },
-        feedLocation: 'NEWSFEED',
+        feedLocation: isGroup ? 'GROUP' : 'NEWSFEED',
         feedbackSource: 1,
         focusCommentID: null,
         gridMediaWidth: null,
-        groupID: null,
+        groupID: groupID,
         scale: 2,
         privacySelectorRenderLocation: 'COMET_STREAM',
         checkPhotosToReelsUpsellEligibility: true,
@@ -112,7 +116,7 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
         isFeed: true,
         isFundraiser: false,
         isFunFactPost: false,
-        isGroup: false,
+        isGroup: isGroup,
         isEvent: false,
         isTimeline: false,
         isSocialLearning: false,
@@ -123,7 +127,8 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
         canUserManageOffers: false,
         __relay_internal__pv__CometUFIShareActionMigrationrelayprovider: true,
         __relay_internal__pv__CometUFI_dedicated_comment_routable_dialog_gkrelayprovider: false,
-        __relay_internal__pv__CometUFICommentAutoTranslationTyperelayprovider: 'ORIGINAL',
+        __relay_internal__pv__CometUFICommentAutoTranslationTyperelayprovider:
+          'ORIGINAL',
         __relay_internal__pv__IsWorkUserrelayprovider: false,
         __relay_internal__pv__CometUFIReactionsEnableShortNamerelayprovider: false,
         __relay_internal__pv__FBReels_deprecate_short_form_video_context_gkrelayprovider: true,
@@ -289,14 +294,28 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
   }
 
   /**
-   * Gets comments from a Facebook post.
-   * @param {string|object} postID - The post ID (string) or options object.
-   * @param {string} postID.story_fbid - The story FBID from the permalink URL.
-   * @param {string} postID.id - The account ID from the permalink URL.
+   * Gets comments from a Facebook post, with pagination support.
+   * @param {string|object} postID - The post URL (string) or options object.
+   * @param {string} [postID.url] - Direct Facebook post URL.
+   * @param {string} [postID.story_fbid] - The story FBID.
+   * @param {string} [postID.id] - The account ID.
+   * @param {string} [postID.after] - Cursor string to fetch the next page.
+   * @param {string} [postID.feedback_id] - Feedback ID required for pagination (returned in page_info).
    * @param {Function} [callback] - Optional callback function.
-   * @returns {Promise<Array>} Array of comments with author info, text, timestamps, etc.
+   * @returns {Promise<{comments: Array, page_info: object}>} Object with comments array and pagination info.
    */
-  async function getPostComments(postID, callback) {
+  async function getPostComments(postID, optionsOrCallback?, callback?) {
+    // Support: getComments(url), getComments(url, cb), getComments(url, opts), getComments(url, opts, cb)
+    let paginationOpts: any = null;
+    if (typeof optionsOrCallback === 'function') {
+      callback = optionsOrCallback;
+    } else if (
+      typeof optionsOrCallback === 'object' &&
+      optionsOrCallback !== null
+    ) {
+      paginationOpts = optionsOrCallback;
+    }
+
     let resolveFunc: Function = function() {};
     let rejectFunc: Function = function() {};
 
@@ -313,37 +332,173 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
       };
 
     try {
-      let story_fbid, accountID;
+      // ── Pagination mode: fetch next page via GraphQL ──────────────────
+      // Merge pagination from either postID (object) or second-arg options
+      const afterCursor: string | undefined =
+        paginationOpts?.after ||
+        (typeof postID === 'object' && postID !== null
+          ? postID.after
+          : undefined);
+      const feedbackId: string | undefined =
+        paginationOpts?.feedback_id ||
+        (typeof postID === 'object' && postID !== null
+          ? postID.feedback_id
+          : undefined);
+
+      if (afterCursor && feedbackId) {
+        // Use GraphQL to fetch next page of comments using the cursor
+        // feedbackId is the GraphQL ID (base64 of "feedback:<numeric_id>")
+        const variables: Record<string, any> = {
+          commentsAfterCount: -1,
+          commentsAfterCursor: afterCursor,
+          commentsBeforeCount: null,
+          commentsBeforeCursor: null,
+          commentsIntentToken: null,
+          feedLocation: 'POST_PERMALINK_DIALOG',
+          focusCommentID: null,
+          scale: 1,
+          useDefaultActor: false,
+          id: feedbackId,
+          __relay_internal__pv__CometUFICommentAutoTranslationTyperelayprovider:
+            'ORIGINAL',
+          __relay_internal__pv__CometUFICommentAvatarStickerAnimatedImagerelayprovider: false,
+          __relay_internal__pv__CometUFICommentActionLinksRewriteEnabledrelayprovider: false,
+          __relay_internal__pv__IsWorkUserrelayprovider: false,
+        };
+
+        const form = {
+          av: ctx.userID,
+          fb_api_caller_class: 'RelayModern',
+          fb_api_req_friendly_name: 'CommentsListComponentsPaginationQuery',
+          variables: JSON.stringify(variables),
+          doc_id: '35385759421023325',
+          server_timestamps: 'true',
+        };
+
+        const gqlRes = await defaultFuncs.post(
+          'https://www.facebook.com/api/graphql/',
+          ctx.jar,
+          form,
+          ctx.globalOptions,
+          ctx,
+        );
+
+        let gqlData: any;
+        if (
+          typeof gqlRes.body === 'object' &&
+          gqlRes.body !== null &&
+          !Buffer.isBuffer(gqlRes.body)
+        ) {
+          gqlData = gqlRes.body;
+        } else {
+          const body = gqlRes.body.toString();
+          try {
+            gqlData = JSON.parse(body);
+          } catch (e) {
+            // Multi-line JSON stream — take first line
+            gqlData = JSON.parse(body.split('\n')[0]);
+          }
+        }
+
+        // Navigate to comments in GraphQL response
+        const commentsConnection =
+          gqlData?.data?.node?.comment_rendering_instance_for_feed_location
+            ?.comments ??
+          gqlData?.data?.feedback?.comment_rendering_instance_for_feed_location
+            ?.comments ??
+          null;
+
+        const result: any[] = [];
+        let page_info: any = null;
+
+        if (commentsConnection) {
+          page_info = commentsConnection.page_info || null;
+          (commentsConnection.edges || []).forEach((edge: any) => {
+            if (!edge?.node) return;
+            const c: any = {
+              id: edge.node.legacy_fbid,
+              graphql_id: edge.node.id,
+              text:
+                edge.node.body?.text || edge.node.preferred_body?.text || '',
+              created_time: edge.node.created_time,
+              author: {
+                id: edge.node.author?.id,
+                name: edge.node.author?.name,
+                avatar: edge.node.author?.profile_picture_depth_0?.uri,
+              },
+              reply_count: edge.node.feedback?.replies_fields?.count || 0,
+              total_reply_count:
+                edge.node.feedback?.replies_fields?.total_count || 0,
+              depth: edge.node.depth || 0,
+              attachments: edge.node.attachments || [],
+            };
+            if (edge.node.feedback?.replies_connection?.edges) {
+              c.replies = edge.node.feedback.replies_connection.edges
+                .map((re: any) => {
+                  if (!re?.node) return null;
+                  return {
+                    id: re.node.legacy_fbid,
+                    text:
+                      re.node.body?.text || re.node.preferred_body?.text || '',
+                    created_time: re.node.created_time,
+                    author: {
+                      id: re.node.author?.id,
+                      name: re.node.author?.name,
+                      avatar: re.node.author?.profile_picture_depth_0?.uri,
+                    },
+                  };
+                })
+                .filter((r: any) => r !== null);
+            }
+            result.push(c);
+          });
+        }
+
+        callback(null, { comments: result, page_info });
+        return returnPromise;
+      }
+
+      // ── Initial load mode: fetch HTML and parse ───────────────────────
+      let url: string;
 
-      // Handle both string and object input
       if (typeof postID === 'string') {
-        // If it's a simple post ID, construct URL with user's ID
-        story_fbid = postID;
-        accountID = ctx.userID;
-      } else if (typeof postID === 'object') {
-        story_fbid = postID.story_fbid;
-        accountID = postID.id || ctx.userID;
+        if (postID.startsWith('https://') || postID.startsWith('http://')) {
+          url = postID;
+        } else if (postID.startsWith('/')) {
+          url = `https://www.facebook.com${postID}`;
+        } else if (/^\d+$/.test(postID)) {
+          url = `https://www.facebook.com/permalink.php?story_fbid=${postID}&id=${ctx.userID}`;
+        } else {
+          url = `https://www.facebook.com/permalink.php?story_fbid=${postID}&id=${ctx.userID}`;
+        }
+      } else if (typeof postID === 'object' && postID !== null) {
+        const story_fbid = postID.story_fbid;
+        const accountID = postID.id || ctx.userID;
+        const postUrl = postID.url;
+
+        if (postUrl) {
+          url = postUrl.startsWith('http')
+            ? postUrl
+            : `https://www.facebook.com${postUrl}`;
+        } else if (story_fbid) {
+          url = `https://www.facebook.com/permalink.php?story_fbid=${story_fbid}&id=${accountID}`;
+        } else {
+          throw new Error('Object input must have story_fbid or url field.');
+        }
       } else {
         throw new Error(
-          'Invalid input: expected string or object with story_fbid and id.',
+          'Invalid input: expected string (URL or postID) or object with story_fbid/url.',
         );
       }
 
-      if (!story_fbid) {
-        throw new Error('Post ID or story_fbid is required.');
-      }
-
-      // Construct the permalink URL
-      const url = `https://www.facebook.com/permalink.php?story_fbid=${story_fbid}&id=${accountID}`;
-
       // Make GET request to fetch the page HTML with cookies
       const resData = await utils.get(url, ctx.jar, {}, ctx.globalOptions, ctx);
       const html = resData.body.toString();
 
-      // Extract comments using new logic
-      const commentList = extractCommentsFromHTML(html);
+      // Extract comments and page_info from HTML
+      const { comments, page_info } = extractCommentsFromHTML(html);
 
-      callback(null, commentList);
+      callback(null, { comments, page_info });
     } catch (err) {
       utils.error('getPostComments', err);
       callback(err);
@@ -370,9 +525,13 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
   /**
    * Extract comments from HTML using new parsing logic
    * @private
+   * @returns {{ comments: any[], page_info: any | null }}
    */
-  function extractCommentsFromHTML(htmlContent) {
-    const comments = [];
+  function extractCommentsFromHTML(
+    htmlContent: string,
+  ): { comments: any[]; page_info: any | null } {
+    const comments: any[] = [];
+    let page_info: any = null;
 
     try {
       // Find all script tags containing JSON data
@@ -381,7 +540,7 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
       );
 
       if (!scriptMatches) {
-        return comments;
+        return { comments, page_info };
       }
 
       // Loop through each script tag
@@ -442,8 +601,32 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
                       commentData.edges &&
                       Array.isArray(commentData.edges)
                     ) {
+                      // Extract page_info (cursor pagination info)
+                      if (commentData.page_info && !page_info) {
+                        page_info = {
+                          end_cursor: commentData.page_info.end_cursor || null,
+                          has_next_page:
+                            commentData.page_info.has_next_page || false,
+                          has_previous_page:
+                            commentData.page_info.has_previous_page || false,
+                          start_cursor:
+                            commentData.page_info.start_cursor || null,
+                        };
+                        // Also try to capture feedback_id for GraphQL pagination
+                        try {
+                          const feedback =
+                            result.data.node_v2?.comet_sections?.feedback?.story
+                              ?.story_ufi_container?.story?.feedback_context
+                              ?.feedback_target_with_context
+                              ?.comment_list_renderer?.feedback;
+                          if (feedback?.id && !page_info.feedback_id) {
+                            page_info.feedback_id = feedback.id;
+                          }
+                        } catch (_) {}
+                      }
+
                       // Extract comments
-                      commentData.edges.forEach((edge) => {
+                      commentData.edges.forEach((edge: any) => {
                         if (!edge.node) return;
 
                         const comment: any = {
@@ -472,7 +655,7 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
                         // Get replies if available
                         if (edge.node.feedback?.replies_connection?.edges) {
                           comment.replies = edge.node.feedback.replies_connection.edges
-                            .map((replyEdge) => {
+                            .map((replyEdge: any) => {
                               if (!replyEdge.node) return null;
                               return {
                                 id: replyEdge.node.legacy_fbid,
@@ -490,7 +673,7 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
                                 },
                               };
                             })
-                            .filter((r) => r !== null);
+                            .filter((r: any) => r !== null);
                         }
 
                         comments.push(comment);
@@ -510,7 +693,218 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
       utils.error('extractCommentsFromHTML', error);
     }
 
-    return comments;
+    return { comments, page_info };
+  }
+
+  /**
+   * Extract the numeric `post_id` (and related IDs) from a Facebook post HTML page.
+   *
+   * This follows the same pipeline as `getPostComments`:
+   * 1. Fetches the page HTML with session cookies (GET request).
+   * 2. Scans every `<script type="application/json" data-sjs>` block.
+   * 3. Searches each parsed JSON tree for `"post_id"` strings (and `"story_id"`,
+   *    `"feedback_id"`, etc.) that appear alongside the post data.
+   *
+   * Works with **all** URL formats:
+   * - `/posts/pfbid{token}`  ← pfbid (server resolves it during HTML render)
+   * - `/posts/{numericID}`
+   * - `permalink.php?story_fbid=...`
+   *
+   * @param {string} urlOrID - Full Facebook post URL, or a plain numeric post ID.
+   *   If a numeric ID is passed, it is fetched as
+   *   `facebook.com/permalink.php?story_fbid={id}&id={userID}`.
+   * @param {Function} [callback] - Optional node-style `(err, result)` callback.
+   * @returns {Promise<{
+   *   post_id:     string | null,   // numeric post ID found in HTML ("post_id":"…")
+   *   story_id:    string | null,   // numeric story/post ID (alias)
+   *   feedback_id: string | null,   // base64 GraphQL feedback ID
+   *   post_url:    string,          // URL that was actually fetched
+   * }>}
+   *
+   * @example
+   * const { post_id } = await api.post.getPostIDFromURL(
+   *   'https://www.facebook.com/tuyetcollection/posts/pfbid0Yo6XDaKKnFKpENu3g2c2to1zJe7jFoZNr2NqjiXRiHmwjsy8dwbE84y4n7syCSfMl'
+   * );
+   * console.log(post_id);  // '1510599910435387'
+   *
+   * // Then react using the real numeric ID
+   * await api.post.reactWithInfo(post_id, 'LOVE');
+   */
+  async function getPostIDFromURL(
+    urlOrID: string,
+    callback?: Function,
+  ): Promise<any> {
+    let resolveFunc: Function = function() {};
+    let rejectFunc: Function = function() {};
+
+    const returnPromise = new Promise<any>((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    callback =
+      callback ||
+      function(err: any, data: any) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+
+    try {
+      if (!urlOrID) throw new Error('urlOrID is required.');
+
+      // ── Build fetch URL ────────────────────────────────────────────────
+      let fetchUrl: string;
+
+      if (urlOrID.startsWith('http://') || urlOrID.startsWith('https://')) {
+        fetchUrl = urlOrID;
+      } else if (urlOrID.startsWith('/')) {
+        fetchUrl = `https://www.facebook.com${urlOrID}`;
+      } else if (/^\d+$/.test(urlOrID)) {
+        // plain numeric ID → use permalink.php format (same as getPostComments)
+        fetchUrl = `https://www.facebook.com/permalink.php?story_fbid=${urlOrID}&id=${ctx.userID}`;
+      } else {
+        // pfbid token without full URL
+        fetchUrl = `https://www.facebook.com/permalink.php?story_fbid=${urlOrID}&id=${ctx.userID}`;
+      }
+
+      // ── Fetch HTML ─────────────────────────────────────────────────────
+      const resData = await utils.get(
+        fetchUrl,
+        ctx.jar,
+        {},
+        ctx.globalOptions,
+        ctx,
+      );
+      const html = resData.body.toString() as string;
+
+      // ── Helpers ────────────────────────────────────────────────────────
+      /** Deep-search an object tree; call visitor(value, key) on every value. */
+      function deepSearch(
+        obj: any,
+        visitor: (v: any, k: string | number) => void,
+      ): void {
+        if (!obj || typeof obj !== 'object') return;
+        for (const key of Object.keys(obj)) {
+          visitor(obj[key], key);
+          deepSearch(obj[key], visitor);
+        }
+      }
+
+      /** Find the first string value of `fieldName` anywhere in `obj`. */
+      function findField(obj: any, fieldName: string): string | null {
+        let found: string | null = null;
+        deepSearch(obj, (v, k) => {
+          if (found) return;
+          if (k === fieldName && typeof v === 'string' && v.length > 0) {
+            found = v;
+          }
+        });
+        return found;
+      }
+
+      // ── Parse <script data-sjs> blocks (same as getPostComments) ───────
+      const scriptMatches = html.match(
+        /<script type="application\/json"\s+data-content-len="\d+"\s+data-sjs>(.*?)<\/script>/gs,
+      );
+
+      let post_id: string | null = null;
+      let story_id: string | null = null;
+      let feedback_id: string | null = null;
+
+      if (scriptMatches) {
+        outer: for (const scriptTag of scriptMatches) {
+          try {
+            const inner = scriptTag.match(/<script[^>]*>(.*?)<\/script>/s);
+            if (!inner) continue;
+
+            const jsonData = JSON.parse(inner[1]);
+
+            if (!jsonData.require || !Array.isArray(jsonData.require)) continue;
+
+            for (const req of jsonData.require) {
+              if (!Array.isArray(req)) continue;
+
+              if (req[0] === 'ScheduledServerJS' && req[1] === 'handle') {
+                const payload = req[3];
+                if (!payload || !Array.isArray(payload)) continue;
+
+                for (const item of payload) {
+                  if (!item.__bbox?.require) continue;
+
+                  for (const bboxReq of item.__bbox.require) {
+                    if (!Array.isArray(bboxReq)) continue;
+
+                    if (
+                      bboxReq[0] === 'RelayPrefetchedStreamCache' &&
+                      bboxReq[1] === 'next'
+                    ) {
+                      const streamData = bboxReq[3];
+                      if (!Array.isArray(streamData) || streamData.length < 2)
+                        continue;
+
+                      const bboxData = streamData[1];
+                      if (!bboxData?.__bbox?.result) continue;
+
+                      const result = bboxData.__bbox.result;
+
+                      // ── Search for post_id / story_id ─────────────────
+                      if (!post_id) post_id = findField(result, 'post_id');
+                      if (!story_id) story_id = findField(result, 'story_id');
+
+                      // ── Search for feedback_id (same path as getPostComments) ──
+                      if (!feedback_id) {
+                        try {
+                          const feedback =
+                            result.data?.node_v2?.comet_sections?.feedback
+                              ?.story?.story_ufi_container?.story
+                              ?.feedback_context?.feedback_target_with_context
+                              ?.comment_list_renderer?.feedback;
+                          if (feedback?.id) feedback_id = feedback.id;
+                        } catch (_) {}
+
+                        // Fallback: deep-search for feedback_id string
+                        if (!feedback_id)
+                          feedback_id = findField(result, 'feedback_id');
+                      }
+
+                      // Stop once we have the numeric post_id
+                      if (post_id) break outer;
+                    }
+                  }
+                }
+              }
+            }
+          } catch (_) {
+            continue; // skip malformed JSON blocks
+          }
+        }
+      }
+
+      // ── Fallback: regex scan on raw HTML ────────────────────────────────
+      // "post_id":"1510599910435387"  or  "post_id":1510599910435387
+      if (!post_id) {
+        const m = html.match(/"post_id"\s*:\s*"?(\d{10,20})"?/);
+        if (m) post_id = m[1];
+      }
+      if (!story_id) {
+        const m = html.match(/"story_id"\s*:\s*"?(\d{10,20})"?/);
+        if (m) story_id = m[1];
+      }
+
+      const resultObj = {
+        post_id,
+        story_id: story_id || post_id, // they're often the same
+        feedback_id,
+        post_url: fetchUrl,
+      };
+
+      callback(null, resultObj);
+    } catch (err) {
+      utils.error('getPostIDFromURL', err);
+      callback(err);
+    }
+
+    return returnPromise;
   }
 
   /**
@@ -748,8 +1142,6 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
         .post('https://www.facebook.com/api/graphql/', ctx.jar, configForm, {})
         .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
 
-
-
       // Extract config (endpoints, service info)
       // NOTE: config is returned as a JSON string under data.viewer
       let startUri =
@@ -795,8 +1187,6 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
         )
         .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
 
-
-
       // ===== Step 3: Initialize Upload Session =====
       // Browser sends: POST vupload2.facebook.com/ajax/video/upload/requests/start/?__a=1
       // Cross-subdomain: must manually extract cookies + send full auth params
@@ -832,8 +1222,6 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
         av: ctx.userID,
       };
 
-
-
       const startRes = await utils
         .post(startRequestUrl, ctx.jar, startForm, ctx.globalOptions, ctx, {
           X_fb_video_waterfall_id: waterfallId,
@@ -847,8 +1235,6 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
 
         .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
 
-
-
       const videoId = startRes?.payload?.video_id || startRes?.video_id;
       const uploadSessionId =
         startRes?.payload?.upload_session_id || startRes?.upload_session_id;
@@ -891,7 +1277,6 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
         'Sec-Fetch-Site': 'same-site',
       };
 
-
       const probeRes = await utils.get(
         ruploadBaseUrl,
         ctx.jar,
@@ -901,7 +1286,6 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
         corsHeaders,
       );
 
-
       // ===== Step 5: Upload Binary Data =====
       const uploadHeaders = {
         'Content-Type': 'application/octet-stream',
@@ -918,7 +1302,6 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
         ...corsHeaders,
       };
 
-
       const uploadRes = await utils.postRaw(
         ruploadBaseUrl,
         ctx.jar,
@@ -977,7 +1360,6 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
         lsd: ctx.lsd || '',
       };
 
-
       const receiveRes = await utils
         .post(
           receiveUrl.toString(),
@@ -1026,11 +1408,686 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
     return returnPromise;
   }
 
+  /**
+   * React to a Facebook post (like, love, haha, wow, sad, angry).
+   *
+   * @param {string} feedbackId - The feedback ID. Can be:
+   *   - A raw numeric post ID (e.g. "1624250182241514")
+   *   - A base64-encoded feedback ID (e.g. "ZmVlZGJhY2s6MTYyN...")
+   *   - The literal string "feedback:<postID>"
+   * @param {string} [reaction="LIKE"] - Reaction type:
+   *   "LIKE" | "LOVE" | "HAHA" | "WOW" | "SAD" | "ANGRY" | "CARE"
+   *   or equivalent emojis: "👍" | "❤️" | "😂" | "😮" | "😢" | "😡" | "🤗"
+   * @param {Function} [callback] - Optional callback function.
+   * @returns {Promise<object>} The server response.
+   */
+  async function reactToPost(
+    feedbackId: string,
+    reaction: string = 'LIKE',
+    callback?: Function,
+  ) {
+    try {
+      if (!feedbackId) {
+        throw new Error('feedbackId is required.');
+      }
+
+      // ── Reaction ID map ────────────────────────────────────────────────
+      // IDs sourced from live Facebook reaction metadata.
+      // Only non-deprecated reactions are listed as primary keys.
+      // Deprecated reactions kept for backward-compat.
+      const REACTION_IDS: Record<string, string> = {
+        // ── Active reactions ─────────────────────────────────────────────
+        LIKE:    '1635855486666999', // Thích       (type:1)  #0866FF
+        LOVE:    '1678524932434102', // Yêu thích   (type:2)  #f33e58
+        WOW:     '478547315650144',  // Wow         (type:3)  #f7b125
+        HAHA:    '115940658764963',  // Haha        (type:4)  #f7b125
+        SAD:     '908563459236466',  // Buồn        (type:7)  #f7b125
+        ANGRY:   '444813342392137',  // Phẫn nộ     (type:8)  #e9710f
+        CARE:    '613557422527858',  // Thương thương (type:16) #f7b125
+        SUPPORT: '613557422527858',  // alias CARE
+        DOROTHY: '1663186627268800', // Biết ơn     (type:11) #7e64c4
+        TOTO:    '899779720071651',  // Tự hào      (type:12) #ec7ebd
+        // ── Deprecated (kept for backward-compat) ────────────────────────
+        YAY:      '1667835766830853', // Chúc mừng  (type:5  - deprecated)
+        CONFUSED: '1536130110011063', // Khó hiểu   (type:10 - deprecated)
+        SELFIE:   '869508936487422',  // Ảnh selfie  (type:13 - deprecated)
+        FLAME:    '938644726258608',  // Bày tỏ (flame, type:14 - deprecated)
+        PLANE:    '1609920819308489', // Bày tỏ (plane, type:15 - deprecated)
+        // ── Emoji aliases ────────────────────────────────────────────────
+        '👍': '1635855486666999', // LIKE
+        '❤️': '1678524932434102', // LOVE
+        '😮': '478547315650144',  // WOW
+        '😂': '115940658764963',  // HAHA
+        '😢': '908563459236466',  // SAD
+        '😡': '444813342392137',  // ANGRY
+        '🤗': '613557422527858',  // CARE/Support
+        // ── Vietnamese name aliases ──────────────────────────────────────
+        'THÍCH':         '1635855486666999',
+        'YÊU THÍCH':     '1678524932434102',
+        'BUỒN':          '908563459236466',
+        'PHẪN NỘ':       '444813342392137',
+        'THƯƠNG THƯƠNG': '613557422527858',
+        'BIẾT ƠN':       '1663186627268800',
+        'TỰ HÀO':        '899779720071651',
+      };
+
+      const reactionKey = reaction.toUpperCase
+        ? reaction.toUpperCase()
+        : reaction;
+      const reactionId = REACTION_IDS[reactionKey] || REACTION_IDS[reaction];
+      if (!reactionId) {
+        throw new Error(
+          `Unknown reaction: "${reaction}". Valid values: LIKE, LOVE, WOW, HAHA, SAD, ANGRY, CARE, SUPPORT, DOROTHY, TOTO`,
+        );
+      }
+
+      // ── Normalise feedbackId → base64 "feedback:<postID>" format ───────
+      let encodedFeedbackId = feedbackId;
+
+      // Plain numeric post ID → encode
+      if (/^\d+$/.test(feedbackId)) {
+        encodedFeedbackId = Buffer.from(`feedback:${feedbackId}`).toString(
+          'base64',
+        );
+      } else {
+        // Try to detect if it's already a valid base64 string by decoding
+        try {
+          const decoded = Buffer.from(feedbackId, 'base64').toString('utf-8');
+          if (!decoded.startsWith('feedback:')) {
+            // Not yet a feedback base64 – wrap and encode
+            const raw = feedbackId.startsWith('feedback:')
+              ? feedbackId
+              : `feedback:${feedbackId}`;
+            encodedFeedbackId = Buffer.from(raw).toString('base64');
+          }
+          // else already properly encoded – keep as-is
+        } catch (_) {
+          // keep original value
+        }
+      }
+
+      // ── Build session IDs ──────────────────────────────────────────────
+      const crypto = require('node:crypto');
+      const sessionId = crypto.randomUUID
+        ? crypto.randomUUID()
+        : [
+            crypto.randomBytes(4).toString('hex'),
+            crypto.randomBytes(2).toString('hex'),
+            crypto.randomBytes(2).toString('hex'),
+            crypto.randomBytes(2).toString('hex'),
+            crypto.randomBytes(6).toString('hex'),
+          ].join('-');
+      const downstreamSessionId = crypto.randomUUID
+        ? crypto.randomUUID()
+        : [
+            crypto.randomBytes(4).toString('hex'),
+            crypto.randomBytes(2).toString('hex'),
+            crypto.randomBytes(2).toString('hex'),
+            crypto.randomBytes(2).toString('hex'),
+            crypto.randomBytes(6).toString('hex'),
+          ].join('-');
+
+      // ── Variables payload (mirrors CometUFIFeedbackReactMutation) ──────
+      const variables = {
+        input: {
+          // attribution_id_v2 identifies the React component tree that triggered
+          // the reaction (format: "<Component>,<surface>,<trigger>,<ts>,<seq>,<groupID>,,").
+          // Pass ctx.attribution_id_v2 when you have it from a page scrape.
+          attribution_id_v2: ctx.attribution_id_v2 || '',
+          feedback_id: encodedFeedbackId,
+          feedback_reaction_id: reactionId,
+          feedback_source: 'OBJECT',
+          is_tracking_encrypted: true,
+          // tracking is an encrypted server-generated token array.
+          // Carry it through ctx when available; fall back to [].
+          tracking:
+            Array.isArray(ctx.tracking) && ctx.tracking.length
+              ? ctx.tracking
+              : [],
+          session_id: sessionId,
+          downstream_share_session_id: downstreamSessionId,
+          // The page URL where the reaction was performed
+          downstream_share_session_origin_uri:
+            ctx.currentUrl || 'https://www.facebook.com/',
+          downstream_share_session_start_time: String(Date.now()),
+          actor_id: ctx.userID,
+          client_mutation_id: String(Math.floor(Math.random() * 10)),
+        },
+        useDefaultActor: false,
+        __relay_internal__pv__CometUFIReactionsEnableShortNamerelayprovider: false,
+      };
+
+      // ── POST to /api/graphql/ ──────────────────────────────────────────
+      // Includes every form field present in the original captured request.
+      const lsd = ctx.lsd || ctx.fb_dtsg;
+      const form = {
+        av: ctx.userID,
+        __aaid: '0',
+        __user: ctx.userID,
+        __a: '1',
+        __req: Math.floor(Math.random() * 99).toString(36),
+        // Opaque session-state tokens generated by the browser on every page
+        // load. Carry them through ctx when available so they match the live
+        // session; otherwise fall back to empty strings (FB tolerates it).
+        __hs: ctx.hs || '20536.HCSV2:comet_pkg.2.1...0',
+        dpr: '1',
+        __ccg: 'EXCELLENT',
+        __rev: ctx.revision || '',
+        __s: ctx.__s || '',
+        __hsi: ctx.__hsi || '',
+        __dyn: ctx.__dyn || '',
+        __csr: ctx.__csr || '',
+        __hsdp: ctx.__hsdp || '',
+        __hblp: ctx.__hblp || '',
+        __sjsp: ctx.__sjsp || '',
+        __comet_req: '15',
+        fb_dtsg: ctx.fb_dtsg,
+        jazoest: ctx.jazoest,
+        lsd,
+        __spin_r: ctx.revision || '',
+        __spin_b: 'trunk',
+        __spin_t: Math.floor(Date.now() / 1000).toString(),
+        // __crn is the Comet route name (page type). Use ctx value or a safe
+        // default that works for both feed and group pages.
+        __crn: ctx.__crn || 'comet.fbweb.CometHomeRoute',
+        fb_api_caller_class: 'RelayModern',
+        fb_api_req_friendly_name: 'CometUFIFeedbackReactMutation',
+        server_timestamps: 'true',
+        variables: JSON.stringify(variables),
+        doc_id: '34430477113234631',
+      };
+
+      const response = await defaultFuncs
+        .post('https://www.facebook.com/api/graphql/', ctx.jar, form, {})
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (response.errors) {
+        throw new Error(JSON.stringify(response.errors));
+      }
+
+      const result = {
+        success: true,
+        reaction: reactionKey,
+        reactionId,
+        feedbackId: encodedFeedbackId,
+        data:
+          response?.data?.feedback_react ||
+          response?.data?.story_act ||
+          response?.data ||
+          response,
+      };
+
+      if (callback) {
+        callback(null, result);
+      }
+
+      return result;
+    } catch (err) {
+      utils.error('reactToPost', err);
+      if (callback) {
+        callback(err);
+      }
+      throw err;
+    }
+  }
+
+  // ── Helper: parse CometSinglePostDialogContentQuery response ───────────
+  function _extractTrackingFromNode(node: any): string[] {
+    if (Array.isArray(node.tracking)) return node.tracking.filter(Boolean);
+    if (node.tracking && typeof node.tracking === 'string')
+      return [node.tracking];
+    return [];
+  }
+
+  function _extractFeedbackTarget(
+    feedbackStory: any,
+  ): { feedback_id: string | null; post_url: string | null } {
+    const ufiCtx =
+      feedbackStory.story_ufi_container?.story?.feedback_context ??
+      feedbackStory.feedback_context ??
+      null;
+    if (!ufiCtx) return { feedback_id: null, post_url: null };
+
+    const feedbackTarget =
+      ufiCtx.feedback_target_with_context ??
+      ufiCtx.ufi_renderer?.feedback ??
+      null;
+
+    return {
+      feedback_id: feedbackTarget?.id ?? null,
+      post_url: feedbackTarget?.url ?? null,
+    };
+  }
+
+  function _extractPostInfoFields(
+    response: any,
+    userID: string,
+  ): {
+    tracking: string[];
+    feedback_id: string | null;
+    attribution_id_v2: string;
+    post_url: string | null;
+  } {
+    try {
+      const node = response?.data?.node ?? response?.data?.node_v2 ?? null;
+      if (!node)
+        return {
+          tracking: [],
+          feedback_id: null,
+          attribution_id_v2: '',
+          post_url: null,
+        };
+
+      let tracking = _extractTrackingFromNode(node);
+      let feedback_id: string | null = null;
+      let post_url: string | null = null;
+      let attribution_id_v2 = '';
+
+      const feedbackStory =
+        node.comet_sections?.feedback?.story ??
+        node.comet_sections?.content?.story ??
+        null;
+
+      if (feedbackStory) {
+        // Prefer tracking from UFI story (more specific)
+        const storyTracking = _extractTrackingFromNode(feedbackStory);
+        if (storyTracking.length > 0) tracking = storyTracking;
+
+        post_url = feedbackStory.permalink ?? feedbackStory.url ?? null;
+
+        // Build attribution_id_v2 matching live browser format
+        const ts = Date.now();
+        const seq = Math.floor(Math.random() * 999999);
+        attribution_id_v2 =
+          `CometSinglePostDialogRoot.react,comet.post.single_dialog,unexpected,${ts},${seq},,,;` +
+          `CometHomeRoot.react,comet.home,logo,${ts - 5000},${seq +
+            1},${userID},229#230#301,`;
+
+        const target = _extractFeedbackTarget(feedbackStory);
+        feedback_id = target.feedback_id;
+        if (target.post_url) post_url = target.post_url;
+      }
+
+      // Fallback: deep path from node directly
+      if (!feedback_id) {
+        const fb =
+          node.comet_sections?.feedback?.story?.story_ufi_container?.story
+            ?.feedback_context?.feedback_target_with_context ?? null;
+        if (fb?.id) feedback_id = fb.id;
+      }
+
+      return { tracking, feedback_id, attribution_id_v2, post_url };
+    } catch {
+      return {
+        tracking: [],
+        feedback_id: null,
+        attribution_id_v2: '',
+        post_url: null,
+      };
+    }
+  }
+
+  /**
+
+   * Fetch post metadata using CometSinglePostDialogContentQuery.
+   * Returns the `tracking` token array, `feedback_id`, and `attribution_id_v2`
+   * required for accurate reactions via reactToPost().
+   *
+   * @param {string} storyID - The story node ID (base64-encoded, e.g. "UzpfS...").
+   *   Can also be a raw numeric post ID — will be auto-encoded.
+   * @param {Function} [callback] - Optional callback function.
+   * @returns {Promise<object>} Object with tracking, feedback_id, attribution_id_v2, and raw data.
+   *
+   * @example
+   * // Get tracking token then react
+   * const info = await api.create.getPostInfo('1510599910435387');
+   * await api.create.reactPost(info.feedback_id, 'LIKE');
+   */
+  async function getPostInfo(
+    storyID: string,
+    callback?: Function,
+  ): Promise<any> {
+    let _resolve: (v: any) => void;
+    let _reject: (e: any) => void;
+
+    const returnPromise = new Promise<any>((res, rej) => {
+      _resolve = res;
+      _reject = rej;
+    });
+
+    const done: Function =
+      callback ??
+      ((err: any, data: any) => {
+        if (err) return _reject(err);
+        _resolve(data);
+      });
+
+    try {
+      if (!storyID) {
+        throw new Error('storyID is required.');
+      }
+
+      // ── Encode storyID if it's a raw numeric post ID ──────────────────
+      // Facebook storyID format: base64("S:<ownerID>:<postID>:<postID>") or
+      // base64("UzpfS<ownerID>:<postID>:<postID>")
+      // If user passes a plain numeric ID, encode it as feedback ID format
+      // and let the server return the full story node.
+      // Usually users pass the post numeric ID (story_fbid), so we build
+      // the proper base64 story node ID: "S:f<userID>:<postID>:<postID>"
+      let encodedStoryID = storyID;
+      if (/^\d+$/.test(storyID)) {
+        // Raw numeric post ID → build story node ID: S:f<actorID>:<postID>:<postID>
+        const nodeString = `S:f${ctx.userID}:${storyID}:${storyID}`;
+        const b64 = Buffer.from(nodeString)
+          .toString('base64')
+          .replaceAll('+', '-')
+          .replaceAll('/', '_')
+          .replaceAll('=', '');
+        const pad = b64.length % 4;
+        encodedStoryID = pad ? b64 + '='.repeat(4 - pad) : b64;
+      }
+
+      // ── Variables matching CometSinglePostDialogContentQuery ──────────
+      const variables = {
+        feedbackSource: 2, // POST_PERMALINK_DIALOG
+        feedLocation: 'POST_PERMALINK_DIALOG',
+        focusCommentID: null,
+        privacySelectorRenderLocation: 'COMET_STREAM',
+        renderLocation: 'permalink',
+        scale: 1,
+        shouldChangeNodeFieldName: true,
+        storyID: encodedStoryID,
+        useDefaultActor: false,
+        // Relay provider flags (copy from live request)
+        __relay_internal__pv__GHLShouldChangeAdIdFieldNamerelayprovider: true,
+        __relay_internal__pv__GHLShouldChangeSponsoredDataFieldNamerelayprovider: true,
+        __relay_internal__pv__CometFeedStory_enable_post_permalink_white_space_clickrelayprovider: false,
+        __relay_internal__pv__CometUFICommentActionLinksRewriteEnabledrelayprovider: false,
+        __relay_internal__pv__CometUFICommentAvatarStickerAnimatedImagerelayprovider: false,
+        __relay_internal__pv__IsWorkUserrelayprovider: false,
+        __relay_internal__pv__TestPilotShouldIncludeDemoAdUseCaserelayprovider: false,
+        __relay_internal__pv__FBReels_deprecate_short_form_video_context_gkrelayprovider: true,
+        __relay_internal__pv__FBReels_enable_view_dubbed_audio_type_gkrelayprovider: true,
+        __relay_internal__pv__CometImmersivePhotoCanUserDisable3DMotionrelayprovider: false,
+        __relay_internal__pv__WorkCometIsEmployeeGKProviderrelayprovider: false,
+        __relay_internal__pv__IsMergQAPollsrelayprovider: false,
+        __relay_internal__pv__FBReelsMediaFooter_comet_enable_reels_ads_gkrelayprovider: true,
+        __relay_internal__pv__CometUFIReactionsEnableShortNamerelayprovider: false,
+        __relay_internal__pv__CometUFICommentAutoTranslationTyperelayprovider:
+          'ORIGINAL',
+        __relay_internal__pv__CometUFIShareActionMigrationrelayprovider: true,
+        __relay_internal__pv__CometUFISingleLineUFIrelayprovider: false,
+        __relay_internal__pv__CometUFI_dedicated_comment_routable_dialog_gkrelayprovider: true,
+        __relay_internal__pv__FBReelsIFUTileContent_reelsIFUPlayOnHoverrelayprovider: true,
+        __relay_internal__pv__GroupsCometGYSJFeedItemHeightrelayprovider: 150,
+        __relay_internal__pv__ShouldEnableBakedInTextStoriesrelayprovider: false,
+        __relay_internal__pv__StoriesShouldIncludeFbNotesrelayprovider: false,
+      };
+
+      const lsd = ctx.lsd || ctx.fb_dtsg;
+      const form = {
+        av: ctx.userID,
+        __aaid: '0',
+        __user: ctx.userID,
+        __a: '1',
+        __req: Math.floor(Math.random() * 99).toString(36),
+        __hs: ctx.hs || '20536.HCSV2:comet_pkg.2.1...0',
+        dpr: '1',
+        __ccg: 'EXCELLENT',
+        __rev: ctx.revision || '',
+        __s: ctx.__s || '',
+        __hsi: ctx.__hsi || '',
+        __dyn: ctx.__dyn || '',
+        __csr: ctx.__csr || '',
+        __hsdp: ctx.__hsdp || '',
+        __hblp: ctx.__hblp || '',
+        __sjsp: ctx.__sjsp || '',
+        __comet_req: '15',
+        fb_dtsg: ctx.fb_dtsg,
+        jazoest: ctx.jazoest,
+        lsd,
+        __spin_r: ctx.revision || '',
+        __spin_b: 'trunk',
+        __spin_t: Math.floor(Date.now() / 1000).toString(),
+        __crn: ctx.__crn || 'comet.fbweb.CometHomeRoute',
+        fb_api_caller_class: 'RelayModern',
+        fb_api_req_friendly_name: 'CometSinglePostDialogContentQuery',
+        server_timestamps: 'true',
+        variables: JSON.stringify(variables),
+        doc_id: '26187019677574345',
+      };
+
+      const response = await defaultFuncs
+        .post('https://www.facebook.com/api/graphql/', ctx.jar, form, {})
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (response.errors) {
+        throw new Error(JSON.stringify(response.errors));
+      }
+
+      // ── Extract tracking, feedback_id, attribution_id_v2 from response ─
+      // The response structure for CometSinglePostDialogContentQuery:
+      // data.node → story node
+      //   .comet_sections.feedback.story → UFI (Unified Feedback Interface)
+      //     .story_ufi_container.story.feedback_context
+      //       .feedback_target_with_context
+      //         .id              → feedback_id (base64)
+      //         .url             → post URL
+      //   .tracking              → encrypted tracking token array
+      //   .id                    → story graphql node ID
+
+      const {
+        tracking,
+        feedback_id,
+        attribution_id_v2,
+        post_url,
+      } = _extractPostInfoFields(response, ctx.userID);
+
+      const result = {
+        success: true,
+        storyID: encodedStoryID,
+        feedback_id,
+        tracking,
+        attribution_id_v2,
+        post_url,
+        data: response,
+      };
+
+      done(null, result);
+    } catch (err) {
+      utils.error('getPostInfo', err);
+      done(err);
+    }
+
+    return returnPromise;
+  }
+
+  /**
+   * React to a post with full tracking accuracy.
+   *
+   * Combines `getPostInfo` + `reactToPost` in one call:
+   * 1. Fetches real `tracking` tokens and `feedback_id` from Facebook via
+   *    `CometSinglePostDialogContentQuery`.
+   * 2. Patches those values into `ctx` so `reactToPost` sends them correctly.
+   * 3. Falls back gracefully if `getPostInfo` fails (uses original IDs).
+   *
+   * @param {string} storyID  - Raw numeric post ID **or** base64 storyID.
+   *   Examples: `'1510599910435387'`  or  `'UzpfSTEwMDA0...'`
+   * @param {string} [reaction='LIKE'] - Reaction type.
+   *   Valid: `'LIKE'|'LOVE'|'HAHA'|'WOW'|'SAD'|'ANGRY'|'CARE'`
+   *   or emoji aliases: `'👍'|'❤️'|'😂'|'😮'|'😢'|'😡'|'🤗'`
+   * @param {Function} [callback] - Optional node-style callback `(err, result)`.
+   * @returns {Promise<object>} Same shape as `reactToPost()`.
+   *
+   * @example
+   * // Easiest usage — just pass the numeric post ID
+   * const result = await api.post.reactWithInfo('1510599910435387', 'LOVE');
+   *
+   * // With callback
+   * api.post.reactWithInfo('1510599910435387', 'HAHA', (err, res) => {
+   *   if (err) console.error(err);
+   *   else console.log('Reacted!', res);
+   * });
+   */
+  async function reactToPostWithTracking(
+    storyID: string,
+    reaction: string = 'LIKE',
+    callback?: Function,
+  ): Promise<any> {
+    try {
+      if (!storyID) throw new Error('storyID is required.');
+
+      // ── Step 1: fetch tracking info from Facebook ──────────────────────
+      let feedbackId = storyID; // fallback: use storyID as-is
+      let infoErr: any = null;
+
+      try {
+        const info = await getPostInfo(storyID);
+
+        // Patch tracking + attribution_id_v2 into ctx so reactToPost uses them
+        if (info.tracking?.length) ctx.tracking = info.tracking;
+        if (info.attribution_id_v2)
+          ctx.attribution_id_v2 = info.attribution_id_v2;
+        if (info.post_url) ctx.currentUrl = info.post_url;
+
+        // Prefer server-provided feedback_id; fall back to storyID
+        if (info.feedback_id) feedbackId = info.feedback_id;
+      } catch (err) {
+        infoErr = err;
+        utils.warn(
+          'reactToPostWithTracking',
+          `getPostInfo failed (falling back to storyID as feedbackId): ${err}`,
+        );
+      }
+
+      // ── Step 2: react using the enriched ctx ───────────────────────────
+      const result = await reactToPost(feedbackId, reaction);
+
+      // Attach info-fetch error to result so callers can inspect it
+      if (infoErr) (result as any).infoError = String(infoErr);
+
+      if (callback) callback(null, result);
+      return result;
+    } catch (err) {
+      utils.error('reactToPostWithTracking', err);
+      if (callback) callback(err);
+      throw err;
+    }
+  }
+
+  // ── pfbid (Permalink-Friendly Base ID) ───────────────────────────────────
+  // pfbid is an opaque server-side token that Facebook generates.
+  // It CANNOT be decoded client-side (it's internally hashed/encrypted).
+  //
+  // The correct workflow:
+  //   parsePostUrl(url)  → extracts the pfbid token from the URL path
+  //   getPostInfo(token) → sends pfbid to Facebook's GraphQL; server resolves it
+  //                        and returns the real numeric story_fbid in the response
+  //
+  // The returned storyID from parsePostUrl is either:
+  //   - A numeric string  (e.g. "1510599910435387")   → for /posts/{numericID} URLs
+  //   - A pfbid string    (e.g. "pfbid0Yo6XDa...")    → for /posts/pfbid{token} URLs
+  //
+  // Both work as input to getPostInfo / reactWithInfo.
+
+  /**
+   * Parse any Facebook post URL into a storyID suitable for `getPostInfo`.
+   *
+   * Supports all common URL patterns:
+   * - `https://www.facebook.com/{page}/posts/pfbid{token}`   ← pfbid (new style)
+   * - `https://www.facebook.com/{page}/posts/{numericID}`    ← plain numeric
+   * - `https://www.facebook.com/permalink.php?story_fbid={id}&id={page}`
+   * - `https://www.facebook.com/photo?fbid={id}&...`
+   * - `https://m.facebook.com/story.php?story_fbid={id}&...`
+   *
+   * @param {string} url - Any Facebook post URL.
+   * @returns {{ storyID: string; pageSlug: string | null; format: 'pfbid'|'numeric'|'query' }}
+   *   `storyID` is either a numeric string or the full pfbid token (including "pfbid" prefix).
+   *   Pass it directly to `getPostInfo()` or `reactWithInfo()`.
+   * @throws If no recognisable post ID can be extracted.
+   *
+   * @example
+   * // pfbid URL → storyID is the pfbid token; pass it to getPostInfo which resolves it server-side
+   * const { storyID } = parsePostUrl('https://www.facebook.com/tuyetcollection/posts/pfbid0Yo6XDaKKnFKpENu3g2c2to1zJe7jFoZNr2NqjiXRiHmwjsy8dwbE84y4n7syCSfMl');
+   * // storyID = 'pfbid0Yo6XDaKKnFKpENu3g2c2to1zJe7jFoZNr2NqjiXRiHmwjsy8dwbE84y4n7syCSfMl'
+   * const info = await api.post.getPostInfo(storyID);  // Facebook resolves it → real ID in response
+   * await api.post.reactToPost(info.feedback_id, 'LOVE');
+   *
+   * // Easiest: reactWithInfo handles all of this automatically
+   * await api.post.reactWithInfo(storyID, 'LOVE');
+   *
+   * // Numeric URL → storyID is already the numeric ID
+   * const { storyID } = parsePostUrl('https://www.facebook.com/tuyetcollection/posts/1510599910435387');
+   * // storyID = '1510599910435387'
+   */
+  function parsePostUrl(
+    url: string,
+  ): { storyID: string; pageSlug: string | null; format: string } {
+    let parsed: URL;
+    try {
+      parsed = new URL(url);
+    } catch {
+      throw new Error(`parsePostUrl: invalid URL "${url}"`);
+    }
+
+    const path = parsed.pathname; // e.g. /tuyetcollection/posts/pfbid0Yo6...
+    const segments = path.split('/').filter(Boolean);
+
+    // ── Pattern 1: /{slug}/posts/{id_or_pfbid} ───────────────────────────
+    const postIdx = segments.indexOf('posts');
+    if (postIdx !== -1 && segments[postIdx + 1]) {
+      const token = segments[postIdx + 1];
+      const pageSlug = postIdx > 0 ? segments[postIdx - 1] : null;
+
+      if (token.startsWith('pfbid')) {
+        // pfbid is an opaque server token — cannot be decoded client-side.
+        // Return the full pfbid as storyID; Facebook GraphQL resolves it server-side.
+        return { storyID: token, pageSlug, format: 'pfbid' };
+      }
+      if (/^\d+$/.test(token)) {
+        return { storyID: token, pageSlug, format: 'numeric' };
+      }
+    }
+
+    // ── Pattern 2: /photo/{numericID} or /video/{numericID} ──────────────
+    for (const seg of ['photo', 'video', 'reel']) {
+      const idx = segments.indexOf(seg);
+      if (idx !== -1 && segments[idx + 1] && /^\d+$/.test(segments[idx + 1])) {
+        return {
+          storyID: segments[idx + 1],
+          pageSlug: null,
+          format: 'numeric',
+        };
+      }
+    }
+
+    // ── Pattern 3: query params ───────────────────────────────────────────
+    // permalink.php?story_fbid=&id=  |  photo?fbid=  |  story.php?story_fbid=
+    const storyFbid = parsed.searchParams.get('story_fbid');
+    if (storyFbid && /^\d+$/.test(storyFbid)) {
+      return { storyID: storyFbid, pageSlug: null, format: 'query' };
+    }
+
+    const fbid = parsed.searchParams.get('fbid');
+    if (fbid && /^\d+$/.test(fbid)) {
+      return { storyID: fbid, pageSlug: null, format: 'query' };
+    }
+
+    throw new Error(`parsePostUrl: could not extract post ID from "${url}"`);
+  }
+
   return {
     create: createPost,
     createPost: createPost,
     delete: deletePost,
     getComments: getPostComments,
+    getPostInfo: getPostInfo,
+    getPostIDFromURL: getPostIDFromURL,
+    parsePostUrl: parsePostUrl,
+    react: reactToPost,
+    reactToPost: reactToPost,
+    reactWithInfo: reactToPostWithTracking,
+    reactToPostWithTracking: reactToPostWithTracking,
     uploadPhoto: uploadPhoto,
     uploadVideo: uploadVideo,
   };