channel-worker 2.4.5 → 2.5.0

package/scripts/upload_facebook.js

@@ -0,0 +1,1754 @@
+// Facebook (Page) upload via Page-wall Reel composer.
+// Flow: navigate https://www.facebook.com/ → click "Thước phim" entry in the
+// "Tạo bài viết" widget → modal opens fresh each time. Switched from Business
+// Suite composer (business.facebook.com/latest/reels_composer) because BS
+// stays on its own URL after publish — no way to capture the new reel URL.
+// Page-wall flow either navigates to /reel/<id>/ or surfaces the new reel
+// at the top of the Page wall so we can grab its href post-publish.
+//
+// UI elements in the Page-wall Reel modal (same as BS composer):
+//   "Thêm video" (Add video — opens native filechooser)
+//   3 inputs: Tiêu đề / Mô tả / Thẻ
+//   "Tiếp" → publish step → final "Đăng" / "Chia sẻ ngay"
+//
+// Strict-input contract (same as upload_youtube.js): every step throws on
+// failure. No silent bypass — the cmd is marked failed so the idea-mirror
+// surfaces the exact problem.
+
+const fs = require('fs');
+const path = require('path');
+const { downloadToTemp, safeUnlink } = require('./lib/download');
+
+async function firstVisible(locator, max = 5) {
+  const n = Math.min(await locator.count().catch(() => 0), max);
+  for (let i = 0; i < n; i++) {
+    if (await locator.nth(i).isVisible().catch(() => false)) return locator.nth(i);
+  }
+  return null;
+}
+
+async function isActionable(el) {
+  if (!(await el.isVisible().catch(() => false))) return false;
+  if (!(await el.isEnabled().catch(() => true))) return false;
+  const ariaDisabled = await el.getAttribute('aria-disabled').catch(() => null);
+  if (ariaDisabled === 'true') return false;
+  return true;
+}
+
+async function waitAndClick(loc, { timeoutMs = 60_000, log, label = 'button' } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await isActionable(loc)) {
+      await loc.click();
+      return;
+    }
+    await loc.page().waitForTimeout(800);
+  }
+  throw new Error(`${label} never became actionable within ${timeoutMs}ms`);
+}
+
+// Same inventory dump as iter-2 (kept for failure diagnostics).
+async function dumpInventory(page, log, tag) {
+  try {
+    const inv = await page.evaluate(() => {
+      const out = { fileInputs: [], buttons: [], dialogs: [] };
+      document.querySelectorAll("input[type='file']").forEach((el) => {
+        const r = el.getBoundingClientRect();
+        out.fileInputs.push({
+          accept: (el.accept || '').slice(0, 60),
+          hidden: r.width === 0 && r.height === 0,
+          parent: el.parentElement?.tagName?.toLowerCase() || '',
+        });
+      });
+      const seen = new Set();
+      document.querySelectorAll("[role='button'], button, [aria-label], [data-testid], [role='textbox']").forEach((el) => {
+        const r = el.getBoundingClientRect();
+        if (r.width < 8 || r.height < 8) return;
+        const aria = el.getAttribute('aria-label') || '';
+        const test = el.getAttribute('data-testid') || '';
+        const role = el.getAttribute('role') || '';
+        const text = (el.innerText || '').trim().slice(0, 60);
+        const key = `${aria}|${test}|${text}`;
+        if (seen.has(key)) return;
+        seen.add(key);
+        if (!aria && !test && !text) return;
+        out.buttons.push({ tag: el.tagName.toLowerCase(), role, aria: aria.slice(0, 60), testid: test.slice(0, 40), text });
+        if (out.buttons.length >= 60) return;
+      });
+      document.querySelectorAll("[role='dialog']").forEach((el) => {
+        out.dialogs.push({ aria: (el.getAttribute('aria-label') || '').slice(0, 80), text: (el.innerText || '').trim().slice(0, 120) });
+      });
+      return out;
+    }).catch(() => ({ fileInputs: [], buttons: [], dialogs: [] }));
+    log('info', `[fb-pw] inv-${tag}: fileInputs=${inv.fileInputs.length} buttons=${inv.buttons.length} dialogs=${inv.dialogs.length}`);
+    inv.dialogs.slice(0, 4).forEach((d, i) => log('info', `  ${tag} dialog[${i}] aria="${d.aria}" text="${d.text}"`));
+    inv.buttons.slice(0, 60).forEach((b, i) => log('info', `  ${tag} btn[${i}] <${b.tag} role="${b.role}" aria="${b.aria}" testid="${b.testid}">${b.text}</>`));
+    // Page-wall flow opens a modal; dump dialog-scoped buttons separately so
+    // we can see the publish CTA inside the modal (which is otherwise drowned
+    // out by the background page's nav buttons).
+    try {
+      const dlgBtns = await page.evaluate(() => {
+        const out = [];
+        document.querySelectorAll("[role='dialog']").forEach((dlg, di) => {
+          const seen = new Set();
+          dlg.querySelectorAll("[role='button'], button").forEach((el) => {
+            const r = el.getBoundingClientRect();
+            if (r.width < 8 || r.height < 8) return;
+            const aria = (el.getAttribute('aria-label') || '').slice(0, 80);
+            const text = (el.innerText || '').trim().slice(0, 60);
+            if (!aria && !text) return;
+            const key = `${di}|${aria}|${text}`;
+            if (seen.has(key)) return;
+            seen.add(key);
+            out.push({ di, aria, text, y: Math.round(r.y) });
+            if (out.length >= 40) return;
+          });
+        });
+        return out;
+      }).catch(() => []);
+      dlgBtns.forEach((b, i) => log('info', `  ${tag} dlg-btn[${i}] d${b.di} y=${b.y} aria="${b.aria}" "${b.text}"`));
+    } catch {}
+    return inv;
+  } catch (e) { log('warn', `[fb-pw] inv-${tag} failed: ${e.message}`); return null; }
+}
+
+async function dumpFailure(page, tag, log) {
+  try {
+    const os = require('os');
+    const dir = path.join(os.tmpdir(), 'cm-worker-pw');
+    fs.mkdirSync(dir, { recursive: true });
+    const png = path.join(dir, `fb-${tag}-${Date.now()}.png`);
+    await page.screenshot({ path: png, fullPage: false, timeout: 8000 }).catch(() => {});
+    log('warn', `[fb-pw] dump ${tag} — url=${page.url()} screenshot=${png}`);
+  } catch {}
+}
+
+// Some Business Suite views overlay an onboarding tutorial dialog (`js_*` aria-
+// label) that intercepts all clicks until dismissed. Click any visible "X" /
+// "Đã hiểu" / "Bỏ qua" inside the dialog, then check again.
+async function dismissBsOnboarding(page, log) {
+  for (let pass = 0; pass < 3; pass++) {
+    const dlg = page.locator("[role='dialog']").first();
+    const has = await dlg.count().catch(() => 0);
+    if (!has || !(await dlg.isVisible().catch(() => false))) return;
+    const phrases = ['Đã hiểu', 'Got it', 'Bỏ qua', 'Skip', 'Để sau', 'Not now', 'Đóng', 'Close', 'Tiếp tục', 'Continue'];
+    let clicked = false;
+    for (const p of phrases) {
+      const candidates = [
+        `[role='dialog'] [aria-label*='${p}']`,
+        `[role='dialog'] [role='button']:has-text('${p}')`,
+        `[role='dialog'] button:has-text('${p}')`,
+      ];
+      for (const sel of candidates) {
+        const hit = await firstVisible(page.locator(sel), 3);
+        if (!hit) continue;
+        try {
+          log('info', `[fb-pw] dismissing BS onboarding via "${sel}"`);
+          await hit.click({ timeout: 2500 });
+          await page.waitForTimeout(700);
+          clicked = true;
+          break;
+        } catch {}
+      }
+      if (clicked) break;
+    }
+    if (!clicked) {
+      try { await page.keyboard.press('Escape'); } catch {}
+      await page.waitForTimeout(500);
+      return;
+    }
+  }
+}
+
+async function run({ page, payload, log }) {
+  const {
+    video_url, title, description = '', tags = [],
+    visibility = 'public', format = 'short',
+  } = payload || {};
+  if (!video_url) throw new Error('No video_url provided');
+
+  log('info', '[fb-pw] selectors version=2026.06.01s-pagewall-thumb-60s-retry');
+
+  page.on('dialog', (d) => { d.accept().catch(() => {}); });
+
+  // Capture the freshly-published Reel's ID from FB's Graph API mutation
+  // response. Without this, the script's DOM scrape after publish was
+  // matching whatever stale /reel/ anchor was already in the page (FB shows
+  // recommendation tiles below the composer). The Graph mutation returns
+  // the new video/reel id in the JSON body — far more reliable.
+  const capturedReelIds = [];
+  let capturedReelIdsSnapshotLen = 0; // set right before publish click
+  page.on('response', async (resp) => {
+    try {
+      const u = resp.url();
+      // Widen URL match: FB publish mutations can fire under graphql,
+      // graphqlbatch, or legacy ajax/reels endpoints.
+      if (!/\/api\/graphql|\/api\/graphqlbatch|\/ajax\/reels|\/ajax\/composer|\/reel\/create|\/videos\/create/i.test(u)) return;
+      const ct = (resp.headers()['content-type'] || '');
+      if (!/json|javascript|text/i.test(ct)) return;
+      const text = await resp.text().catch(() => '');
+      if (!text) return;
+      // Capture VIDEO/REEL IDs only — NOT story_id/post_id (those are FB's
+      // newer 18-digit container IDs, e.g. 122101397445343435, that wrap a
+      // reel but don't resolve as canonical /reel/<id>/ URLs. The actual
+      // reel ID is a 15-digit shorter number that lives in videoID/reelID
+      // fields).
+      const matches = [];
+      for (const re of [
+        /"videoID"\s*:\s*"(\d{8,18})"/g,
+        /"video_id"\s*:\s*"(\d{8,18})"/g,
+        /"short_form_video_id"\s*:\s*"(\d{8,18})"/g,
+        /"reelID"\s*:\s*"(\d{8,18})"/g,
+        /"reel_id"\s*:\s*"(\d{8,18})"/g,
+        /"id"\s*:\s*"(\d{8,18})"[^}]*"__typename"\s*:\s*"Video"/g,
+        /"id"\s*:\s*"(\d{8,18})"[^}]*"__typename"\s*:\s*"Reel"/g,
+        /\/reel\/(\d{8,18})/g,
+      ]) {
+        let m;
+        while ((m = re.exec(text)) !== null) {
+          // Reel IDs are typically 15-16 digits. 17-18 digit IDs are FB's
+          // newer "story container" format that doesn't resolve as reel.
+          if (m[1].length >= 13 && m[1].length <= 16) matches.push(m[1]);
+        }
+      }
+      if (matches.length) {
+        capturedReelIds.push(...matches);
+      }
+    } catch { /* ignore */ }
+  });
+
+  log('info', '[fb-pw] downloading video to local…');
+  const videoPath = await downloadToTemp(video_url, { prefix: 'fb', ext: '.mp4' });
+  log('info', `[fb-pw] video at ${videoPath}`);
+
+  // Custom thumbnail — FB Reels DOES allow custom thumbnail uploads via web
+  // (unlike YT Shorts which is mobile-only). Best-effort: download if URL
+  // present, attempt upload on the thumbnail step, throw if the URL was
+  // provided but the upload UI is missing/broken (strict-input contract).
+  let thumbPath = null;
+  if (payload.thumbnail_url) {
+    try {
+      thumbPath = await downloadToTemp(payload.thumbnail_url, { prefix: 'fb-thumb', ext: '.png' });
+      log('info', `[fb-pw] thumbnail at ${thumbPath}`);
+    } catch (e) { log('warn', `[fb-pw] thumbnail download failed: ${e.message}`); }
+  }
+
+  try {
+    // 1) Open the Facebook Page wall (NOT Business Suite). The BS composer
+    //    couldn't capture the post URL after publish — the page stayed at
+    //    business.facebook.com/... with no navigation to the new reel. The
+    //    Page-wall flow opens a Reel modal whose publish flow either navigates
+    //    or shows a confirmation toast linking to the new reel.
+    log('info', '[fb-pw] open https://www.facebook.com/ (page wall flow) …');
+    await page.goto('https://www.facebook.com/', { waitUntil: 'domcontentloaded', timeout: 60_000 });
+    await page.waitForLoadState('networkidle', { timeout: 30_000 }).catch(() => {});
+    await page.waitForTimeout(4000);
+    log('info', `[fb-pw] home loaded — url=${page.url()}`);
+
+    // 2) Click the "Thước phim" entry inside the Page's "Tạo bài viết" widget.
+    //    This opens a FRESH Reel composer modal each time (no stale-draft
+    //    issue that plagued the BS composer). CRITICAL: scope to the "Tạo
+    //    bài viết" region — `[aria-label='Thước phim']` ALSO matches the
+    //    Reels-feed link in the sidebar nav, which navigates to /reel/...
+    //    instead of opening the composer (observed on the brain-made-simple
+    //    page wall — clicked feed link, played random viral reel).
+    log('info', '[fb-pw] click "Thước phim" entry inside "Tạo bài viết"…');
+    const reelEntryCandidates = [
+      // Scoped to the create-post widget — this is the only correct trigger.
+      "div[role='region'][aria-label='Tạo bài viết'] [aria-label='Thước phim']",
+      "div[role='region'][aria-label='Tạo bài viết'] [aria-label='Reel']",
+      "div[role='region'][aria-label='Tạo bài viết'] [aria-label='Reels']",
+      "div[role='region'][aria-label='Create post'] [aria-label='Reels']",
+    ];
+    let reelOpened = false;
+    for (const sel of reelEntryCandidates) {
+      const btn = await firstVisible(page.locator(sel), 5);
+      if (!btn) continue;
+      try {
+        await btn.click({ timeout: 3000 });
+        log('info', `[fb-pw] Thước phim clicked via "${sel}"`);
+        reelOpened = true;
+        break;
+      } catch {}
+    }
+    // Fallback — walk the "Tạo bài viết" region in JS, find a button whose
+    // text/aria starts with "Thước phim"/"Reel" but is NOT in the sidebar.
+    if (!reelOpened) {
+      const probed = await page.evaluate(() => {
+        const regions = document.querySelectorAll("[role='region'], [aria-label='Tạo bài viết']");
+        for (const region of regions) {
+          const aria = (region.getAttribute('aria-label') || '').toLowerCase();
+          if (!/tạo bài viết|create post/.test(aria)) continue;
+          const btns = region.querySelectorAll("[role='button'], button, a");
+          for (const b of btns) {
+            const t = (b.innerText || b.textContent || '').trim();
+            const al = (b.getAttribute('aria-label') || '').trim();
+            const sig = (t + '|' + al).toLowerCase();
+            if (/^thước phim|^reels?$/i.test(t.trim()) || /thước phim/i.test(al)) {
+              const r = b.getBoundingClientRect();
+              if (r.width < 8 || r.height < 8) continue;
+              b.setAttribute('__fbpw_reel_entry__', '1');
+              return { selector: "[__fbpw_reel_entry__='1']", text: t.slice(0, 40), aria: al.slice(0, 40) };
+            }
+          }
+        }
+        return null;
+      }).catch(() => null);
+      if (probed) {
+        try {
+          await page.locator(probed.selector).click({ timeout: 3000 });
+          log('info', `[fb-pw] Thước phim clicked via region-probe (text="${probed.text}" aria="${probed.aria}")`);
+          reelOpened = true;
+        } catch (e) {
+          log('warn', `[fb-pw] region-probe click failed: ${e.message.slice(0, 80)}`);
+        }
+      }
+    }
+    if (!reelOpened) {
+      await dumpInventory(page, log, 'no-reel-entry');
+      await dumpFailure(page, 'no-reel-entry', log);
+      throw new Error('FB home: "Thước phim" entry not found in "Tạo bài viết" widget (sidebar Reels feed link doesn\'t count — it navigates instead of opening composer)');
+    }
+    await page.waitForTimeout(4000);
+    const afterUrl = page.url();
+    log('info', `[fb-pw] after Thước phim click — url=${afterUrl}`);
+    // Sanity check: clicking the sidebar Reels link navigates to /reel/<id>.
+    // That means we clicked the wrong button — fail fast so the user knows.
+    if (/\/reel\/\d+/.test(afterUrl)) {
+      throw new Error(`FB Thước phim click navigated to Reels feed (${afterUrl}) — wrong button matched, should be composer modal. Check "Tạo bài viết" widget layout on this Page.`);
+    }
+
+    // 3) Dismiss any onboarding/tutorial dialog.
+    await dismissBsOnboarding(page, log);
+
+    // 3) Click "Thêm video" — opens the native OS file picker. Catch the
+    //    filechooser event and inject the video file path. Multiple aria/text
+    //    candidates so we survive minor i18n drift.
+    log('info', '[fb-pw] click "Thêm video" + filechooser…');
+    const addVideoCandidates = [
+      "div[role='button']:has-text('Thêm video')",
+      "div[role='button']:has-text('Add video')",
+      "[aria-label='Thêm video']",
+      "[aria-label='Add video']",
+    ];
+    let videoSet = false;
+    for (const sel of addVideoCandidates) {
+      if (videoSet) break;
+      const btn = await firstVisible(page.locator(sel), 3);
+      if (!btn) continue;
+      try {
+        const [chooser] = await Promise.all([
+          page.waitForEvent('filechooser', { timeout: 8000 }),
+          btn.click({ timeout: 3000 }),
+        ]);
+        await chooser.setFiles(videoPath);
+        videoSet = true;
+        log('info', `[fb-pw] video file set via "${sel}"`);
+      } catch (e) {
+        log('info', `[fb-pw] "Thêm video" via "${sel}" did not open picker: ${e.message.slice(0, 80)}`);
+      }
+    }
+    if (!videoSet) {
+      // Fallback — some BS variants expose the hidden input directly. Try
+      // setInputFiles on input[type='file'] anywhere on the page that accepts video.
+      const fi = page.locator("input[type='file']").last();
+      if (await fi.count().catch(() => 0) > 0) {
+        try {
+          await fi.setInputFiles(videoPath);
+          videoSet = true;
+          log('info', `[fb-pw] video file set via fallback input[type='file']`);
+        } catch (e) { log('info', `[fb-pw] fallback input setInputFiles failed: ${e.message.slice(0, 80)}`); }
+      }
+    }
+    if (!videoSet) {
+      await dumpInventory(page, log, 'no-add-video');
+      await dumpFailure(page, 'no-add-video', log);
+      throw new Error('FB "Thêm video" trigger not found — could not start video upload');
+    }
+
+    // 4) Wait for the video to finish processing on FB's side before we can
+    //    fill the caption + advance. FB shows a progress indicator and only
+    //    enables the "Tiếp" button once upload + thumbnail extraction is done.
+    log('info', '[fb-pw] waiting for video upload to process (up to 60s)…');
+    await page.waitForTimeout(30000); // FB processes 10-60s for short Reels
+
+    // 5) Fill metadata. FB Reels has THREE separate fields (verified visually
+    //    by user — different from how YT lumps everything into title + desc):
+    //      - Tiêu đề thước phim    (title — short, ~80 chars)
+    //      - Mô tả thước phim      (description — long, supports emoji)
+    //      - Thêm thẻ              (tags — comma-separated, NO hashtag prefix)
+    //    We attempt to fill all 3 here on step 1 + again after each Tiếp
+    //    (some FB builds only show them on the final Chia sẻ step). The
+    //    helper is idempotent: it tracks per-field "done" so we don't
+    //    re-fill on subsequent steps.
+    const fillState = { title: false, description: false, tags: false };
+    const fillMetadata = async () => {
+      // Title (Tiêu đề thước phim). Variant-A input is shown by default in the
+      // BS composer — NO reveal click needed. Earlier `revealCandidates` clicks
+      // were accidentally landing on the "+" button (add A/B variant) which
+      // creates an empty variant-B and triggers "Không được để trống tiêu đề
+      // thay thế" validation, blocking Tiếp.
+      if (!fillState.title && title) {
+        // If a previous run accidentally created variant B (empty + warning
+        // triangle icon), delete it via its trash button so FB doesn't block
+        // Tiếp on the empty-variant-B error.
+        const variantBDeleted = await page.evaluate(() => {
+          // Look for a trash/remove icon button BESIDE a 2nd title input.
+          // FB's A/B title rows are siblings; the 2nd row has a trash button
+          // and an empty input with the same "Tiêu đề..." placeholder.
+          const inputs = Array.from(document.querySelectorAll("input"))
+            .filter((el) => {
+              const p = el.getAttribute('placeholder') || '';
+              const ap = el.getAttribute('aria-placeholder') || '';
+              return /tiêu đề.*thước phim|tiêu đề.*thay thế|thước phim.*tiêu đề/i.test(p + ap);
+            });
+          if (inputs.length < 2) return false;
+          // Variant B is the LAST title input. Look for a trash button near it.
+          const last = inputs[inputs.length - 1];
+          let parent = last.parentElement;
+          for (let depth = 0; depth < 5 && parent; depth++) {
+            const trash = parent.querySelector("[aria-label*='Xóa'], [aria-label*='Remove'], [aria-label*='Trash']");
+            if (trash) {
+              trash.click();
+              return true;
+            }
+            parent = parent.parentElement;
+          }
+          return false;
+        }).catch(() => false);
+        if (variantBDeleted) {
+          log('info', '[fb-pw] removed stale empty variant-B title row');
+          await page.waitForTimeout(800);
+        }
+        const titleSels = [
+          // PAGE-WALL form 1 — "Bạn đang nghĩ gì?" caption textbox is the
+          // TITLE field per FB layout (user-confirmed: form 1 = title, form
+          // 2 = description + tags). Match these FIRST.
+          "[role='textbox'][aria-placeholder*='Bạn đang nghĩ gì']",
+          "[role='textbox'][aria-placeholder*='đang nghĩ gì']",
+          "[role='textbox'][aria-placeholder*='Whats on your mind']",
+          "[role='textbox'][aria-placeholder*='thinking']",
+          "[role='textbox'][aria-label*='Bạn đang nghĩ gì']",
+          // BS-composer title (Tiêu đề thước phim) — kept for legacy BS flow.
+          "[role='textbox'][aria-placeholder*='Tiêu đề thước phim']",
+          "[role='textbox'][aria-placeholder*='Tiêu đề']",
+          "[contenteditable='true'][aria-placeholder*='Tiêu đề']",
+          "input[placeholder*='Tiêu đề thước phim']",
+          "input[placeholder*='Tiêu đề']",
+          "textarea[placeholder*='Tiêu đề']",
+          "[aria-label='Tiêu đề thước phim']",
+          "[aria-label*='Tiêu đề thước phim']",
+          "[aria-label*='Tiêu đề']",
+        ];
+        const clippedTitle = String(title).length > 80 ? String(title).slice(0, 79) + '…' : String(title);
+        for (const sel of titleSels) {
+          const f = await firstVisible(page.locator(sel), 3);
+          if (!f) continue;
+          try {
+            await f.click({ timeout: 3000 });
+            const tag = await f.evaluate((el) => el.tagName.toLowerCase()).catch(() => '');
+            if (tag === 'input' || tag === 'textarea') {
+              await f.fill(clippedTitle);
+            } else {
+              await f.type(clippedTitle, { delay: 12 });
+            }
+            // Blur to commit (FB's React validation re-renders on blur).
+            await page.keyboard.press('Tab').catch(() => {});
+            fillState.title = true;
+            log('info', `[fb-pw] title filled (${clippedTitle.length} chars) via "${sel}"`);
+            break;
+          } catch (e) { log('info', `[fb-pw] title via "${sel}" failed: ${e.message.slice(0, 80)}`); }
+        }
+        // Last-resort dynamic probe — JS scan for any input/contenteditable
+        // whose attributes mention "Tiêu đề". Returns a CSS path we can target.
+        if (!fillState.title) {
+          const probe = await page.evaluate(() => {
+            const all = document.querySelectorAll("input, textarea, [contenteditable='true'], [role='textbox']");
+            for (let i = 0; i < all.length; i++) {
+              const el = all[i];
+              const r = el.getBoundingClientRect();
+              if (r.width < 8 || r.height < 8) continue;
+              const attrs = (
+                (el.getAttribute('placeholder') || '') + '|' +
+                (el.getAttribute('aria-placeholder') || '') + '|' +
+                (el.getAttribute('aria-label') || '') + '|' +
+                (el.getAttribute('data-placeholder') || '')
+              ).toLowerCase();
+              if (/tiêu đề|title.*reel|reel.*title/i.test(attrs)) {
+                return {
+                  tag: el.tagName.toLowerCase(),
+                  attrs,
+                  bbox: { x: r.x + r.width / 2, y: r.y + r.height / 2 },
+                };
+              }
+            }
+            return null;
+          }).catch(() => null);
+          if (probe) {
+            log('info', `[fb-pw] title dynamic-probe found <${probe.tag}> attrs="${probe.attrs.slice(0, 80)}"`);
+            try {
+              await page.mouse.click(probe.bbox.x, probe.bbox.y);
+              await page.waitForTimeout(300);
+              // FB Reels title cap is 80 chars (BS composer shows red invalid
+              // state above that and blocks Tiếp). Be conservative — clip with
+              // ellipsis suffix so the AI-generated hook is preserved at front.
+              const clipped = String(title).length > 80
+                ? String(title).slice(0, 79) + '…'
+                : String(title);
+              await page.keyboard.type(clipped, { delay: 12 });
+              // Tab away to blur — commits the value and triggers React's
+              // validation re-render, otherwise the form keeps the invalid
+              // state from a previous typing session.
+              await page.keyboard.press('Tab');
+              fillState.title = true;
+              log('info', `[fb-pw] title filled via dynamic-probe (${clipped.length} chars)`);
+            } catch (e) {
+              log('info', `[fb-pw] title dynamic-probe click failed: ${e.message.slice(0, 80)}`);
+            }
+          }
+        }
+      }
+
+      // Description (Mô tả) — multi-line. Best-known aria: "Hãy viết vào ô
+      // hộp thoại...". On the metadata page it's the same field but with
+      // placeholder "Mô tả thước phim của bạn".
+      // Description selectors — Page-wall form 2 uses "Mô tả thước phim của
+      // bạn..." textbox (verified via screenshot). MUST be specific to avoid
+      // matching form 1's "Bạn đang nghĩ gì?" caption (which is the TITLE
+      // field — would re-write title with description text otherwise).
+      if (!fillState.description) {
+        const descSels = [
+          // Page-wall form 2 description — match by aria-placeholder.
+          "[role='textbox'][aria-placeholder*='Mô tả thước phim']",
+          "[role='textbox'][aria-placeholder*='Mô tả']",
+          "[role='textbox'][aria-placeholder*='Describe your reel']",
+          // BS composer description — legacy.
+          "[role='textbox'][aria-label*='Mô tả']",
+          "[role='textbox'][aria-label*='hộp thoại']",
+          "[role='textbox'][aria-label*='Hãy viết']",
+          "textarea[placeholder*='Mô tả']",
+        ];
+        for (const sel of descSels) {
+          const f = await firstVisible(page.locator(sel), 3);
+          if (!f) continue;
+          try {
+            await f.click({ timeout: 3000 });
+            const descText = (description || title || '').toString().slice(0, 2100);
+            if (!descText) break;
+            await f.type(descText, { delay: 12 });
+            fillState.description = true;
+            log('info', `[fb-pw] description filled (${descText.length} chars) via "${sel}"`);
+            break;
+          } catch (e) { log('info', `[fb-pw] desc via "${sel}" failed: ${e.message.slice(0, 80)}`); }
+        }
+      }
+
+      // Tags (Thêm thẻ) — comma-separated; STRIP leading "#" since FB's tag
+      // input is keyword-style, not hashtag-style. The tag input is at the
+      // BOTTOM of the BS composer form; firstVisible was missing it because
+      // it sat below the fold. Each candidate now scrollIntoView before
+      // attempting click.
+      if (!fillState.tags && tags && tags.length) {
+        const tagSels = [
+          // Page-wall form 2 — "Thêm thẻ" textbox.
+          "[role='textbox'][aria-placeholder='Thêm thẻ']",
+          "[role='textbox'][aria-placeholder*='Thêm thẻ']",
+          "[role='textbox'][aria-label='Thêm thẻ']",
+          "[aria-label='Thêm thẻ']",
+          "[aria-label*='Thêm thẻ']",
+          // BS composer tag input.
+          "[aria-label*='thẻ phân tách']",
+          "input[placeholder*='thẻ phân tách']",
+          "input[placeholder*='thẻ']",
+          "textarea[placeholder*='thẻ phân tách']",
+        ];
+        // First locate the tag input via JS so we can scroll it into view
+        // even when it's outside the current viewport. Two strategies, in
+        // order: (1) attribute match (aria-label/placeholder/aria-placeholder
+        // contains "thẻ" or "tag"); (2) DOM-walk from a label/heading text
+        // "Thẻ" / "Tag" to the nearest input under it (FB sometimes renders
+        // the input with no descriptive attrs and only a sibling label).
+        const tagLoc = await page.evaluate(() => {
+          // Strategy 1: attribute match.
+          const cands = document.querySelectorAll("input, textarea, [contenteditable='true'], [role='textbox']");
+          for (const el of cands) {
+            const a = (el.getAttribute('aria-label') || '').toLowerCase();
+            const p = (el.getAttribute('placeholder') || '').toLowerCase();
+            const ap = (el.getAttribute('aria-placeholder') || '').toLowerCase();
+            const sig = a + '|' + p + '|' + ap;
+            if (/thẻ|tag/i.test(sig)) {
+              const r = el.getBoundingClientRect();
+              if (r.width < 8) continue;
+              el.scrollIntoView({ block: 'center' });
+              el.setAttribute('__fbpw_tag__', '1');
+              return { selector: "[__fbpw_tag__='1']", tag: el.tagName.toLowerCase(), via: 'attr', sig };
+            }
+          }
+          // Strategy 2: find a label/heading whose text is exactly "Thẻ" /
+          // "Tag" / contains those — then locate the nearest input under it.
+          const labels = document.querySelectorAll("label, h2, h3, h4, span, div");
+          for (const lbl of labels) {
+            const t = (lbl.innerText || '').trim();
+            if (!/^thẻ$|^tag$|^thẻ\s|tag\s/i.test(t)) continue;
+            const r = lbl.getBoundingClientRect();
+            if (r.width < 8) continue;
+            // Walk up to find a container, then look for input inside.
+            let container = lbl.parentElement;
+            for (let depth = 0; depth < 4 && container; depth++) {
+              const inp = container.querySelector("input, textarea, [contenteditable='true'], [role='textbox']");
+              if (inp) {
+                const ir = inp.getBoundingClientRect();
+                if (ir.width >= 8) {
+                  inp.scrollIntoView({ block: 'center' });
+                  inp.setAttribute('__fbpw_tag__', '1');
+                  return { selector: "[__fbpw_tag__='1']", tag: inp.tagName.toLowerCase(), via: 'label', label: t };
+                }
+              }
+              container = container.parentElement;
+            }
+          }
+          return null;
+        }).catch(() => null);
+        if (tagLoc) log('info', `[fb-pw] tag input located via ${tagLoc.via}${tagLoc.sig ? ` (sig=${tagLoc.sig.slice(0, 60)})` : ''}${tagLoc.label ? ` (label="${tagLoc.label}")` : ''}`);
+        if (tagLoc) {
+          try {
+            await page.waitForTimeout(400);
+            const f = page.locator(tagLoc.selector);
+            await f.click({ timeout: 5000 });
+            const cleaned = tags.map((t) => String(t).replace(/^#+/, '').trim()).filter(Boolean);
+            const tagsStr = cleaned.join(', ');
+            if (tagLoc.tag === 'input' || tagLoc.tag === 'textarea') {
+              await f.fill(tagsStr);
+            } else {
+              await f.type(tagsStr, { delay: 10 });
+            }
+            fillState.tags = true;
+            log('info', `[fb-pw] tags filled (${cleaned.length}: ${tagsStr.slice(0, 60)}…) via scrollIntoView`);
+            await page.evaluate((sel) => document.querySelectorAll(sel).forEach((el) => el.removeAttribute('__fbpw_tag__')), tagLoc.selector).catch(() => {});
+          } catch (e) {
+            log('info', `[fb-pw] tags fill via scrollIntoView failed: ${e.message.slice(0, 80)}`);
+          }
+        }
+        // Fallback: standard CSS selectors (in case the JS probe missed).
+        if (!fillState.tags) {
+          for (const sel of tagSels) {
+            const f = await firstVisible(page.locator(sel), 3);
+            if (!f) continue;
+            try {
+              await f.scrollIntoViewIfNeeded({ timeout: 2000 }).catch(() => {});
+              const cleaned = tags.map((t) => String(t).replace(/^#+/, '').trim()).filter(Boolean);
+              const tagsStr = cleaned.join(', ');
+              await f.click({ timeout: 3000 });
+              const tag = await f.evaluate((el) => el.tagName.toLowerCase()).catch(() => '');
+              if (tag === 'input' || tag === 'textarea') {
+                await f.fill(tagsStr);
+              } else {
+                await f.type(tagsStr, { delay: 10 });
+              }
+              fillState.tags = true;
+              log('info', `[fb-pw] tags filled (${cleaned.length}: ${tagsStr.slice(0, 60)}…) via "${sel}"`);
+              break;
+            } catch (e) { log('info', `[fb-pw] tags via "${sel}" failed: ${e.message.slice(0, 80)}`); }
+          }
+        }
+      }
+    };
+
+    log('info', '[fb-pw] fill metadata (title/description/tags) — step 1…');
+    await fillMetadata();
+    await page.waitForTimeout(800);
+
+    // 6) Multi-step "Tiếp" → "Tiếp" → "Đăng" loop. FB Reels composer is 3
+    //    pages: caption (now) → thumbnail (auto-selected, just advance) →
+    //    visibility/publish (final). Each step has a "Tiếp" button until the
+    //    last, which has "Đăng" / "Chia sẻ ngay" instead. Loop with a max
+    //    bound of 5 to handle future composer changes without infinite-clicking.
+    // Publish verbs ordered by specificity. Critical: "Chia sẻ" (bare) is
+    // the ACTUAL primary action button at the bottom-right of step 3 (blue).
+    // "Chia sẻ ngay" is just a publish-mode RADIO option (defaults selected).
+    // The wizard header also has "Chia sẻ" text — but our findByVerbs prefers
+    // LAST occurrence in DOM order, which is the bottom action button.
+    // "Chia sẻ" REMOVED from publish verbs: in the Page-wall Reel modal,
+    // there's a "Chia sẻ" button whose aria-label is "Gửi nội dung này cho
+    // bạn bè hoặc đăng lên trang cá nhân của bạn." — that's the share-to-
+    // friends action, NOT publish. The real Page-wall publish CTA is "Đăng".
+    // In BS composer "Chia sẻ" was the publish CTA, but the dialog-scoped
+    // findByVerbs in Page wall avoids the BS-only confusion.
+    const publishVerbs = ['Đăng', 'Đăng bài', 'Đăng ngay', 'Đăng video', 'Đăng thước phim', 'Post now', 'Share now', 'Publish', 'Post'];
+    const nextVerbs = ['Tiếp', 'Tiếp theo', 'Next', 'Continue'];
+
+    // Exact-text match via page.evaluate, returning a CSS selector path so
+    // Playwright's locator-based click handles scrollIntoView + auto-wait.
+    // `requireBottomHalf` filters out wizard step-indicator buttons at the
+    // top (e.g., "Chia sẻ" step header at y < 200 which navigates the wizard
+    // instead of publishing). Used by publish verb search.
+    const findByVerbs = async (verbs, opts = {}) => {
+      const requireBottomHalf = !!opts.requireBottomHalf;
+      for (const v of verbs) {
+        const found = await page.evaluate(({ verb, bottomHalf }) => {
+          // Page-wall flow renders the composer inside [role='dialog']. Prefer
+          // matches INSIDE a dialog — otherwise we hit background-page buttons
+          // (e.g. the home page's share-to-friends "Chia sẻ" button at the
+          // bottom of a feed item, aria-label "Gửi nội dung này cho bạn bè
+          // hoặc đăng lên trang cá nhân của bạn." — which is NOT the publish
+          // CTA). For BS composer (no dialog), this falls through to body.
+          const vh = window.innerHeight;
+          const tryScope = (rootSelectorOrNull) => {
+            const roots = rootSelectorOrNull
+              ? Array.from(document.querySelectorAll(rootSelectorOrNull))
+              : [document];
+            for (const root of roots) {
+              const els = root.querySelectorAll("button, [role='button']");
+              let bestEl = null;
+              for (const el of els) {
+                const t = (el.innerText || el.textContent || '').trim();
+                if (t !== verb) continue;
+                const r = el.getBoundingClientRect();
+                if (r.width < 8 || r.height < 8) continue;
+                const cs = getComputedStyle(el);
+                if (cs.visibility === 'hidden' || cs.display === 'none' || cs.opacity === '0') continue;
+                if (el.getAttribute('aria-disabled') === 'true' || el.disabled) continue;
+                if (bottomHalf && r.y < vh * 0.4) continue;
+                bestEl = el;
+              }
+              if (bestEl) return bestEl;
+            }
+            return null;
+          };
+          // Pass 1: inside any [role='dialog'] (modal composer).
+          let bestEl = tryScope("[role='dialog']");
+          // Pass 2: fall back to whole document (BS composer non-modal flow).
+          if (!bestEl) bestEl = tryScope(null);
+          if (!bestEl) return null;
+          // Tag the element so Playwright can find it back. data-attribute is
+          // safe + ignored by FB's React reconciliation.
+          const marker = '__fbpw_target__';
+          bestEl.setAttribute(marker, '1');
+          return { selector: `[${marker}='1']`, tag: bestEl.tagName.toLowerCase() };
+        }, { verb: v, bottomHalf: requireBottomHalf });
+        if (found) {
+          const loc = page.locator(found.selector);
+          return {
+            hit: {
+              click: async (opts) => {
+                // scrollIntoViewIfNeeded handles off-screen primary actions
+                // (e.g. Chia sẻ ngay at y=-274 after a step jump). Then
+                // Playwright's click auto-waits visible+stable.
+                try { await loc.scrollIntoViewIfNeeded({ timeout: 3000 }); } catch {}
+                await loc.click({ timeout: opts?.timeout || 5000 });
+                // Remove the marker so subsequent findByVerbs gets a fresh
+                // element instead of clinging to the now-stale node.
+                await page.evaluate((sel) => {
+                  document.querySelectorAll(sel).forEach((el) => el.removeAttribute(sel.replace(/[\[\]'=1]/g, '')));
+                }, found.selector).catch(() => {});
+              },
+              isVisible: async () => loc.isVisible().catch(() => false),
+              isEnabled: async () => loc.isEnabled().catch(() => true),
+              getAttribute: (a) => loc.getAttribute(a).catch(() => null),
+              page: () => page,
+            },
+            sel: `exact-text:'${v}' (<${found.tag}>)`,
+            verb: v,
+          };
+        }
+      }
+      return null;
+    };
+
+    // Simplified step loop — no stuck-detect (false-positive prone because
+    // BS composer's wizard header buttons are the same across all 3 steps).
+    // Each iteration: fillMetadata + pick thumbnail if on thumb step +
+    // (publish if available, else Tiếp). If we never find publish in 6
+    // iterations, throw with diagnostics.
+    let published = false;
+    let customThumbDone = false;
+    for (let step = 0; step < 6 && !published; step++) {
+      await page.waitForTimeout(3000);
+      await fillMetadata();
+
+      // PAGE-WALL thumb flow (form 2 has a "Chỉnh sửa" overlay button on the
+      // video preview → opens "Chỉnh sửa hình thu nhỏ" modal → "Tải lên" →
+      // file picker → "Lưu"). Per user screenshots, this is the only way to
+      // attach a custom thumbnail in the Page-wall composer.
+      if (!customThumbDone && thumbPath && /^https?:\/\/(www\.)?facebook\.com\/?($|\?|#)/.test(page.url())) {
+        const editBtn = await page.evaluate(() => {
+          // Look for the thumbnail-edit button inside ANY visible composer
+          // dialog. The overlay is a small button on the video preview with:
+          //   - aria-label containing "hình thu nhỏ" / "thumbnail"
+          //   - OR text "Chỉnh sửa" with size < ~120px wide (overlay vs full
+          //     "Chỉnh sửa ảnh bìa" page cover button which is much wider)
+          const dlgs = document.querySelectorAll("[role='dialog']");
+          for (const dlg of dlgs) {
+            const r = dlg.getBoundingClientRect();
+            if (r.width < 8 || r.height < 8) continue;
+            const cs = getComputedStyle(dlg);
+            if (cs.visibility === 'hidden' || cs.display === 'none') continue;
+            const cands = dlg.querySelectorAll("[role='button'], button, [aria-label]");
+            for (const el of cands) {
+              const t = (el.innerText || '').trim();
+              const al = (el.getAttribute('aria-label') || '').trim();
+              const ar = el.getBoundingClientRect();
+              if (ar.width < 8 || ar.height < 8) continue;
+              // Specific aria match for the thumb-edit overlay.
+              if (/hình thu nhỏ|thumbnail|edit thumb/i.test(al)) {
+                el.setAttribute('__fbpw_thumb_edit__', '1');
+                return { selector: "[__fbpw_thumb_edit__='1']", aria: al.slice(0, 60), text: t.slice(0, 40), via: 'aria-thumb' };
+              }
+              // Bare "Chỉnh sửa" text — but ONLY if narrow (overlay pill)
+              // AND not a page-cover edit button (which is wide).
+              if ((t === 'Chỉnh sửa' || t === 'Edit') && ar.width < 140 && ar.height < 60) {
+                // Avoid matching page-cover "Chỉnh sửa ảnh bìa" / sidebar.
+                if (/ảnh bìa|cover|trang cá nhân|profile|lối tắt|shortcut/i.test(al)) continue;
+                el.setAttribute('__fbpw_thumb_edit__', '1');
+                return { selector: "[__fbpw_thumb_edit__='1']", aria: al.slice(0, 60), text: t.slice(0, 40), via: 'narrow-pill', size: `${Math.round(ar.width)}x${Math.round(ar.height)}` };
+              }
+            }
+          }
+          return null;
+        }).catch(() => null);
+
+        if (editBtn) {
+          log('info', `[fb-pw] page-wall thumb — opening "Chỉnh sửa hình thu nhỏ" modal (via=${editBtn.via}, aria="${editBtn.aria}", text="${editBtn.text}"${editBtn.size ? `, size=${editBtn.size}` : ''})…`);
+          try {
+            await page.locator(editBtn.selector).click({ timeout: 5000 });
+            await page.waitForTimeout(2500);
+
+            // Wait for the thumb-edit modal to mount. Header text =
+            // "Chỉnh sửa hình thu nhỏ".
+            await page.evaluate(() => document.querySelectorAll("[__fbpw_thumb_edit__]").forEach((el) => el.removeAttribute('__fbpw_thumb_edit__'))).catch(() => {});
+
+            // Click "Tải lên" button — opens OS file picker. Use filechooser
+            // race to inject the file path directly.
+            const uploadCandidates = [
+              "[role='dialog'] div[role='button']:has-text('Tải lên')",
+              "[role='dialog'] button:has-text('Tải lên')",
+              "[role='dialog'] [aria-label='Tải lên']",
+              "[role='dialog'] [aria-label*='Tải hình thu nhỏ']",
+              "[role='dialog'] div[role='button']:has-text('Upload')",
+            ];
+            let uploaded = false;
+            for (const sel of uploadCandidates) {
+              const btn = await firstVisible(page.locator(sel), 5);
+              if (!btn) continue;
+              try {
+                const [chooser] = await Promise.all([
+                  page.waitForEvent('filechooser', { timeout: 8000 }),
+                  btn.click({ timeout: 3000 }),
+                ]);
+                await chooser.setFiles(thumbPath);
+                log('info', `[fb-pw] page-wall thumb — file set via "${sel}"`);
+                uploaded = true;
+                await page.waitForTimeout(3500); // FB processes image
+                break;
+              } catch (e) {
+                log('info', `[fb-pw] "Tải lên" via "${sel}" failed: ${e.message.slice(0, 80)}`);
+              }
+            }
+
+            // Fallback — direct setInputFiles on a hidden image-accepting
+            // file input inside the modal.
+            if (!uploaded) {
+              const directInput = page.locator("[role='dialog'] input[type='file'][accept*='image']").last();
+              if (await directInput.count().catch(() => 0) > 0) {
+                try {
+                  await directInput.setInputFiles(thumbPath);
+                  log('info', '[fb-pw] page-wall thumb — file set via direct input[type=file]');
+                  uploaded = true;
+                  await page.waitForTimeout(3500);
+                } catch (e) {
+                  log('warn', `[fb-pw] direct file input failed: ${e.message.slice(0, 80)}`);
+                }
+              }
+            }
+
+            if (uploaded) {
+              // Click "Lưu" to save the new thumbnail.
+              const saveCandidates = [
+                "[role='dialog'] div[role='button']:has-text('Lưu')",
+                "[role='dialog'] button:has-text('Lưu')",
+                "[role='dialog'] [aria-label='Lưu']",
+                "[role='dialog'] div[role='button']:has-text('Save')",
+              ];
+              let saved = false;
+              for (const sel of saveCandidates) {
+                const btn = await firstVisible(page.locator(sel), 3);
+                if (!btn) continue;
+                try {
+                  await btn.click({ timeout: 3000 });
+                  log('info', `[fb-pw] page-wall thumb — saved via "${sel}"`);
+                  saved = true;
+                  break;
+                } catch (e) {
+                  log('info', `[fb-pw] "Lưu" via "${sel}" failed: ${e.message.slice(0, 80)}`);
+                }
+              }
+              if (saved) {
+                // Poll up to 60s for the "Chỉnh sửa hình thu nhỏ" modal to
+                // CLOSE. FB processes the uploaded image on the server side
+                // before dismissing the modal — for large images or slow
+                // worker connections, this can take 20-40s. If the modal
+                // doesn't close within 12s of polling, RE-CLICK Lưu (in case
+                // the first click didn't register because the button was
+                // disabled while FB was still hashing the upload).
+                const closeDeadline = Date.now() + 60_000;
+                let modalClosed = false;
+                let retryCount = 0;
+                const RETRY_AFTER_MS = 12_000;
+                let lastRetryAt = Date.now();
+                while (Date.now() < closeDeadline) {
+                  const still = await page.evaluate(() => {
+                    const dlgs = document.querySelectorAll("[role='dialog']");
+                    for (const dlg of dlgs) {
+                      const txt = (dlg.innerText || '').slice(0, 200);
+                      if (/Chỉnh sửa hình thu nhỏ|Edit thumbnail/i.test(txt)) {
+                        const r = dlg.getBoundingClientRect();
+                        if (r.width > 8 && r.height > 8) return true;
+                      }
+                    }
+                    return false;
+                  }).catch(() => false);
+                  if (!still) { modalClosed = true; break; }
+                  // Retry Lưu click after RETRY_AFTER_MS without progress —
+                  // limit to 3 retries (so we still leave time for FB to
+                  // finish processing on the last attempt).
+                  if (retryCount < 3 && Date.now() - lastRetryAt >= RETRY_AFTER_MS) {
+                    retryCount++;
+                    lastRetryAt = Date.now();
+                    log('info', `[fb-pw] thumb modal still open after ${retryCount * (RETRY_AFTER_MS / 1000)}s — re-clicking Lưu (retry ${retryCount}/3)`);
+                    for (const sel of saveCandidates) {
+                      const btn = await firstVisible(page.locator(sel), 2);
+                      if (!btn) continue;
+                      try {
+                        await btn.click({ timeout: 2500 });
+                        break;
+                      } catch {}
+                    }
+                  }
+                  await page.waitForTimeout(1000);
+                }
+                if (modalClosed) {
+                  log('info', `[fb-pw] page-wall thumb — modal closed after save (retries=${retryCount})`);
+                } else {
+                  log('warn', '[fb-pw] page-wall thumb — modal still open 60s after Lưu click; trying ESC + click Hủy fallback');
+                  await page.keyboard.press('Escape').catch(() => {});
+                  await page.waitForTimeout(800);
+                  const cancel = await firstVisible(page.locator("[role='dialog'] div[role='button']:has-text('Hủy'), [role='dialog'] button:has-text('Hủy')"), 2);
+                  if (cancel) await cancel.click({ timeout: 2000 }).catch(() => {});
+                  await page.waitForTimeout(1500);
+                }
+              } else {
+                log('warn', '[fb-pw] page-wall thumb upload OK but "Lưu" click failed — modal may stay open');
+              }
+            } else {
+              log('warn', '[fb-pw] page-wall thumb upload failed — closing modal via Hủy to continue');
+              const cancel = await firstVisible(page.locator("[role='dialog'] div[role='button']:has-text('Hủy'), [role='dialog'] button:has-text('Hủy')"), 2);
+              if (cancel) await cancel.click({ timeout: 2000 }).catch(() => {});
+              await page.waitForTimeout(1500);
+            }
+          } catch (e) {
+            log('warn', `[fb-pw] page-wall thumb flow failed: ${e.message.slice(0, 100)}`);
+          }
+          customThumbDone = true;
+        }
+      }
+
+      // Thumbnail step handling (BS composer legacy).
+      const onThumbStep = await firstVisible(page.locator(
+        "[aria-label='Hình thu nhỏ tạo tự động 1'], [aria-label*='Auto-generated thumbnail'], div[role='button']:has-text('Tải hình ảnh lên'), div[role='button']:has-text('Upload image')"
+      ), 3);
+      if (onThumbStep && !customThumbDone) {
+        if (thumbPath) {
+          log('info', '[fb-pw] thumbnail step — uploading custom thumb…');
+          let uploaded = false;
+
+          // Probe: dump ALL file inputs (incl. hidden) for diagnostic + find
+          // the image-accepting one. FB usually mounts a hidden
+          // <input type="file" accept="image/*"> tied to the upload button.
+          const fileInputDiag = await page.evaluate(() => {
+            const all = document.querySelectorAll("input[type='file']");
+            return Array.from(all).slice(0, 6).map((el, i) => ({
+              i,
+              accept: (el.accept || '').slice(0, 60),
+              name: el.name || '',
+              id: el.id || '',
+              hidden: el.offsetParent === null,
+              parent: el.parentElement?.tagName?.toLowerCase() || '',
+            }));
+          }).catch(() => []);
+          log('info', `[fb-pw] thumb-step file inputs found: ${fileInputDiag.length}`);
+          fileInputDiag.forEach((fi) => log('info', `  thumb-file-input[${fi.i}] accept=${fi.accept} hidden=${fi.hidden} parent=${fi.parent}`));
+
+          // Path A — setInputFiles on a hidden image-accepting file input.
+          // Some FB builds expose the input directly; setting files bypasses
+          // the click-to-OS-picker flow that's flaky in CDP-attached Chrome.
+          const directImgInputs = page.locator("input[type='file'][accept*='image']");
+          const dCount = Math.min(await directImgInputs.count().catch(() => 0), 3);
+          for (let i = 0; i < dCount && !uploaded; i++) {
+            try {
+              await directImgInputs.nth(i).setInputFiles(thumbPath);
+              uploaded = true;
+              log('info', `[fb-pw] custom thumbnail set via direct image input[${i}]`);
+              await page.waitForTimeout(3000);
+            } catch (e) { log('info', `[fb-pw] direct img input[${i}] failed: ${e.message.slice(0, 80)}`); }
+          }
+
+          // Path B — scope dispatchFile to ANY file input even if its accept
+          // attribute doesn't strictly match `image`. Some FB cohorts use
+          // `accept="image/*,image/heif"` and our `*=image` matches; others
+          // use `accept=""` and need a looser selector.
+          if (!uploaded) {
+            const anyFile = page.locator("input[type='file']");
+            const aCount = Math.min(await anyFile.count().catch(() => 0), 5);
+            for (let i = 0; i < aCount && !uploaded; i++) {
+              try {
+                await anyFile.nth(i).setInputFiles(thumbPath);
+                uploaded = true;
+                log('info', `[fb-pw] custom thumbnail set via any-file input[${i}]`);
+                await page.waitForTimeout(3000);
+              } catch (e) { log('info', `[fb-pw] any-file input[${i}] failed: ${e.message.slice(0, 80)}`); }
+            }
+          }
+
+          // Path C — TWO-step flow (verified manually by user):
+          //   1. Click "Tải hình ảnh lên" tab to switch to the upload pane.
+          //   2. INSIDE the pane, click the <a> element containing "Upload"
+          //      text — THIS is what actually fires the OS file chooser.
+          // The original 1-step click on the tab itself only switches panes,
+          // it does NOT trigger the picker.
+          if (!uploaded) {
+            const tabCandidates = [
+              "div[role='button']:has-text('Tải hình ảnh lên')",
+              "div[role='button']:has-text('Upload image')",
+              "[aria-label='Tải hình ảnh lên']",
+              "[aria-label='Upload image']",
+            ];
+            // Step 1: switch tab.
+            let tabClicked = false;
+            for (const sel of tabCandidates) {
+              const btn = await firstVisible(page.locator(sel), 3);
+              if (!btn) continue;
+              try {
+                await btn.scrollIntoViewIfNeeded({ timeout: 2000 }).catch(() => {});
+                await btn.click({ timeout: 3000 });
+                tabClicked = true;
+                log('info', `[fb-pw] upload-tab switched via "${sel}"`);
+                break;
+              } catch (e) {
+                log('info', `[fb-pw] tab switch via "${sel}" failed: ${e.message.slice(0, 80)}`);
+              }
+            }
+            if (tabClicked) {
+              await page.waitForTimeout(2500); // let pane render fully
+              // Step 2: click the actual <a> trigger inside the Upload pane.
+              // Per user's xpath `.//a[contains(text(), "Upload")]`. VN UI
+              // shows "Tải hình ảnh lên". Try multiple variants + force-click
+              // + mouse fallback (the locator click sometimes times out due
+              // to FB's overlay heuristics, even though the element is alive).
+              const aCandidates = [
+                "a:has-text('Upload image')",
+                "a:has-text('Tải hình ảnh lên')",
+                "a:has-text('Tải hình')",
+                "a:has-text('Upload')",
+                "a:has-text('Tải lên')",
+                "a:has-text('Chọn ảnh')",
+              ];
+              for (const sel of aCandidates) {
+                if (uploaded) break;
+                const link = page.locator(sel).first();
+                if (await link.count().catch(() => 0) === 0) continue;
+                if (!(await link.isVisible().catch(() => false))) continue;
+
+                // Attempt 1 — normal click + filechooser race.
+                try {
+                  await link.scrollIntoViewIfNeeded({ timeout: 2000 }).catch(() => {});
+                  const [chooser] = await Promise.all([
+                    page.waitForEvent('filechooser', { timeout: 8000 }),
+                    link.click({ timeout: 3000 }),
+                  ]);
+                  await chooser.setFiles(thumbPath);
+                  uploaded = true;
+                  log('info', `[fb-pw] custom thumbnail set via <a> "${sel}"`);
+                  // FB needs ~10s after thumbnail upload to process the image
+                  // and re-enable the Tiếp button. Without this wait, Tiếp
+                  // stays aria-disabled and our findByVerbs skips it.
+                  await page.waitForTimeout(10000);
+                  break;
+                } catch (e1) {
+                  log('info', `[fb-pw] <a> click via "${sel}" failed (normal): ${e1.message.slice(0, 80)}`);
+                }
+
+                // Attempt 2 — force click (bypass actionability checks).
+                try {
+                  const [chooser] = await Promise.all([
+                    page.waitForEvent('filechooser', { timeout: 8000 }),
+                    link.click({ timeout: 3000, force: true }),
+                  ]);
+                  await chooser.setFiles(thumbPath);
+                  uploaded = true;
+                  log('info', `[fb-pw] custom thumbnail set via <a> "${sel}" (force)`);
+                  await page.waitForTimeout(3000);
+                  break;
+                } catch (e2) {
+                  log('info', `[fb-pw] <a> click via "${sel}" failed (force): ${e2.message.slice(0, 80)}`);
+                }
+
+                // Attempt 3 — CDP mouse click at element bbox center.
+                const bbox = await link.boundingBox().catch(() => null);
+                if (bbox) {
+                  try {
+                    const [chooser] = await Promise.all([
+                      page.waitForEvent('filechooser', { timeout: 8000 }),
+                      page.mouse.click(bbox.x + bbox.width / 2, bbox.y + bbox.height / 2),
+                    ]);
+                    await chooser.setFiles(thumbPath);
+                    uploaded = true;
+                    log('info', `[fb-pw] custom thumbnail set via <a> "${sel}" (mouse @ bbox)`);
+                    await page.waitForTimeout(3000);
+                    break;
+                  } catch (e3) {
+                    log('info', `[fb-pw] <a> mouse click via "${sel}" failed: ${e3.message.slice(0, 80)}`);
+                  }
+                }
+              }
+            }
+          }
+
+          // Path D — JS-native click on "Tải hình ảnh lên" via evaluate, then
+          // poll for a lazy-injected file input. Playwright's click sometimes
+          // gets swallowed by FB's React layer; el.click() in page context
+          // dispatches a synthetic but page-trusted event that triggers the
+          // file picker.
+          if (!uploaded) {
+            const jsClicked = await page.evaluate(() => {
+              const els = document.querySelectorAll("[role='button'], button, label");
+              for (const el of els) {
+                const t = (el.innerText || '').trim();
+                if (/^Tải hình ảnh lên$|^Upload image$/i.test(t)) {
+                  const r = el.getBoundingClientRect();
+                  if (r.width < 8 || r.height < 8) continue;
+                  el.click();
+                  return true;
+                }
+              }
+              return null;
+            }).catch(() => null);
+            if (jsClicked) {
+              log('info', '[fb-pw] JS-click on Tải hình ảnh lên fired — polling for file input…');
+              // Wait + poll for input[type=file] to materialize
+              for (let i = 0; i < 12 && !uploaded; i++) {
+                await page.waitForTimeout(500);
+                const lazy = page.locator("input[type='file']").last();
+                if (await lazy.count().catch(() => 0) > 0) {
+                  try {
+                    await lazy.setInputFiles(thumbPath);
+                    uploaded = true;
+                    log('info', `[fb-pw] custom thumbnail set via JS-click + lazy input (poll #${i + 1})`);
+                    await page.waitForTimeout(3000);
+                    break;
+                  } catch (e) { /* keep polling */ }
+                }
+              }
+              if (!uploaded) log('info', '[fb-pw] JS-click did not produce a usable file input within 6s');
+            }
+          }
+
+          // Path E — last attempt: dispatch a "trusted click" via CDP's
+          // Input.dispatchMouseEvent at the button's center. CDP-dispatched
+          // mouse events ARE trusted in real Chromium (unlike DOM .click()).
+          if (!uploaded) {
+            const bbox = await page.evaluate(() => {
+              const els = document.querySelectorAll("[role='button'], button, label");
+              for (const el of els) {
+                const t = (el.innerText || '').trim();
+                if (/^Tải hình ảnh lên$|^Upload image$/i.test(t)) {
+                  const r = el.getBoundingClientRect();
+                  if (r.width < 8 || r.height < 8) continue;
+                  el.scrollIntoView({ block: 'center' });
+                  return { x: r.x + r.width / 2, y: r.y + r.height / 2 };
+                }
+              }
+              return null;
+            }).catch(() => null);
+            if (bbox) {
+              try {
+                const [chooser] = await Promise.all([
+                  page.waitForEvent('filechooser', { timeout: 5000 }),
+                  page.mouse.click(bbox.x, bbox.y),
+                ]);
+                await chooser.setFiles(thumbPath);
+                uploaded = true;
+                log('info', `[fb-pw] custom thumbnail set via CDP-mouse @ (${Math.round(bbox.x)},${Math.round(bbox.y)})`);
+                await page.waitForTimeout(3000);
+              } catch (e) {
+                log('info', `[fb-pw] CDP-mouse + filechooser failed: ${e.message.slice(0, 80)}`);
+              }
+            }
+          }
+
+          // Path C — fall back to auto-thumb #1. Thumbnail upload isn't a
+          // hard requirement for FB Reels publish; pick auto-thumb so the
+          // post still goes out, log a warning so the failure is visible.
+          if (!uploaded) {
+            log('warn', '[fb-pw] custom thumb upload failed — falling back to auto-thumb #1');
+            const auto1 = await firstVisible(page.locator("[aria-label='Hình thu nhỏ tạo tự động 1'], [aria-label*='Auto-generated thumbnail 1']"), 3);
+            if (auto1) await auto1.click({ timeout: 3000 }).catch(() => {});
+            await page.waitForTimeout(1500);
+          }
+          customThumbDone = true;
+        } else {
+          log('info', '[fb-pw] thumbnail step — picking auto-thumb #1 (no custom thumb)');
+          const auto1 = await firstVisible(page.locator("[aria-label='Hình thu nhỏ tạo tự động 1'], [aria-label*='Auto-generated thumbnail 1']"), 3);
+          if (auto1) {
+            await auto1.click({ timeout: 3000 }).catch(() => {});
+            await page.waitForTimeout(1500);
+          }
+          customThumbDone = true;
+        }
+      }
+
+      // BEFORE looking for the publish button, dismiss any FB cross-sell
+      // pop-ups (WhatsApp button, story share, promote post) that appear as
+      // overlay dialogs and BLOCK clicks on the underlying publish CTA. On
+      // brain-made-simple page wall, "Thêm nút WhatsApp / Lúc khác" pops up
+      // and covers the Đăng button at y=812 — Playwright's auto-retry click
+      // still "succeeds" but FB's handler doesn't fire because the overlay
+      // intercepts pointer events.
+      const dismissVerbsPre = ['Lúc khác', 'Không phải bây giờ', 'Để sau', 'Bỏ qua', 'Không, cảm ơn', 'Later', 'Not now', 'Skip', 'No thanks'];
+      for (let dr = 0; dr < 4; dr++) {
+        const dh = await page.evaluate((verbs) => {
+          const dlgs = document.querySelectorAll("[role='dialog']");
+          for (const dlg of dlgs) {
+            const r = dlg.getBoundingClientRect();
+            if (r.width < 8 || r.height < 8) continue;
+            const cs = getComputedStyle(dlg);
+            if (cs.visibility === 'hidden' || cs.display === 'none') continue;
+            const dlgAria = (dlg.getAttribute('aria-label') || '').toLowerCase();
+            // Don't touch the composer dialog itself.
+            if (/tạo bài viết|create post|cài đặt thước phim|reel settings/i.test(dlgAria)) continue;
+            const btns = dlg.querySelectorAll("button, [role='button']");
+            for (const v of verbs) {
+              for (const b of btns) {
+                const t = (b.innerText || '').trim();
+                const a = (b.getAttribute('aria-label') || '').trim();
+                if (t === v || a === v) {
+                  b.setAttribute('__fbpw_predismiss__', '1');
+                  return { selector: "[__fbpw_predismiss__='1']", verb: v };
+                }
+              }
+            }
+          }
+          return null;
+        }, dismissVerbsPre).catch(() => null);
+        if (!dh) break;
+        log('info', `[fb-pw] pre-publish dismissing overlay via "${dh.verb}"`);
+        try {
+          await page.locator(dh.selector).click({ timeout: 3000 });
+          await page.waitForTimeout(1500);
+          await page.evaluate(() => document.querySelectorAll("[__fbpw_predismiss__]").forEach((el) => el.removeAttribute('__fbpw_predismiss__'))).catch(() => {});
+        } catch (e) {
+          log('warn', `[fb-pw] pre-dismiss click failed: ${e.message.slice(0, 80)}`);
+          break;
+        }
+      }
+
+      // Prefer a publish button over a Tiếp. If we see Đăng/Chia sẻ ngay,
+      // click it and break. requireBottomHalf=true filters out wizard step
+      // indicators at the top (e.g., "Chia sẻ" header that navigates instead
+      // of publishing).
+      const pub = await findByVerbs(publishVerbs, { requireBottomHalf: true });
+      if (pub) {
+        log('info', `[fb-pw] click publish "${pub.verb}" via "${pub.sel}" (step ${step + 1})`);
+        // Snapshot the captured-IDs list RIGHT BEFORE the publish click. The
+        // network listener captures from EVERY graph response, including the
+        // pre-publish page wall feed (~100+ IDs). Only IDs captured AFTER
+        // this snapshot are candidates for the new reel — and the FIRST
+        // new one is the publish mutation response.
+        capturedReelIdsSnapshotLen = capturedReelIds.length;
+        try {
+          await waitAndClick(pub.hit, { timeoutMs: 120_000, log, label: `Publish(${pub.verb})` });
+
+          // FB shows a confirmation dialog ("Chia sẻ ai biết tin trên Facebook"
+          // / "Are you sure you want to share?") after the primary publish
+          // click. Without confirming, the post stays as a draft and the page
+          // doesn't actually publish. Poll for the dialog up to 8s (FB's
+          // dialog mount is slow — a single 2.5s wait often missed it).
+          const confirmVerbs = ['Xác nhận', 'Xác minh', 'Đồng ý', 'Confirm', 'Continue', 'OK', 'Đăng'];
+          let confirmHit = null;
+          const cfmDeadline = Date.now() + 8000;
+          while (Date.now() < cfmDeadline && !confirmHit) {
+            confirmHit = await page.evaluate((verbs) => {
+              const dlgs = document.querySelectorAll("[role='dialog']");
+              for (const dlg of dlgs) {
+                const r = dlg.getBoundingClientRect();
+                if (r.width < 8 || r.height < 8) continue;
+                const cs = getComputedStyle(dlg);
+                if (cs.visibility === 'hidden' || cs.display === 'none') continue;
+                const btns = dlg.querySelectorAll("button, [role='button']");
+                for (const v of verbs) {
+                  for (const b of btns) {
+                    const t = (b.innerText || '').trim();
+                    if (t === v) {
+                      b.setAttribute('__fbpw_confirm__', '1');
+                      return { selector: "[__fbpw_confirm__='1']", verb: v };
+                    }
+                  }
+                }
+              }
+              return null;
+            }, confirmVerbs).catch(() => null);
+            if (!confirmHit) await page.waitForTimeout(600);
+          }
+          if (confirmHit) {
+            log('info', `[fb-pw] confirming publish via dialog button "${confirmHit.verb}"`);
+            const cLoc = page.locator(confirmHit.selector);
+            try { await cLoc.scrollIntoViewIfNeeded({ timeout: 2000 }); } catch {}
+            await cLoc.click({ timeout: 5000 }).catch((e) => log('warn', `[fb-pw] confirm click failed: ${e.message.slice(0, 80)}`));
+            await page.waitForTimeout(3000);
+          } else {
+            log('info', '[fb-pw] no confirmation dialog detected after 8s — assuming direct publish');
+          }
+
+          // Dismiss post-publish prompts that block the actual commit. After
+          // clicking Đăng, FB sometimes pops a SECONDARY dialog asking to
+          // "Add WhatsApp button" / "Add to story" / "Promote post" with a
+          // "Lúc khác" (Later) / "Không" / "Skip" CTA. If we don't dismiss
+          // these, the post sits in a half-committed state and never actually
+          // appears on the wall. Run a short loop trying to find + click
+          // these dismiss CTAs in any visible dialog.
+          const dismissVerbs = ['Lúc khác', 'Không phải bây giờ', 'Để sau', 'Bỏ qua', 'Không, cảm ơn', 'Later', 'Not now', 'Skip', 'No thanks', 'Dismiss', 'Close'];
+          for (let dismissRound = 0; dismissRound < 4; dismissRound++) {
+            const dismissHit = await page.evaluate((verbs) => {
+              const dlgs = document.querySelectorAll("[role='dialog']");
+              for (const dlg of dlgs) {
+                const r = dlg.getBoundingClientRect();
+                if (r.width < 8 || r.height < 8) continue;
+                const cs = getComputedStyle(dlg);
+                if (cs.visibility === 'hidden' || cs.display === 'none') continue;
+                // Skip the main composer dialog (aria-label "Tạo bài viết"
+                // contains the publish button — don't accidentally close it).
+                const dlgAria = (dlg.getAttribute('aria-label') || '').toLowerCase();
+                if (/tạo bài viết|create post|cài đặt thước phim|reel settings/i.test(dlgAria)) continue;
+                const btns = dlg.querySelectorAll("button, [role='button']");
+                for (const v of verbs) {
+                  for (const b of btns) {
+                    const t = (b.innerText || '').trim();
+                    const a = (b.getAttribute('aria-label') || '').trim();
+                    if (t === v || a === v) {
+                      b.setAttribute('__fbpw_dismiss__', '1');
+                      return { selector: "[__fbpw_dismiss__='1']", verb: v };
+                    }
+                  }
+                }
+              }
+              return null;
+            }, dismissVerbs).catch(() => null);
+            if (!dismissHit) break;
+            log('info', `[fb-pw] dismissing post-publish prompt via "${dismissHit.verb}"`);
+            try {
+              await page.locator(dismissHit.selector).click({ timeout: 3000 });
+              await page.waitForTimeout(2000);
+              await page.evaluate(() => document.querySelectorAll("[__fbpw_dismiss__]").forEach((el) => el.removeAttribute('__fbpw_dismiss__'))).catch(() => {});
+            } catch (e) {
+              log('warn', `[fb-pw] dismiss click failed: ${e.message.slice(0, 80)}`);
+              break;
+            }
+          }
+
+          published = true;
+          break;
+        } catch (e) {
+          await dumpInventory(page, log, `publish-not-clickable-${step + 1}`);
+          await dumpFailure(page, `publish-not-clickable-${step + 1}`, log);
+          throw new Error(`FB publish button "${pub.verb}" found but did not click: ${e.message}`);
+        }
+      }
+
+      // No publish yet — advance via Tiếp.
+      const next = await findByVerbs(nextVerbs);
+      if (!next) {
+        await dumpInventory(page, log, `no-advance-${step + 1}`);
+        await dumpFailure(page, `no-advance-${step + 1}`, log);
+        throw new Error(`FB composer step ${step + 1}: neither publish nor Tiếp button found`);
+      }
+      log('info', `[fb-pw] click "${next.verb}" via "${next.sel}" (step ${step + 1})`);
+      try {
+        await waitAndClick(next.hit, { timeoutMs: 180_000, log, label: `Tiếp(${step + 1})` });
+      } catch (e) {
+        await dumpInventory(page, log, `tiep-not-clickable-${step + 1}`);
+        await dumpFailure(page, `tiep-not-clickable-${step + 1}`, log);
+        throw new Error(`FB Tiếp not clickable at step ${step + 1}: ${e.message}`);
+      }
+
+      // BS-only side-wizard jump fallback — DO NOT run in Page-wall mode.
+      // The BS composer has a left-side wizard with clickable step headers
+      // ("Thước phim" / "Tùy chọn" / "Chia sẻ"). Clicking "Chia sẻ" jumps to
+      // the publish step. The Page-wall modal has NO such wizard; clicking
+      // any "Chia sẻ" text on the page falls through to a feed-item's share
+      // button or sidebar nav, navigating AWAY from the composer and
+      // breaking the flow (iter-38 ended up on /profile.php?sk=reels_tab).
+      const onPageWall = /^https?:\/\/(www\.)?facebook\.com\/?($|\?|#)/.test(page.url());
+      if (step >= 2 && !published && !onPageWall) {
+        log('info', '[fb-pw] Tiếp ineffective — trying side-wizard jump to "Chia sẻ" step (BS only)');
+        const jumpBbox = await page.evaluate(() => {
+          const els = document.querySelectorAll("button, [role='button']");
+          for (const el of els) {
+            const t = (el.innerText || '').trim();
+            if (t !== 'Chia sẻ') continue;
+            const r = el.getBoundingClientRect();
+            if (r.width < 8) continue;
+            return { x: r.x + r.width / 2, y: r.y + r.height / 2 };
+          }
+          return null;
+        });
+        if (jumpBbox) {
+          await page.mouse.click(jumpBbox.x, jumpBbox.y);
+          log('info', `[fb-pw] jumped to Chia sẻ step @ (${Math.round(jumpBbox.x)},${Math.round(jumpBbox.y)})`);
+          await page.waitForTimeout(3000);
+        }
+      }
+    }
+    if (!published) {
+      await dumpInventory(page, log, 'no-publish-after-5');
+      await dumpFailure(page, 'no-publish-after-5', log);
+      throw new Error('FB composer: ran out of Tiếp steps without finding a publish button');
+    }
+
+    // 7) Post-publish — capture URL via multiple sources. After Page-wall
+    //    flow publish, FB often shows a "Đã đăng" toast OR navigates to the
+    //    page wall where the new reel is the latest item.
+    log('info', '[fb-pw] publish clicked — waiting for confirmation…');
+    await page.waitForTimeout(15000); // longer wait for Graph mutation
+    await dumpInventory(page, log, 'post-publish');
+    await dumpFailure(page, 'post-publish', log);
+
+    // 7a) Spam-limit / block detection — FB rate-limits accounts that publish
+    //     too frequently. The block is rendered as a card (not always a
+    //     role='dialog') with text "Để bảo vệ cộng đồng khỏi spam, chúng tôi
+    //     giới hạn tần suất bài đăng…" and "Chỉnh sửa và đăng lại" / "Đóng"
+    //     buttons. If we see this, the reel WAS NOT POSTED — fail loudly so
+    //     the user knows to wait + cool down the account.
+    const blockPhrases = [
+      'giới hạn tần suất',
+      'để bảo vệ cộng đồng khỏi spam',
+      'chỉnh sửa và đăng lại',
+      'spam protection',
+      'temporarily blocked',
+      'you are temporarily blocked',
+      'limit how often',
+      'để giữ cho cộng đồng',
+    ];
+    const blockHit = await page.evaluate((phrases) => {
+      const text = (document.body?.innerText || '').toLowerCase();
+      for (const p of phrases) {
+        if (text.includes(p)) return p;
+      }
+      return null;
+    }, blockPhrases).catch(() => null);
+    if (blockHit) {
+      throw new Error(`FB rate-limited / spam-blocked this account — publish was NOT accepted. Detected phrase: "${blockHit}". Cool down account before retry.`);
+    }
+
+    let postUrl = '';
+
+    // (a) Title-anchored page-wall scrape — FB renders the just-published
+    //     reel inline on the page wall in a "Bài viết đã xuất" / "Vừa được
+    //     đăng" section. The reel has an `<a href="/reel/<id>/">` anchor
+    //     wrapping its thumbnail/title. We FIND that anchor by matching its
+    //     surrounding text against the title we just published (first 30
+    //     chars — collision-free signature). This is RELIABLE because:
+    //       - feed-recommended reels have OTHER titles
+    //       - the just-published reel uses the canonical /reel/<id>/ URL FB
+    //         expects (15-digit format, not the 18-digit story_id container)
+    // (a.0) NAVIGATE TO PAGE REELS TAB — most reliable for finding the
+    //       just-published reel. /profile.php?sk=reels_tab lists Page's reels
+    //       in chronological order (newest first). The first tile with a
+    //       FRESH timestamp ("Vừa xong" / "X phút" / "X giây") is the new
+    //       reel. Skip tiles without a fresh timestamp — those are stale
+    //       same-title duplicates that lured iter-40/42 into wrong picks.
+    //
+    //       This costs ~5s but is the only deterministic way given that:
+    //       - Page wall display order isn't strictly chronological
+    //       - "Quảng bá thước phim" appears on ALL Page reels, not just new
+    //       - Title match alone can't distinguish same-title duplicates
+    try {
+      // Find a link to the page's reels tab. Multi-strategy:
+      //   1. Any existing href containing "sk=reels_tab"
+      //   2. Extract Page ID from "Dòng thời gian của X" timeline anchor or
+      //      any /profile.php?id=<id> anchor, then build the reels_tab URL
+      //   3. Extract Page slug from any /<handle>/ anchor
+      const reelsTabHref = await page.evaluate(() => {
+        // Strategy 1: direct reels_tab link.
+        const direct = document.querySelectorAll("a[href*='sk=reels_tab']");
+        for (const a of direct) {
+          const h = a.getAttribute('href') || '';
+          if (h) return h.startsWith('http') ? h : `https://www.facebook.com${h}`;
+        }
+        // Strategy 2: extract Page ID from a /profile.php?id=<id> anchor.
+        // The "Dòng thời gian của X" anchor and the page-shortcut anchor
+        // both have hrefs like /profile.php?id=61590303065684.
+        const profAnchors = document.querySelectorAll("a[href*='/profile.php?id=']");
+        for (const a of profAnchors) {
+          const h = a.getAttribute('href') || '';
+          const m = h.match(/\/profile\.php\?id=(\d+)/);
+          if (m) return `https://www.facebook.com/profile.php?id=${m[1]}&sk=reels_tab`;
+        }
+        // Strategy 3: page handle via "Dòng thời gian của X" anchor (no
+        // profile.php — uses /<handle> instead).
+        const tlAnchors = document.querySelectorAll("a[aria-label*='Dòng thời gian'], a[aria-label*='Timeline']");
+        for (const a of tlAnchors) {
+          const h = a.getAttribute('href') || '';
+          // /<handle> or /<handle>/?...
+          const m = h.match(/^\/([A-Za-z0-9._-]{3,})\/?(?:\?|$)/);
+          if (m && !['profile.php', 'reel', 'video', 'videos'].includes(m[1])) {
+            return `https://www.facebook.com/${m[1]}/?sk=reels_tab`;
+          }
+          if (h.match(/\/profile\.php\?id=(\d+)/)) {
+            const pid = h.match(/\/profile\.php\?id=(\d+)/)[1];
+            return `https://www.facebook.com/profile.php?id=${pid}&sk=reels_tab`;
+          }
+        }
+        return null;
+      }).catch(() => null);
+      if (reelsTabHref) {
+        log('info', `[fb-pw] navigating to page reels tab: ${reelsTabHref.slice(0, 100)}`);
+        await page.goto(reelsTabHref, { waitUntil: 'domcontentloaded', timeout: 30_000 }).catch(() => {});
+        await page.waitForTimeout(5000);
+        const fresh = await page.evaluate(() => {
+          const norm = (s) => (s || '').toLowerCase().normalize('NFD').replace(/\p{Diacritic}/gu, '');
+          const FRESH_RE = /vừa xong|vài giây|^\s*\d{1,2}\s*giây|^\s*[1-5]\s*phút\b|\b[1-5]\s*phút trước|just now|few seconds ago|\b[1-5] min(ute)?s? ago/i;
+          // Reel tiles on the reels tab — each is an <a href="/reel/<id>/">
+          // wrapping a thumbnail + meta. Iterate in DOM order (newest first
+          // on reels tab). For each tile, check if its subtree has a fresh
+          // timestamp.
+          const anchors = document.querySelectorAll("a[href*='/reel/']");
+          for (const a of anchors) {
+            const href = a.getAttribute('href') || '';
+            const m = href.match(/\/reel\/(\d{8,18})/);
+            if (!m) continue;
+            const r = a.getBoundingClientRect();
+            if (r.width < 8 || r.height < 8) continue;
+            // Look within the anchor's subtree + closest meaningful ancestor.
+            let ctx = a;
+            for (let depth = 0; depth < 5 && ctx; depth++) {
+              const raw = (ctx.innerText || ctx.textContent || '').slice(0, 500);
+              if (FRESH_RE.test(raw)) {
+                return { href, id: m[1], depth, timestamp: (raw.match(FRESH_RE) || [''])[0] };
+              }
+              ctx = ctx.parentElement;
+            }
+          }
+          return null;
+        }).catch(() => null);
+        if (fresh) {
+          const full = fresh.href.startsWith('http') ? fresh.href : `https://www.facebook.com${fresh.href}`;
+          postUrl = full;
+          log('info', `[fb-pw] post URL from reels_tab fresh tile (id=${fresh.id}, depth=${fresh.depth}, timestamp="${fresh.timestamp}"): ${postUrl}`);
+        } else {
+          log('warn', '[fb-pw] reels_tab navigated but no tile with fresh timestamp found');
+        }
+      } else {
+        log('warn', '[fb-pw] no reels_tab link found on page; skipping reels-tab strategy');
+      }
+    } catch (e) {
+      log('warn', `[fb-pw] reels_tab nav strategy failed: ${e.message.slice(0, 100)}`);
+    }
+
+    const titleSig = !postUrl && String(title || description || '').slice(0, 30).replace(/[\s\n]+/g, ' ').trim();
+    if (titleSig && titleSig.length >= 12) {
+      const titleHref = await page.evaluate((sig) => {
+        // Lowercase + accent-fold compare to be tolerant of FB's CSS-styled
+        // title rendering (sometimes uppercase, etc.).
+        const norm = (s) => (s || '').toLowerCase().normalize('NFD').replace(/\p{Diacritic}/gu, '');
+        const sigNorm = norm(sig);
+        // FB Vietnamese fresh-publish timestamps: "Vừa xong", "1 phút", "X
+        // giây", "vài giây trước". Anything older ("1 giờ", "2 ngày", "1
+        // tuần", explicit date like "5 tháng 12") indicates an OLDER reel
+        // with the same title — NOT what we just published. The fresh
+        // pattern matches up to 5 minutes for safety (FB sometimes lags).
+        const FRESH_RE = /vừa xong|vài giây|^\s*\d{1,2}\s*giây|^\s*[1-5]\s*phút\b|\b[1-5]\s*phút trước|just now|few seconds ago|\b[1-5] min(ute)?s? ago/i;
+        const candidates = [];
+        const anchors = document.querySelectorAll("a[role='link']");
+        for (const a of anchors) {
+          const href = a.getAttribute('href') || '';
+          const m = href.match(/\/reel\/(\d{8,18})/);
+          if (!m) continue;
+          // Walk up to 8 levels collecting subtree text. Track FIRST level
+          // where title sig appears + check if a fresh timestamp also
+          // appears in the same container at any depth up to 8.
+          let ctx = a;
+          let titleDepth = -1;
+          let freshDepth = -1;
+          for (let depth = 0; depth < 8 && ctx; depth++) {
+            const raw = (ctx.innerText || ctx.textContent || '').slice(0, 1000);
+            const txt = norm(raw);
+            if (titleDepth < 0 && txt.includes(sigNorm)) titleDepth = depth;
+            if (freshDepth < 0 && FRESH_RE.test(raw)) freshDepth = depth;
+            ctx = ctx.parentElement;
+            if (titleDepth >= 0 && freshDepth >= 0) break;
+          }
+          if (titleDepth < 0) continue;
+          candidates.push({
+            href, id: m[1],
+            titleDepth,
+            freshDepth,
+            hasFresh: freshDepth >= 0,
+          });
+        }
+        if (!candidates.length) return null;
+        // Prefer candidates with fresh timestamp (just-published). Among
+        // them, pick the one with the SHALLOWEST title depth (closest
+        // semantic association). If none are fresh, return null so caller
+        // can fall through to other strategies — DO NOT return an old
+        // same-title reel.
+        const fresh = candidates.filter((c) => c.hasFresh);
+        if (!fresh.length) {
+          return { skipped: true, reason: `${candidates.length} title matches but none with fresh-publish timestamp` };
+        }
+        fresh.sort((a, b) => a.titleDepth - b.titleDepth);
+        return { href: fresh[0].href, id: fresh[0].id, depth: fresh[0].titleDepth, freshDepth: fresh[0].freshDepth, total: candidates.length };
+      }, titleSig).catch(() => null);
+      if (titleHref && titleHref.skipped) {
+        log('warn', `[fb-pw] title-match scrape SKIPPED: ${titleHref.reason} (avoiding stale duplicate)`);
+      } else if (titleHref) {
+        const full = titleHref.href.startsWith('http') ? titleHref.href : `https://www.facebook.com${titleHref.href}`;
+        postUrl = full;
+        log('info', `[fb-pw] post URL via title-match scrape (id=${titleHref.id}, depth=${titleHref.depth}, freshDepth=${titleHref.freshDepth}, total candidates=${titleHref.total}): ${postUrl}`);
+      }
+    }
+
+    // (a.1) Fallback: "Xem thông tin chi tiết" / "Quảng bá thước phim"
+    //       anchors. These sit next to the just-published reel display.
+    //       Note: "Xem thông tin chi tiết" is sometimes a <div> not <a>;
+    //       only the <a role="link"> variant of these CTAs has a useful
+    //       href.
+    if (!postUrl) {
+      const inlineHref = await page.evaluate(() => {
+        const anchors = document.querySelectorAll("a[role='link']");
+        for (const a of anchors) {
+          const aria = (a.getAttribute('aria-label') || '').trim();
+          if (/Xem thông tin chi tiết|View (post )?details|Quảng bá (thước phim|bài viết)|Promote (reel|post)/i.test(aria)) {
+            const href = a.getAttribute('href') || '';
+            if (/\/reel\/\d{8,18}/.test(href)) {
+              return { href, aria: aria.slice(0, 60) };
+            }
+          }
+        }
+        return null;
+      }).catch(() => null);
+      if (inlineHref) {
+        postUrl = inlineHref.href.startsWith('http') ? inlineHref.href : `https://www.facebook.com${inlineHref.href}`;
+        log('info', `[fb-pw] post URL from inline reel "${inlineHref.aria}": ${postUrl}`);
+      }
+    }
+
+    // (a.2) Reel-preview tile on profile reels tab — FB sometimes navigates
+    //       to /profile.php?sk=reels_tab after publish. The FIRST tile in
+    //       DOM order (with aria-label="Bản xem trước ô thước phim" /
+    //       "Reel tile preview") is the NEWEST reel = our just-published.
+    //       Each tile is an <a href="/reel/<id>/"> anchor — scraping that
+    //       href is far more reliable than network-id ordering.
+    if (!postUrl) {
+      const tileHref = await page.evaluate(() => {
+        const anchors = document.querySelectorAll("a[role='link']");
+        for (const a of anchors) {
+          const aria = (a.getAttribute('aria-label') || '').toLowerCase();
+          if (!/bản xem trước ô thước phim|reel tile preview|reel preview/.test(aria)) continue;
+          const href = a.getAttribute('href') || '';
+          const m = href.match(/\/reel\/(\d{8,20})/);
+          if (m) return { href, aria: aria.slice(0, 60) };
+        }
+        return null;
+      }).catch(() => null);
+      if (tileHref) {
+        postUrl = tileHref.href.startsWith('http') ? tileHref.href : `https://www.facebook.com${tileHref.href}`;
+        log('info', `[fb-pw] post URL from FIRST reel tile on reels_tab: ${postUrl}`);
+      }
+    }
+
+    // (b) Graph API network capture — only consider IDs captured AFTER the
+    //     publish click snapshot (pre-snapshot IDs are from the page-wall
+    //     feed pre-render, NOT the publish mutation). Take the FIRST new ID
+    //     since FB's publish-mutation response comes back before any
+    //     feed-reload responses.
+    if (!postUrl && capturedReelIds.length > capturedReelIdsSnapshotLen) {
+      const newIds = capturedReelIds.slice(capturedReelIdsSnapshotLen);
+      // Filter out IDs that appeared in the pre-snapshot to be safe (Set
+      // diff). Then take the FIRST new one.
+      const preSet = new Set(capturedReelIds.slice(0, capturedReelIdsSnapshotLen));
+      const trulyNew = newIds.filter((id) => !preSet.has(id));
+      if (trulyNew.length) {
+        const firstNew = trulyNew[0];
+        postUrl = `https://www.facebook.com/reel/${firstNew}/`;
+        log('info', `[fb-pw] post URL from network (FIRST new ID after snapshot): ${postUrl} (snapshotLen=${capturedReelIdsSnapshotLen} total=${capturedReelIds.length} new=${trulyNew.length})`);
+      }
+    }
+
+    // (b) URL change — FB sometimes navigates to /reel/<id>/ after publish.
+    if (!postUrl) {
+      const cur = page.url();
+      const m = cur.match(/\/reel\/(\d{8,20})|\/videos\/(\d{8,20})/);
+      if (m) {
+        postUrl = cur;
+        log('info', `[fb-pw] post URL from page nav: ${postUrl}`);
+      }
+    }
+
+    // (c) Scoped dialog link — only links INSIDE a post-publish confirmation
+    //     dialog. Page-wall flow usually shows "Đã đăng" toast with a link.
+    if (!postUrl) {
+      const dialogs = page.locator("[role='dialog']");
+      const dlgCount = await dialogs.count().catch(() => 0);
+      for (let i = 0; i < dlgCount && !postUrl; i++) {
+        const dlg = dialogs.nth(i);
+        if (!(await dlg.isVisible().catch(() => false))) continue;
+        const anchors = dlg.locator("a[href*='/reel/'], a[href*='/videos/']");
+        const aCount = Math.min(await anchors.count().catch(() => 0), 4);
+        for (let j = 0; j < aCount; j++) {
+          const href = (await anchors.nth(j).getAttribute('href').catch(() => '')) || '';
+          if (/\/reel\/\d{8,20}|\/videos\/\d{8,20}/.test(href)) {
+            postUrl = href.startsWith('http') ? href : `https://www.facebook.com${href}`;
+            log('info', `[fb-pw] post URL from confirmation dialog: ${postUrl}`);
+            break;
+          }
+        }
+      }
+    }
+
+    // NOTE: page-wall probe was removed (was unreliable — it grabbed the
+    // FIRST visible reel on the Page wall, which is the LATEST EXISTING reel,
+    // not necessarily our just-published one. When FB rate-limited the
+    // publish but we missed the spam dialog, the probe returned a stale reel
+    // and we reported it as "done" — a false success). Better to leave
+    // post_url empty than to record a wrong one. The spam-limit guard above
+    // now catches the FB block case explicitly.
+
+    if (!postUrl) log('warn', '[fb-pw] post URL not captured — upload still considered ok (no spam-block detected, FB likely accepted)');
+
+    // Strip FB tracking params (__cft__, __tn__, etc.) so the stored URL is
+    // canonical. The reel ID alone uniquely identifies the post and the
+    // tracking params expire / leak referrer state.
+    if (postUrl) {
+      const m = postUrl.match(/(https?:\/\/[^/]+\/(?:reel|videos)\/\d{8,20})/);
+      if (m) {
+        const clean = m[1] + '/';
+        if (clean !== postUrl) {
+          log('info', `[fb-pw] canonicalized post URL: ${postUrl.slice(0, 80)}… → ${clean}`);
+          postUrl = clean;
+        }
+      }
+    }
+
+    return {
+      ok: true,
+      title: String(title || description || '').slice(0, 80),
+      visibility,
+      post_url: postUrl,
+      video_path_local: videoPath,
+    };
+  } finally {
+    safeUnlink(videoPath);
+    if (thumbPath) safeUnlink(thumbPath);
+  }
+}
+
+module.exports = { run };