channel-worker 2.4.5 → 2.5.1

package/scripts/upload_youtube.js

@@ -0,0 +1,1151 @@
+// YouTube Studio upload flow via Playwright attached to NSTBrowser (CDP).
+//
+// Payload fields (matches what publishIdea builds for upload_youtube):
+//   video_url, title, description, tags[], visibility ('public'|'unlisted'|'private'),
+//   thumbnail_url, account_name, account_url, job_id.
+//
+// Selectors are pulled from selectors/youtube.json (hot-reloadable). We prefer
+// accessibility (getByRole/getByLabel + Vietnamese fallback) and only fall
+// back to CSS for shadow-DOM custom elements YouTube doesn't expose via ARIA.
+
+const fs = require('fs');
+const path = require('path');
+const { downloadToTemp, safeUnlink } = require('./lib/download');
+
+const SELECTORS_PATH = path.join(__dirname, 'selectors', 'youtube.json');
+
+function loadSelectors() {
+  // Re-read on each invocation so hotfixing selectors.json doesn't need a
+  // daemon restart.
+  return JSON.parse(fs.readFileSync(SELECTORS_PATH, 'utf8'));
+}
+
+// Pick the first VISIBLE match among the locator's results (up to 5 to keep
+// the scan cheap). Studio's Polymer markup keeps hidden duplicates in the DOM
+// — count() > 0 isn't enough; we must require visibility or click() will hang
+// waiting for the hidden one to become actionable.
+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;
+}
+
+// Check if an element is interactive — not just visible, but also enabled. The
+// Next button in Studio's wizard stays disabled until the video upload validates
+// (a few seconds to a couple minutes for large files), so a plain `.click()`
+// will hang waiting. Polymer custom elements often use `aria-disabled="true"`
+// instead of the native `disabled` attribute; check both.
+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;
+}
+
+// Wait for a located button to become actionable (visible + enabled) and then
+// click. Used for transitions like Studio's Next which is disabled during
+// video upload — the button is in the DOM the whole time, but only clickable
+// once Studio finishes its validation.
+async function waitAndClick(loc, { timeoutMs = 120_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`);
+}
+
+// Resolve an interactive element. Tries CSS candidates FIRST (more specific —
+// scoped to the upload modal), THEN accessibility-based matches as fallback.
+// The original "role first" order was matching wrong Tiếp/Next buttons in
+// Studio's tutorial overlays before the actual wizard Next button.
+async function locateButton(page, spec, { timeoutMs = 15000 } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  const probe = async () => {
+    if (Array.isArray(spec?.cssCandidates)) {
+      for (const css of spec.cssCandidates) {
+        try {
+          const hit = await firstVisible(page.locator(css));
+          if (hit) return hit;
+        } catch { /* invalid selector for this Playwright version — try next */ }
+      }
+    }
+    if (Array.isArray(spec?.byRoleName)) {
+      for (const name of spec.byRoleName) {
+        const hit = await firstVisible(page.getByRole('button', { name: new RegExp(name, 'i') }));
+        if (hit) return hit;
+      }
+    }
+    if (Array.isArray(spec?.byMenuItemName)) {
+      for (const name of spec.byMenuItemName) {
+        const hit = await firstVisible(page.getByRole('menuitem', { name: new RegExp(name, 'i') }));
+        if (hit) return hit;
+      }
+    }
+    if (Array.isArray(spec?.byLabel)) {
+      for (const label of spec.byLabel) {
+        const hit = await firstVisible(page.getByLabel(new RegExp(label, 'i')));
+        if (hit) return hit;
+      }
+    }
+    return null;
+  };
+  while (Date.now() < deadline) {
+    const hit = await probe();
+    if (hit) return hit;
+    await page.waitForTimeout(400);
+  }
+  throw new Error(`button not found (no visible match): ${JSON.stringify(spec).slice(0, 200)}`);
+}
+
+// On failure dump everything we need to debug remotely: screenshot, URL/title,
+// body head, AND the list of visible interactive elements (buttons + menu items)
+// with their id/text/aria-label so we can patch selectors without ssh-ing into
+// the win-worker browser. Best-effort: any sub-step failure just logs and moves
+// on so the original error still propagates.
+async function dumpFailure(page, tag, log) {
+  try {
+    const path = require('path');
+    const os = require('os');
+    const dir = path.join(os.tmpdir(), 'cm-worker-pw');
+    const png = path.join(dir, `${tag}-${Date.now()}.png`);
+    await page.screenshot({ path: png, fullPage: false, timeout: 8000 }).catch(() => {});
+    const url = page.url();
+    const title = await page.title().catch(() => '');
+    const bodyHead = await page.evaluate(() => (document.body?.innerText || '').slice(0, 400)).catch(() => '');
+    log('warn', `[yt-pw] page dump on ${tag} — url=${url} | title=${title.slice(0, 80)} | head=${bodyHead.replace(/\s+/g, ' ').slice(0, 200)} | screenshot=${png}`);
+
+    // Snapshot of every VISIBLE interactive element — so when Studio renames
+    // an id or swaps a tag we see what's there instead.
+    const inventory = await page.evaluate(() => {
+      const out = [];
+      const sels = [
+        'button', '[role="button"]', '[role="menuitem"]',
+        'ytcp-button', 'ytcp-icon-button', 'tp-yt-paper-item', 'tp-yt-paper-button', 'ytcp-text-menu-item',
+      ];
+      const els = document.querySelectorAll(sels.join(','));
+      for (const el of els) {
+        const r = el.getBoundingClientRect();
+        if (r.width === 0 || r.height === 0) continue;
+        const cs = getComputedStyle(el);
+        if (cs.visibility === 'hidden' || cs.display === 'none' || cs.opacity === '0') continue;
+        const text = (el.innerText || el.textContent || '').trim().slice(0, 50);
+        const id = el.id || '';
+        const aria = el.getAttribute('aria-label') || '';
+        const role = el.getAttribute('role') || '';
+        const disabled = el.disabled || el.getAttribute('aria-disabled') === 'true';
+        out.push(`<${el.tagName.toLowerCase()} id="${id}" role="${role}" aria="${aria.slice(0, 40)}" disabled="${disabled}">${text}</>`);
+        if (out.length >= 30) break;
+      }
+      return out;
+    }).catch(() => []);
+    if (inventory.length) {
+      log('warn', `[yt-pw] visible buttons/menuitems on ${tag}:\n  ${inventory.join('\n  ')}`);
+    }
+  } catch (e) {
+    log('warn', `[yt-pw] page dump failed: ${e.message}`);
+  }
+}
+
+async function locateField(page, spec, { timeoutMs = 15000 } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (Array.isArray(spec?.byLabel)) {
+      for (const label of spec.byLabel) {
+        const hit = await firstVisible(page.getByLabel(new RegExp(label, 'i')));
+        if (hit) return hit;
+      }
+    }
+    if (Array.isArray(spec?.cssCandidates)) {
+      for (const css of spec.cssCandidates) {
+        try {
+          const hit = await firstVisible(page.locator(css));
+          if (hit) return hit;
+        } catch {}
+      }
+    }
+    await page.waitForTimeout(300);
+  }
+  throw new Error(`field not found (no visible match): ${JSON.stringify(spec).slice(0, 200)}`);
+}
+
+async function jitter(page, baseMs = 1200) {
+  // Human-ish pacing between actions.
+  await page.waitForTimeout(baseMs + Math.floor(Math.random() * 1500));
+}
+
+// Best-effort dismiss of a blocking Polymer overlay backdrop. Only runs when
+// `<tp-yt-iron-overlay-backdrop opened>` is actually present (otherwise the
+// click sweep can hit unrelated "Bỏ qua / Skip" buttons in the page and break
+// the flow — saw this in v29d run where multiple dismiss clicks closed the
+// Create dropdown). Stops after the FIRST visible match per sweep.
+async function dismissOverlays(page, log) {
+  // Phrases ordered by priority. Welcome / continue verbs first — when the
+  // backdrop is up the visible dialog is usually a multi-step welcome flow
+  // ("Chào mừng bạn đến với YouTube Studio" → "Tiếp tục"). Skip/dismiss verbs
+  // come later as fallback.
+  const phrases = [
+    'Tiếp tục', 'Tiếp theo', 'Bắt đầu',
+    'Continue', 'Next', 'Get started', 'Start',
+    'Got it', 'Đã hiểu',
+    'Skip the tutorial', 'Skip tutorial', 'Skip tour', 'Skip',
+    'Dismiss', 'Not now', 'No thanks', 'Close',
+    'Bỏ qua phần hướng dẫn', 'Bỏ qua hướng dẫn', 'Bỏ qua',
+    'Để sau', 'Không phải bây giờ', 'Đóng',
+  ];
+
+  // CRITICAL: only consider buttons INSIDE an opened dialog. Previous bug:
+  // when the backdrop was up, we matched "Bỏ qua phần hướng dẫn" (sidebar
+  // tutorial-skip, OUTSIDE the modal) — click intercepted by backdrop, button
+  // still visible, loop spun 6 times doing nothing. Studio's dialog wrappers:
+  //   tp-yt-paper-dialog[opened]
+  //   ytcp-dialog[opened]
+  //   ytcp-confirmation-dialog[opened]
+  //   any element with role="dialog" that's a sibling of the opened backdrop
+  const dialogScopes = [
+    "tp-yt-paper-dialog[opened]",
+    "ytcp-dialog[opened]",
+    "ytcp-confirmation-dialog[opened]",
+    "[role='dialog']:visible",
+  ];
+
+  for (let pass = 0; pass < 6; pass++) {
+    const backdropOpen = await page.locator("tp-yt-iron-overlay-backdrop[opened]").count().catch(() => 0);
+    if (!backdropOpen) return;
+
+    let clicked = false;
+    // Try each visible dialog scope in order.
+    for (const dlgSel of dialogScopes) {
+      if (clicked) break;
+      const dlg = page.locator(dlgSel).first();
+      const dlgCount = await dlg.count().catch(() => 0);
+      if (dlgCount === 0) continue;
+      if (!(await dlg.isVisible().catch(() => false))) continue;
+      // Search clickables INSIDE this dialog only.
+      for (const p of phrases) {
+        const candidates = [
+          `button:has-text('${p}')`,
+          `tp-yt-paper-button:has-text('${p}')`,
+          `ytcp-button:has-text('${p}')`,
+        ];
+        for (const sel of candidates) {
+          try {
+            const hit = await firstVisible(dlg.locator(sel), 3);
+            if (!hit) continue;
+            log('info', `[yt-pw] dismissing overlay via "${dlgSel} ${sel}" (pass ${pass + 1})`);
+            await hit.click({ timeout: 3000 }).catch(() => {});
+            await page.waitForTimeout(700);
+            clicked = true;
+            break;
+          } catch {}
+        }
+        if (clicked) break;
+      }
+    }
+    if (!clicked) {
+      // No dialog matched — try Escape as last resort, then bail.
+      log('info', `[yt-pw] no dismissable button found in opened dialog (pass ${pass + 1}) — trying Escape`);
+      try { await page.keyboard.press('Escape'); } catch {}
+      await page.waitForTimeout(500);
+      // If Escape didn't help on this pass, don't burn more passes.
+      const stillOpen = await page.locator("tp-yt-iron-overlay-backdrop[opened]").count().catch(() => 0);
+      if (stillOpen) return;
+    }
+  }
+}
+
+// Deep diagnostic: dump file inputs across the entire document (incl. open
+// shadow roots), every Polymer custom element whose tag contains 'thumb',
+// and every visible button-like element whose text suggests "Show more" /
+// "Add" / "Hiển thị thêm" / "Tải lên" — enough surface area to patch
+// selectors for thumbnail + tags without manually inspecting in DevTools.
+async function inspectDetailsForm(page, log) {
+  try {
+    const inv = await page.evaluate(() => {
+      const out = [];
+      // Walk document + open shadow roots — Studio's Polymer wrappers hide
+      // file inputs and rich controls behind shadowRoot.
+      const allEls = [];
+      const visit = (root) => {
+        allEls.push(...root.querySelectorAll('*'));
+        root.querySelectorAll('*').forEach((el) => {
+          if (el.shadowRoot && el.shadowRoot.mode === 'open') visit(el.shadowRoot);
+        });
+      };
+      visit(document);
+
+      // 1) Every file input anywhere (likely all hidden — what matters is the
+      // parent/grandparent chain so we can pick a stable Polymer ancestor).
+      const fileInputs = allEls.filter((el) => el.tagName === 'INPUT' && el.type === 'file');
+      fileInputs.forEach((el, i) => {
+        const ancestors = [];
+        let p = el;
+        for (let n = 0; n < 6 && p; n++) {
+          ancestors.push(`${p.tagName.toLowerCase()}${p.id ? '#' + p.id : ''}${p.className && typeof p.className === 'string' ? '.' + p.className.split(/\s+/).filter(Boolean).slice(0, 2).join('.') : ''}`);
+          p = p.parentElement || (p.getRootNode() && p.getRootNode().host);
+        }
+        out.push(`file-input[${i}] accept="${(el.accept || '').slice(0, 40)}" name="${el.name || ''}" id="${el.id || ''}" ancestors=${ancestors.slice(0, 5).join(' > ')}`);
+      });
+
+      // 2) Polymer custom elements tagged with 'thumb' anywhere in their name —
+      // ytcp-thumbnail-*, ytcp-thumbnails-*, etc. Capture their immediate
+      // child-input pattern so we know how to setInputFiles.
+      const thumbEls = allEls.filter((el) => /thumb/i.test(el.tagName));
+      thumbEls.slice(0, 8).forEach((el) => {
+        const id = el.id || '';
+        const r = el.getBoundingClientRect();
+        const visible = r.width > 0 && r.height > 0;
+        const childInput = el.querySelector("input[type='file']") || (el.shadowRoot && el.shadowRoot.querySelector("input[type='file']"));
+        out.push(`<${el.tagName.toLowerCase()}${id ? ' id="' + id + '"' : ''}> visible=${visible} has-file-input=${!!childInput}`);
+      });
+
+      // 3) ALL visible buttons inside the upload modal, with text + aria —
+      // first pass had a regex filter that missed Studio's actual button
+      // labels (Show more was probably "Hiện cài đặt nâng cao" or icon-only).
+      // Dump everything so the next iteration can pick the right one.
+      const dlg2 = document.querySelector('ytcp-uploads-dialog');
+      if (dlg2) {
+        const dlgButtons = dlg2.querySelectorAll('button, ytcp-button, ytcp-icon-button, ytcp-text-menu-item, [role="button"]');
+        let dumped = 0;
+        for (const el of dlgButtons) {
+          const r = el.getBoundingClientRect();
+          if (r.width === 0 || r.height === 0) continue;
+          const text = (el.innerText || el.textContent || '').trim().replace(/\s+/g, ' ');
+          const aria = el.getAttribute('aria-label') || '';
+          if (!text && !aria) continue;
+          out.push(`btn <${el.tagName.toLowerCase()}${el.id ? ' id="' + el.id + '"' : ''} aria="${aria.slice(0, 40)}">${text.slice(0, 50)}</>`);
+          if (++dumped >= 40) break;
+        }
+      }
+
+      // 4) ALL radio buttons — Made for kids / Age restriction / Altered
+      // content / etc. Dump everything so unfamiliar ones (AI disclosure,
+      // shorts-only questions) are visible without another iteration.
+      allEls.filter((el) => el.tagName === 'TP-YT-PAPER-RADIO-BUTTON').forEach((el) => {
+        out.push(`radio name="${el.getAttribute('name') || ''}" text="${(el.innerText || '').trim().slice(0, 50)}"`);
+      });
+
+      return out;
+    }).catch(() => []);
+    if (inv.length) {
+      log('info', `[yt-pw] details-form inventory:\n  ${inv.join('\n  ')}`);
+    }
+  } catch (e) {
+    log('warn', `[yt-pw] details-form inventory failed: ${e.message}`);
+  }
+}
+
+// Tick the "Altered/synthetic content" YES radio on the Details step. YouTube
+// requires creators to disclose AI-generated content that depicts realistic
+// people/events. Our pipeline outputs are Veo3 + edited — always YES.
+// Polymer name pattern observed in Studio:
+//   tp-yt-paper-radio-button[name='ALTERED_CONTENT_YES'] (newer)
+//   tp-yt-paper-radio-button[name='ALTERED_OR_SYNTHETIC_CONTENT_YES'] (older)
+// Tick the "Altered/synthetic content" YES radio. STRICT: if no selector
+// matches, throw — every input step must complete or the cmd is failed.
+// Caller can wrap in try/catch if a particular channel is exempt.
+async function selectAlteredContentYes(page, log) {
+  const candidates = [
+    "tp-yt-paper-radio-button[name='VIDEO_HAS_ALTERED_CONTENT_YES']",
+    "tp-yt-paper-radio-button[name='ALTERED_CONTENT_YES']",
+    "tp-yt-paper-radio-button[name='ALTERED_OR_SYNTHETIC_CONTENT_YES']",
+    "tp-yt-paper-radio-button[name*='ALTERED_CONTENT'][name$='YES']",
+    "tp-yt-paper-radio-button[name*='ALTERED'][name$='_YES']",
+    "tp-yt-paper-radio-button[name*='SYNTHETIC'][name$='_YES']",
+  ];
+  for (const sel of candidates) {
+    try {
+      const hit = await firstVisible(page.locator(sel), 3);
+      if (hit) {
+        log('info', `[yt-pw] picking 'Altered/AI content = YES' via "${sel}"`);
+        await hit.click({ timeout: 3000 });
+        return;
+      }
+    } catch {}
+  }
+  throw new Error('altered/AI content radio not found — Studio markup changed; update selectAlteredContentYes selectors');
+}
+
+// Pick "Not made for kids" on Studio's required Audience question. STRICT:
+// throw if not found — without this, Studio leaves Next disabled and the
+// flow stalls anyway.
+async function selectNotMadeForKids(page, log) {
+  const candidates = [
+    "tp-yt-paper-radio-button[name='VIDEO_MADE_FOR_KIDS_NOT_MFK']",
+    "tp-yt-paper-radio-button[name='NOT_MFK']",
+    "input[type='radio'][value*='NOT_MFK']",
+  ];
+  for (const sel of candidates) {
+    try {
+      const hit = await firstVisible(page.locator(sel), 3);
+      if (hit) {
+        log('info', `[yt-pw] picking 'Not made for kids' via "${sel}"`);
+        await hit.click({ timeout: 3000 });
+        return;
+      }
+    } catch {}
+  }
+  // Label-based fallback — Studio's i18n: "No, it's not made for kids" /
+  // "Không phải video dành cho trẻ em".
+  try {
+    const byLabel = await firstVisible(page.getByText(/Không phải video dành cho trẻ em|No, it'?s not made for kids/i), 3);
+    if (byLabel) {
+      log('info', `[yt-pw] picking 'Not made for kids' via text match`);
+      await byLabel.click({ timeout: 3000 });
+      return;
+    }
+  } catch {}
+  throw new Error("'Not made for kids' radio not found — Studio markup changed; update selectNotMadeForKids selectors");
+}
+
+async function run({ page, payload, log }) {
+  const { video_url, title, description = '', tags = [], visibility = 'public', thumbnail_url, account_name } = payload || {};
+  if (!video_url) throw new Error('No video_url provided');
+  if (!title) throw new Error('No title provided');
+
+  const S = loadSelectors();
+  log('info', `[yt-pw] selectors version=${S.version}`);
+
+  // Auto-accept any beforeunload / confirmation dialog so a stuck previous-run
+  // upload modal doesn't block our goto(studio) with "Are you sure you want to
+  // leave? Your upload will be cancelled." Saw this trigger silently when the
+  // last run left ytcp-uploads-dialog open in the same NST profile.
+  page.on('dialog', (d) => { d.accept().catch(() => {}); });
+
+  // Capture the freshly-uploaded video's ID directly from YouTube's network
+  // responses. Studio's youtubei mutations carry { videoId: 'XXXXXXXXXXX' } on
+  // upload/save calls, which is far more reliable than scraping the share
+  // dialog (it auto-closes, gets covered by toasts, or never appears for
+  // Shorts). We hold onto the LAST observed videoId — the one issued for our
+  // upload, not a stale Creators recommendation.
+  const networkVideoIds = [];
+  page.on('response', async (resp) => {
+    try {
+      const u = resp.url();
+      if (!/youtubei\/v1\/(upload|video|video_manager)/i.test(u)) return;
+      // Fast path: many endpoints expose videoId in the URL or response JSON.
+      const inUrl = u.match(/videoId=([A-Za-z0-9_-]{11})/);
+      if (inUrl) { networkVideoIds.push(inUrl[1]); return; }
+      const ct = (resp.headers()['content-type'] || '');
+      if (!/json/i.test(ct)) return;
+      const text = await resp.text().catch(() => '');
+      if (!text) return;
+      const m = text.match(/"videoId"\s*:\s*"([A-Za-z0-9_-]{11})"/);
+      if (m) networkVideoIds.push(m[1]);
+    } catch { /* ignore */ }
+  });
+  // Expose to the URL-extraction step via the run closure.
+  // eslint-disable-next-line no-param-reassign
+  payload.__networkVideoIds = networkVideoIds;
+
+  // 1) Download video to local disk — Playwright setInputFiles needs a path.
+  log('info', `[yt-pw] downloading video to local…`);
+  const videoPath = await downloadToTemp(video_url, { prefix: 'yt', ext: '.mp4' });
+  log('info', `[yt-pw] video at ${videoPath}`);
+
+  let thumbPath = null;
+  if (thumbnail_url) {
+    try {
+      thumbPath = await downloadToTemp(thumbnail_url, { prefix: 'thumb', ext: '.png' });
+      log('info', `[yt-pw] thumbnail at ${thumbPath}`);
+    } catch (e) { log('warn', `[yt-pw] thumbnail download failed: ${e.message}`); }
+  }
+
+  try {
+    // 2) Open Studio (cookie-logged via NST).
+    log('info', `[yt-pw] open studio.youtube.com…`);
+    await page.goto(S.studioUrl, { waitUntil: 'domcontentloaded', timeout: 60_000 });
+    await page.waitForLoadState('networkidle', { timeout: 30_000 }).catch(() => {});
+    // Studio's chrome takes a moment to render after DOM ready — give it some
+    // grace before scanning for buttons.
+    await page.waitForTimeout(2500);
+    log('info', `[yt-pw] page loaded — url=${page.url()} title=${(await page.title().catch(()=>''))}`);
+
+    // 2b) Dismiss any onboarding/tutorial overlay. Studio sometimes shows a
+    // first-visit tutorial with a `tp-yt-iron-overlay-backdrop` that intercepts
+    // every click on the page (saw "Bỏ qua phần hướng dẫn / Tạo Kênh của bạn"
+    // in a recent dump → wizard Next couldn't be clicked). Best-effort: find any
+    // visible "Skip / Dismiss / Got it" button (EN + VI) and click it.
+    await dismissOverlays(page, log);
+
+    // 3) (Optional) account_name check is left to the caller — switching
+    // channels in Studio is its own dance and out of scope for the pilot.
+
+    // 4) Click Create → "Upload videos".
+    log('info', `[yt-pw] click Create…`);
+    let createBtn;
+    try { createBtn = await locateButton(page, S.createButton, { timeoutMs: 20_000 }); }
+    catch (e) { await dumpFailure(page, 'create-not-found', log); throw e; }
+    await createBtn.click();
+    // Studio's Create dropdown animates open — give it time to render before
+    // we scan for the menu item, otherwise we may match a hidden duplicate.
+    await page.waitForTimeout(1200);
+
+    // Confirm the dropdown actually opened. If clicking the wrapper failed to
+    // trigger it (e.g., match landed on an inner element with no handler), we
+    // want to know FAST — otherwise the later locateButton just times out and
+    // hides the root cause. Studio's dropdown contains menuitem elements with
+    // text containing 'video' (Upload videos / Tải video lên / Go live / Đi
+    // trực tiếp / Create post / Tạo bài đăng).
+    const dropdownOpen = await page.locator("tp-yt-paper-listbox tp-yt-paper-item, ytcp-text-menu-item, [role='menu'] [role='menuitem']").first().isVisible({ timeout: 3000 }).catch(() => false);
+    if (!dropdownOpen) {
+      log('warn', `[yt-pw] Create dropdown did not open after click — retrying with a different match`);
+      // Retry: re-locate Create and try clicking the inner native button this
+      // time (some Studio builds register the handler on the button child).
+      try {
+        const altCreate = page.locator("ytcp-button:has-text('Tạo'), ytcp-button:has-text('Create')").last();
+        if (await altCreate.isVisible().catch(() => false)) {
+          await altCreate.click({ timeout: 3000 });
+          await page.waitForTimeout(1200);
+        }
+      } catch {}
+    }
+
+    log('info', `[yt-pw] click "Upload videos"…`);
+    let uploadItem;
+    try { uploadItem = await locateButton(page, S.uploadMenuItem, { timeoutMs: 15_000 }); }
+    catch (e) { await dumpFailure(page, 'upload-menu-not-found', log); throw e; }
+    await uploadItem.click();
+    await jitter(page, 800);
+
+    // 5) The KEY step — set the video file.
+    log('info', `[yt-pw] setInputFiles(video)…`);
+    await page.locator(S.fileInput).setInputFiles(videoPath);
+    log('info', `[yt-pw] file set; waiting for the metadata form to appear…`);
+
+    // 6) Wait for the Title field to be ready (Studio renders it as the file
+    // starts processing). Default title = filename; we'll overwrite.
+    //
+    // Use POSITIONAL lookup, not id/label: in Studio 2026 the title/description
+    // ids changed, and getByLabel(/Mô tả/) sometimes matched the title field
+    // → we ended up typing title + description into the SAME field (271/100).
+    // Inside the upload dialog there are exactly two top-level contenteditable
+    // rich-text boxes — [0] = title, [1] = description.
+    // Check for hard upload blockers BEFORE entering the scrim-wait loop, so
+    // we fail fast with a clear message instead of hanging on a scrim that
+    // never clears. Currently checks the daily upload quota banner — Studio
+    // shows it as a red alert inside ytcp-uploads-dialog while the scrim
+    // stays up indefinitely (upload was rejected, modal can't progress).
+    const checkUploadBlockers = async () => {
+      return page.evaluate(() => {
+        const dlg = document.querySelector('ytcp-uploads-dialog');
+        if (!dlg) return null;
+        const text = (dlg.innerText || '').slice(0, 4000);
+        const patterns = [
+          // Vietnamese
+          /Đã đạt giới hạn tải video lên hằng ngày/i,
+          /giới hạn tải video lên/i,
+          /vượt quá giới hạn tải/i,
+          // English
+          /Daily upload limit reached/i,
+          /You'?ve reached your daily upload limit/i,
+          /Upload limit reached/i,
+        ];
+        for (const re of patterns) {
+          const m = text.match(re);
+          if (m) return { kind: 'quota_exceeded', match: m[0] };
+        }
+        return null;
+      }).catch(() => null);
+    };
+
+    const blocker = await checkUploadBlockers();
+    if (blocker) {
+      await dumpFailure(page, `upload-blocked-${blocker.kind}`, log);
+      throw new Error(`YouTube upload blocked: ${blocker.kind} — "${blocker.match}". Channel hit the daily upload quota (~15 unverified / 50+ verified). Wait ~24h or complete phone verification at studio.youtube.com.`);
+    }
+
+    const editables = page.locator("ytcp-uploads-dialog [contenteditable='true']");
+    // Wait for both contenteditables to render AND for the upload dialog's
+    // scrim overlay to clear. Studio puts a `<div class="dialog-scrim">` over
+    // the form during the open transition + initial file processing — it
+    // doesn't hide the field (isVisible() returns true) but it intercepts every
+    // pointer event ("dialog-scrim intercepts pointer events" in Playwright's
+    // retry log). Waiting for fields alone is not enough.
+    // Recheck the quota banner each iteration — it sometimes appears after
+    // the initial pre-upload validation completes.
+    const formDeadline = Date.now() + 120_000;
+    let titleField = editables.nth(0);
+    let formReady = false;
+    while (Date.now() < formDeadline) {
+      const lateBlocker = await checkUploadBlockers();
+      if (lateBlocker) {
+        await dumpFailure(page, `upload-blocked-${lateBlocker.kind}`, log);
+        throw new Error(`YouTube upload blocked: ${lateBlocker.kind} — "${lateBlocker.match}". Channel hit the daily upload quota. Wait ~24h or complete phone verification.`);
+      }
+      const n = await editables.count().catch(() => 0);
+      if (n >= 2) {
+        const scrimBlocking = await page.evaluate(() => {
+          const scrim = document.querySelector('ytcp-uploads-dialog .dialog-scrim');
+          if (!scrim) return false;
+          const r = scrim.getBoundingClientRect();
+          if (r.width === 0 || r.height === 0) return false;
+          const cs = getComputedStyle(scrim);
+          if (cs.display === 'none' || cs.visibility === 'hidden') return false;
+          if (cs.pointerEvents === 'none') return false;
+          return true;
+        }).catch(() => false);
+        if (!scrimBlocking && await isActionable(editables.nth(0))) {
+          formReady = true;
+          break;
+        }
+      }
+      await page.waitForTimeout(500);
+    }
+    if (!formReady) {
+      await dumpFailure(page, 'title-field-not-actionable', log);
+      throw new Error('title field never became actionable (scrim never cleared or modal stuck)');
+    }
+    const descField = editables.nth(1);
+
+    // YouTube hard-caps title at 100 chars — over the limit, Studio rejects
+    // input mid-typing and blocks Next. Clip with ellipsis on overflow. Safety
+    // net here even though publishIdea also clips, in case the cmd payload
+    // came from another path (manual mongosh, legacy, etc.).
+    const titleForUpload = (title && title.length > 100) ? (title.slice(0, 99) + '…') : title;
+    log('info', `[yt-pw] fill title (${titleForUpload.length}/${title.length} chars${title.length > 100 ? ' — clipped from ' + title.length : ''})…`);
+    try {
+      await titleField.click({ timeout: 10_000 });
+    } catch (e) {
+      await dumpFailure(page, 'title-click-failed', log);
+      throw e;
+    }
+    await page.keyboard.press('Control+A');
+    await page.keyboard.press('Delete');
+    await titleField.type(titleForUpload, { delay: 25 });
+    await jitter(page, 600);
+
+    if (description) {
+      log('info', `[yt-pw] fill description (${description.length} chars)…`);
+      try {
+        // descField.click() places the cursor INSIDE the description field
+        // (different element than title, guaranteed by .nth(1)).
+        await descField.click();
+        await page.keyboard.press('Control+A');
+        await page.keyboard.press('Delete');
+        await descField.type(description, { delay: 15 });
+      } catch (e) { throw new Error(`description fill failed: ${e.message}`); }
+    }
+
+    // tags handled below — after Show more expand, see section 7d.
+
+    // 7) Thumbnail (custom). YouTube web UI does NOT allow custom thumbnail
+    // uploads for Shorts — that's a mobile-app-only feature. For Shorts, the
+    // pipeline pre-bakes the custom thumbnail as the FIRST FRAME of the rendered
+    // video (see render pipeline), so YT's auto-extracted first-frame thumbnail
+    // IS our custom thumbnail. Skip the web upload attempt entirely for Shorts.
+    const isShortFormat = String(payload.format || '').toLowerCase().includes('short');
+    if (isShortFormat && thumbPath) {
+      log('info', `[yt-pw] thumbnail skipped for Shorts — YT auto-uses video's first frame (custom thumb pre-baked in render)`);
+    }
+    if (thumbPath && !isShortFormat) {
+      try {
+        log('info', `[yt-pw] uploading custom thumbnail…`);
+        // Wide probe — Studio sometimes mounts the file input/icon as a
+        // sibling of ytcp-video-thumbnail-editor (under ytcp-thumbnail-uploader)
+        // or lazily under <body>. Scoping to just the editor missed it.
+        const thumbInventory = await page.evaluate(() => {
+          const out = { fileInputs: [], buttons: [], hostFound: [] };
+          const editor = document.querySelector('ytcp-uploads-dialog')
+            || document.querySelector('ytcp-video-thumbnail-editor')
+            || document.body;
+          if (!editor) return out;
+          // Note hosts that EXIST in the doc — helps narrow next iteration.
+          ['ytcp-thumbnail-uploader', 'ytcp-thumbnail-with-title', 'ytcp-video-thumbnail-editor', 'ytcp-uploads-dialog'].forEach((tag) => {
+            if (document.querySelector(tag)) out.hostFound.push(tag);
+          });
+          // Look for the magic icon ANYWHERE in the document.
+          ['#add-photo-icon', '#file-loader', "input[name='Filedata']"].forEach((sel) => {
+            const el = document.querySelector(sel);
+            if (el) out.fileInputs.push({ accept: el.accept || '', name: el.name || sel, id: el.id || '', hidden: el.offsetParent === null, ancestor: el.tagName.toLowerCase() });
+          });
+          const walk = [];
+          const visit = (root) => {
+            walk.push(...root.querySelectorAll('*'));
+            root.querySelectorAll('*').forEach((el) => {
+              if (el.shadowRoot && el.shadowRoot.mode === 'open') visit(el.shadowRoot);
+            });
+          };
+          visit(editor);
+          for (const el of walk) {
+            if (el.tagName === 'INPUT' && el.type === 'file') {
+              out.fileInputs.push({
+                accept: el.accept || '',
+                name: el.name || '',
+                id: el.id || '',
+                hidden: el.offsetParent === null,
+                ancestor: el.parentElement?.tagName?.toLowerCase() || '',
+              });
+            }
+            // Click-like elements (buttons, divs with role, labels) — record
+            // class/id/aria so we can target the actual trigger.
+            const isClickable = el.tagName === 'BUTTON' || el.tagName === 'YTCP-BUTTON'
+              || el.tagName === 'YTCP-ICON-BUTTON' || el.tagName === 'LABEL'
+              || el.getAttribute?.('role') === 'button' || el.getAttribute?.('tabindex') === '0';
+            if (!isClickable) continue;
+            const r = el.getBoundingClientRect();
+            if (r.width === 0 || r.height === 0) continue;
+            out.buttons.push({
+              tag: el.tagName.toLowerCase(),
+              id: el.id || '',
+              aria: el.getAttribute('aria-label') || '',
+              text: (el.innerText || el.textContent || '').trim().slice(0, 40),
+              cls: (typeof el.className === 'string' ? el.className.split(/\s+/).slice(0, 2).join('.') : ''),
+            });
+            if (out.buttons.length >= 20) break;
+          }
+          return out;
+        }).catch(() => ({ fileInputs: [], buttons: [] }));
+        log('info', `[yt-pw] thumb-probe: hosts=${thumbInventory.hostFound.join(',') || '(none)'} | file-input(s)=${thumbInventory.fileInputs.length} | clickable(s)=${thumbInventory.buttons.length}`);
+        thumbInventory.fileInputs.forEach((fi, i) => log('info', `  thumb-fileinput[${i}] accept=${fi.accept} hidden=${fi.hidden} parent=${fi.ancestor}`));
+        thumbInventory.buttons.slice(0, 10).forEach((b, i) => log('info', `  thumb-clickable[${i}] <${b.tag}> id=${b.id} aria="${b.aria}" text="${b.text}"`));
+
+        let thumbDone = false;
+
+        // Path A — legacy hidden input. Some Studio cohorts still expose
+        // <input id="file-loader" type="file"> in light DOM; setInputFiles
+        // bypasses any click flow entirely.
+        const legacyInput = page.locator("#file-loader, input[name='Filedata']").first();
+        if (await legacyInput.count().catch(() => 0) > 0) {
+          try {
+            await legacyInput.setInputFiles(thumbPath);
+            log('info', `[yt-pw] thumbnail set via legacy input#file-loader`);
+            thumbDone = true;
+            await page.waitForTimeout(800);
+          } catch (e) {
+            log('info', `[yt-pw] legacy input setInputFiles failed: ${e.message.slice(0, 80)}`);
+          }
+        }
+
+        // Path B — modern: click into the thumbnail editor via raw DOM walk
+        // that pierces ANY shadow boundary (open). Playwright's CSS locator
+        // matched count=0 for `ytcp-uploads-dialog ytcp-thumbnail-with-title`
+        // even though the deep-walk probe found the element — confirms it's
+        // inside an open shadow root that page.locator can't reach with the
+        // descendant combinator. Race the filechooser with a JS click.
+        if (!thumbDone) {
+          // Try several candidate targets in priority order.
+          //   B1. el.click() via shadow walk — synthetic click (sometimes fails).
+          //   B2. page.mouse.click(bboxCenter) — real CDP mouse, trusted event.
+          //       Studio's handler is gated on isTrusted=true on some builds.
+          const targetCandidates = [
+            { tag: 'YTCP-THUMBNAIL-UPLOADER', why: 'Studio 2024+ uploader wrapper' },
+            { tag: 'YTCP-THUMBNAIL-WITH-TITLE', why: 'wrapper containing upload slot' },
+            { tag: 'YTCP-THUMBNAIL', why: 'first thumbnail tile = upload trigger' },
+          ];
+
+          // Helper: dump SHADOW DOM contents of a target so we can patch
+          // selectors when none of these work. Only fires on the LAST attempt.
+          const dumpShadowChildren = async (tagName) => {
+            const dump = await page.evaluate(({ tagName }) => {
+              const walk = (root) => {
+                for (const el of root.querySelectorAll('*')) {
+                  if (el.tagName === tagName) return el;
+                  if (el.shadowRoot && el.shadowRoot.mode === 'open') {
+                    const f = walk(el.shadowRoot);
+                    if (f) return f;
+                  }
+                }
+                return null;
+              };
+              const target = walk(document);
+              if (!target) return null;
+              const out = [];
+              const inner = (root, depth) => {
+                if (depth > 3) return;
+                for (const el of root.children || []) {
+                  const id = el.id ? `#${el.id}` : '';
+                  const cls = (typeof el.className === 'string' && el.className) ? `.${el.className.split(/\s+/).slice(0, 2).join('.')}` : '';
+                  const aria = el.getAttribute?.('aria-label');
+                  out.push(`${'  '.repeat(depth)}<${el.tagName.toLowerCase()}${id}${cls}${aria ? ` aria="${aria.slice(0, 30)}"` : ''}>`);
+                  if (out.length >= 30) return;
+                  if (el.shadowRoot && el.shadowRoot.mode === 'open') {
+                    out.push(`${'  '.repeat(depth)}#shadow-root (open)`);
+                    inner(el.shadowRoot, depth + 1);
+                  } else {
+                    inner(el, depth + 1);
+                  }
+                }
+              };
+              inner(target.shadowRoot || target, 0);
+              return out;
+            }, { tagName });
+            if (dump && dump.length) log('info', `[yt-pw] <${tagName.toLowerCase()}> tree:\n  ${dump.join('\n  ')}`);
+          };
+
+          for (const { tag, why } of targetCandidates) {
+            if (thumbDone) break;
+            // Locate the target element in DOM via shadow walk + get bbox.
+            const targetInfo = await page.evaluate(({ tagName }) => {
+              const walk = (root) => {
+                for (const el of root.querySelectorAll('*')) {
+                  if (el.tagName === tagName) return el;
+                  if (el.shadowRoot && el.shadowRoot.mode === 'open') {
+                    const f = walk(el.shadowRoot);
+                    if (f) return f;
+                  }
+                }
+                return null;
+              };
+              const target = walk(document);
+              if (!target) return null;
+              const r = target.getBoundingClientRect();
+              if (r.width === 0 || r.height === 0) return { found: true, visible: false };
+              return { found: true, visible: true, x: r.x + r.width / 2, y: r.y + r.height / 2 };
+            }, { tagName: tag });
+
+            if (!targetInfo?.found) {
+              log('info', `[yt-pw] thumbnail target <${tag.toLowerCase()}> not in DOM`);
+              continue;
+            }
+            if (!targetInfo.visible) {
+              log('info', `[yt-pw] thumbnail target <${tag.toLowerCase()}> not visible`);
+              continue;
+            }
+
+            // B2: try real CDP mouse click — trusted event.
+            try {
+              const [chooser] = await Promise.all([
+                page.waitForEvent('filechooser', { timeout: 5000 }),
+                page.mouse.click(targetInfo.x, targetInfo.y),
+              ]);
+              await chooser.setFiles(thumbPath);
+              log('info', `[yt-pw] thumbnail set via mouse.click on <${tag.toLowerCase()}> @ (${Math.round(targetInfo.x)},${Math.round(targetInfo.y)}) — ${why}`);
+              thumbDone = true;
+              await page.waitForTimeout(800);
+            } catch (e) {
+              log('info', `[yt-pw] mouse.click on <${tag.toLowerCase()}> did not open picker: ${e.message.slice(0, 80)}`);
+              // Dump children on the last attempted target — so next iteration
+              // can patch selectors knowing exactly what's inside.
+              if (tag === 'YTCP-THUMBNAIL-WITH-TITLE' || tag === 'YTCP-THUMBNAIL') {
+                await dumpShadowChildren(tag).catch(() => {});
+              }
+              if (tag === 'YTCP-THUMBNAIL') {
+                await dumpShadowChildren('YTCP-VIDEO-THUMBNAIL-EDITOR').catch(() => {});
+              }
+            }
+          }
+
+          // Last-resort: also try the legacy CSS selectors in case some Studio
+          // builds DO expose them in light DOM.
+          if (!thumbDone) {
+            const cssTriggers = [
+              "#add-photo-icon",
+              "ytcp-uploads-dialog #add-photo-icon",
+            ];
+            for (const sel of cssTriggers) {
+              if (thumbDone) break;
+              const loc = page.locator(sel).first();
+              if (await loc.count().catch(() => 0) === 0) continue;
+              if (!(await loc.isVisible().catch(() => false))) continue;
+              try {
+                const [chooser] = await Promise.all([
+                  page.waitForEvent('filechooser', { timeout: 5000 }),
+                  loc.click({ timeout: 3000 }),
+                ]);
+                await chooser.setFiles(thumbPath);
+                log('info', `[yt-pw] thumbnail set via CSS ${sel}`);
+                thumbDone = true;
+                await page.waitForTimeout(800);
+              } catch (e) {
+                log('info', `[yt-pw] CSS trigger "${sel}" did not open picker: ${e.message.slice(0, 80)}`);
+              }
+            }
+          }
+        }
+
+        if (!thumbDone) throw new Error('thumbnail upload — no working trigger found; Studio markup changed');
+      } catch (e) {
+        // Re-throw to fail the cmd. Caller (cmd-result mirror) will surface
+        // the message on the idea's publish_results.
+        throw new Error(`thumbnail upload failed: ${e.message}`);
+      }
+    }
+
+    // 7c) Show more (Hiện thêm) → reveals Tags input + other advanced fields.
+    // Toggle button id="toggle-button" with aria="Hiện chế độ cài đặt nâng cao".
+    // Best-effort: if the dialog already had it expanded, skip.
+    const showMoreClicked = await (async () => {
+      const sels = [
+        "ytcp-uploads-dialog #toggle-button",
+        "ytcp-uploads-dialog ytcp-button#toggle-button",
+        "ytcp-uploads-dialog ytcp-button[aria-label*='cài đặt nâng cao']",
+        "ytcp-uploads-dialog ytcp-button[aria-label*='advanced']",
+        "ytcp-uploads-dialog ytcp-button:has-text('Hiện thêm')",
+        "ytcp-uploads-dialog ytcp-button:has-text('Show more')",
+      ];
+      for (const s of sels) {
+        const loc = page.locator(s).first();
+        if (await loc.count().catch(() => 0) === 0) continue;
+        if (!(await loc.isVisible().catch(() => false))) continue;
+        // Don't click again if already expanded — text flips to "Ẩn bớt".
+        const txt = (await loc.innerText().catch(() => '')).toLowerCase();
+        if (/ẩn|fewer|hide/.test(txt)) {
+          log('info', `[yt-pw] advanced settings already expanded`);
+          return true;
+        }
+        try {
+          await loc.click({ timeout: 3000 });
+          await page.waitForTimeout(600);
+          log('info', `[yt-pw] Show more clicked via ${s}`);
+          return true;
+        } catch (e) {
+          log('info', `[yt-pw] Show more click failed via ${s}: ${e.message.slice(0, 80)}`);
+        }
+      }
+      return false;
+    })();
+    // STRICT: if caller sent tags, the advanced section MUST be expanded —
+    // tags are not optional once requested. If no tags requested, skip Show
+    // more entirely (cmd success doesn't depend on it).
+    if (tags?.length && !showMoreClicked) {
+      throw new Error('Show more / advanced settings toggle not found — tags requested but cannot be filled');
+    }
+
+    // 7d) Tags — fill only when caller requested them. STRICT: input must
+    // exist, every tag must be typed (modulo 480-char cap which is YT's own
+    // limit). Silent skipping was hiding selector regressions.
+    if (showMoreClicked && tags?.length) {
+      const tagSelCandidates = [
+        "ytcp-uploads-dialog ytcp-form-input-container[label*='Tag'] input",
+        "ytcp-uploads-dialog ytcp-form-input-container[label*='Thẻ'] input",
+        "ytcp-uploads-dialog ytcp-form-input-container[label*='标签'] input",
+        "ytcp-uploads-dialog ytcp-chip-bar input",
+        "ytcp-uploads-dialog ytcp-video-keywords input",
+        "ytcp-uploads-dialog input[aria-label*='Tag']",
+        "ytcp-uploads-dialog input[aria-label*='Thẻ']",
+      ];
+      let tagInput = null;
+      let usedSel = '';
+      for (const s of tagSelCandidates) {
+        const loc = page.locator(s).first();
+        if (await loc.count().catch(() => 0) > 0 && await loc.isVisible().catch(() => false)) {
+          tagInput = loc;
+          usedSel = s;
+          break;
+        }
+      }
+      if (!tagInput) {
+        throw new Error('tag input not found inside ytcp-uploads-dialog — Studio markup changed; update tagSelCandidates');
+      }
+      log('info', `[yt-pw] tag input found via ${usedSel}`);
+      try {
+        // Chip-bar: each tag added by typing then Enter. YT 500-char cap;
+        // clip with margin to avoid mid-type rejection.
+        let consumed = 0;
+        let filled = 0;
+        for (const raw of tags) {
+          const t = String(raw || '').replace(/[#,]/g, '').trim();
+          if (!t) continue;
+          if (consumed + t.length + 1 > 480) {
+            log('info', `[yt-pw] tag cap reached (~480 chars) — stopping at ${filled}/${tags.length}`);
+            break;
+          }
+          await tagInput.click({ timeout: 2000 });
+          await tagInput.type(t, { delay: 20 });
+          await page.keyboard.press('Enter');
+          consumed += t.length + 1;
+          filled += 1;
+          await page.waitForTimeout(120);
+        }
+        log('info', `[yt-pw] tags filled: ${filled}/${tags.length}, ~${consumed} chars`);
+      } catch (e) {
+        throw new Error(`tags fill failed: ${e.message}`);
+      }
+    }
+
+    // Diagnostic: dump the Details-step DOM once BEFORE Show-more and once
+    // AFTER, so we can see how Studio reveals the tags + advanced inputs.
+    await inspectDetailsForm(page, log);
+    if (showMoreClicked) {
+      log('info', `[yt-pw] details-form inventory (POST show-more):`);
+      await inspectDetailsForm(page, log);
+    }
+
+    // 7b) Audience question — Studio leaves Next disabled until the user
+    // answers "Made for kids? Yes/No". Default to "Not made for kids".
+    await selectNotMadeForKids(page, log);
+
+    // 7b.2) AI/Altered content disclosure — required when the video contains
+    // synthetic / AI-generated content. Our pipeline always uses Veo3 → YES.
+    await selectAlteredContentYes(page, log);
+    // (Removed second dismissOverlays sweep — once the upload modal is open,
+    // its own backdrop trips our gate, and clicking a "Bỏ qua / Skip" button
+    // anywhere on the page CLOSES the modal as a side effect. Dashboard
+    // onboarding gets dismissed only at page-load, before the modal exists.)
+    await jitter(page, 600);
+
+    // 8) Next → Next → Next (3 steps: Details, Video elements, Checks).
+    // First Next can take 1-2 min waiting for Studio's upload-validation step;
+    // later Nexts usually flip enabled within seconds. Poll for actionable.
+    for (let step = 0; step < 3; step++) {
+      let nextBtn;
+      try { nextBtn = await locateButton(page, S.nextButton, { timeoutMs: 15_000 }); }
+      catch (e) { await dumpFailure(page, `next-step${step + 1}-not-found`, log); throw e; }
+      try {
+        await waitAndClick(nextBtn, { timeoutMs: step === 0 ? 180_000 : 30_000, log, label: `Next(${step + 1}/3)` });
+      } catch (e) {
+        await dumpFailure(page, `next-step${step + 1}-not-actionable`, log);
+        throw e;
+      }
+      log('info', `[yt-pw] clicked Next (${step + 1}/3)`);
+      await jitter(page, 1000);
+    }
+
+    // 9) Visibility — Public / Unlisted / Private. STRICT: must be set or
+    // Publish stays at whatever default Studio remembered (last upload's
+    // visibility); silently leaving Public a private upload as Unlisted etc.
+    // is exactly the kind of bypass the user wants to fail loudly.
+    const visSpec = S.visibilityRadio[visibility] || S.visibilityRadio.public;
+    log('info', `[yt-pw] visibility=${visibility}`);
+    try {
+      const visBtn = await locateField(page, visSpec, { timeoutMs: 10_000 });
+      await visBtn.click();
+    } catch (e) {
+      throw new Error(`visibility radio (${visibility}) not clickable: ${e.message}`);
+    }
+    await jitter(page, 600);
+
+    // 10) Publish — waits up to 5 min for upload processing before it enables.
+    log('info', `[yt-pw] waiting for Publish to enable…`);
+    let pubBtn;
+    try { pubBtn = await locateButton(page, S.publishButton, { timeoutMs: 60_000 }); }
+    catch (e) { await dumpFailure(page, 'publish-not-found', log); throw e; }
+    try {
+      await waitAndClick(pubBtn, { timeoutMs: 5 * 60_000, log, label: 'Publish' });
+    } catch (e) {
+      await dumpFailure(page, 'publish-not-actionable', log);
+      throw e;
+    }
+    log('info', `[yt-pw] Publish clicked`);
+
+    // 11) Studio shows a "Video đã xuất bản / Video published" confirmation
+    // dialog after Publish with a share-URL input. Poll for it up to 60s —
+    // initial encode is short for our 8s scenes, so this normally lands in
+    // a few seconds. If we can't find it (Shorts vs Long flow, scheduled, A/B
+    // test), we still return ok=true — the upload itself succeeded.
+    log('info', `[yt-pw] waiting for share URL…`);
+    let postUrl = '';
+
+    // Fast path: did we capture the videoId from a network response earlier?
+    // Take the LAST one observed during the run — that's the upload we just
+    // performed, not an earlier Creators/recommendation tile.
+    const networkIds = payload.__networkVideoIds || [];
+    if (networkIds.length) {
+      const lastId = networkIds[networkIds.length - 1];
+      // Shorts vs long: detect by format param if caller hinted, else default
+      // to /watch?v= (works for both — YT auto-redirects shorts there).
+      const isShorts = String(payload.format || '').toLowerCase().includes('short');
+      postUrl = isShorts ? `https://www.youtube.com/shorts/${lastId}` : `https://www.youtube.com/watch?v=${lastId}`;
+      log('info', `[yt-pw] post URL from network: ${postUrl}`);
+    }
+
+    // Extract a YouTube video URL only if it looks like an actual video link
+    // (youtu.be/<id>, youtube.com/watch?v=<id>, or youtube.com/shorts/<id>).
+    // Reject Studio internal links (studio.youtube.com/...), Creators/marketing
+    // links (youtube.com/creators, /howyoutubeworks, /about, etc.), and channel
+    // pages. Past bug: the published-dialog has a "YouTube Creators" footer
+    // link that the generic a[href*='youtube.com/watch'] selector matched
+    // first, so we returned a marketing URL as the post URL.
+    const looksLikeVideoUrl = (raw) => {
+      if (!raw) return null;
+      const s = String(raw).trim();
+      // studio.* is the editor URL — never the public video.
+      if (/studio\.youtube\.com/i.test(s)) return null;
+      // Creators / marketing / docs / about pages.
+      if (/youtube\.com\/(creators|howyoutubeworks|about|t\/|kids|premium|music)\b/i.test(s)) return null;
+      const m =
+        s.match(/https?:\/\/youtu\.be\/([A-Za-z0-9_-]{8,15})(?:[/?#]|$)/)
+        || s.match(/https?:\/\/(?:www\.|m\.)?youtube\.com\/watch\?[^"\s]*v=([A-Za-z0-9_-]{8,15})/)
+        || s.match(/https?:\/\/(?:www\.|m\.)?youtube\.com\/shorts\/([A-Za-z0-9_-]{8,15})/);
+      return m ? m[0] : null;
+    };
+
+    // Scope the search to the ACTUAL share dialog/card container — never the
+    // entire page. The post-publish surface is always one of these wrappers:
+    //   ytcp-video-info-share-card (newer Studio)
+    //   ytcp-uploads-still-processing-dialog (encoding-in-progress dialog)
+    //   ytcp-video-share / ytcp-video-share-url (older Studio)
+    // Inside that scope, prefer the readonly input (canonical share URL), then
+    // fall back to anchors. The anchor sweep is bounded to the same scope so
+    // marketing links elsewhere on the page can't poison the result.
+    const scopeSelectors = [
+      'ytcp-video-info-share-card',
+      'ytcp-video-share',
+      'ytcp-video-share-url',
+      'ytcp-uploads-still-processing-dialog',
+      // Last-resort fallback — but still must contain a copy-button to count
+      // as a publish dialog, not a stray button somewhere on the page.
+      "ytcp-uploads-dialog ytcp-copy-link, ytcp-uploads-dialog [aria-label*='ideo URL']",
+    ];
+
+    const tryExtract = async () => {
+      for (const scopeSel of scopeSelectors) {
+        const scope = page.locator(scopeSel).first();
+        if (await scope.count().catch(() => 0) === 0) continue;
+        // 1) readonly inputs inside scope
+        const inputs = scope.locator("input[readonly], input[type='url'], textarea[readonly]");
+        const inputCount = Math.min(await inputs.count().catch(() => 0), 4);
+        for (let i = 0; i < inputCount; i++) {
+          const v = await inputs.nth(i).getAttribute('value').catch(() => null);
+          const hit = looksLikeVideoUrl(v);
+          if (hit) return hit;
+        }
+        // 2) anchors inside scope
+        const anchors = scope.locator("a[href]");
+        const anchorCount = Math.min(await anchors.count().catch(() => 0), 6);
+        for (let i = 0; i < anchorCount; i++) {
+          const v = await anchors.nth(i).getAttribute('href').catch(() => null);
+          const hit = looksLikeVideoUrl(v);
+          if (hit) return hit;
+        }
+        // 3) text content (some Studio variants put the URL plain-text in a div)
+        const text = await scope.innerText().catch(() => '');
+        const hit = looksLikeVideoUrl(text);
+        if (hit) return hit;
+      }
+      return null;
+    };
+
+    const urlDeadline = Date.now() + 60_000;
+    while (Date.now() < urlDeadline && !postUrl) {
+      const hit = await tryExtract();
+      if (hit) { postUrl = hit; break; }
+      await page.waitForTimeout(1500);
+    }
+
+    if (postUrl) {
+      log('info', `[yt-pw] post URL: ${postUrl}`);
+    } else {
+      // Last-ditch — sometimes the dialog never appears (scheduled/processing),
+      // but YT writes a recent-upload row to the page. Dump for diagnostics.
+      await dumpFailure(page, 'post-url-not-found', log);
+      log('warn', `[yt-pw] could not extract post URL — upload still considered ok`);
+    }
+
+    // Close the confirmation dialog if any (best-effort — doesn't affect result).
+    try {
+      const closeBtn = await firstVisible(page.locator("ytcp-uploads-still-processing-dialog button, ytcp-video-share + button, button:has-text('Close'), button:has-text('Đóng')"), 3);
+      if (closeBtn) await closeBtn.click({ timeout: 2000 }).catch(() => {});
+    } catch {}
+
+    return {
+      ok: true,
+      title,
+      visibility,
+      post_url: postUrl,
+      video_path_local: videoPath,
+    };
+  } finally {
+    safeUnlink(videoPath);
+    if (thumbPath) safeUnlink(thumbPath);
+  }
+}
+
+module.exports = { run };