@reconcrap/boss-recommend-mcp 2.1.21 → 2.1.23

package/src/domains/recommend/detail.js

@@ -1,54 +1,54 @@
-import {
-  clickNodeCenter,
-  clickPoint,
-  DETERMINISTIC_CLICK_OPTIONS,
-  getFrameDocumentNodeId,
-  getNodeBox,
-  getOuterHTML,
-  pressKey,
-  querySelectorAll,
-  scrollNodeIntoView,
-  sleep
-} from "../../core/browser/index.js";
-import { candidateKeyFromProfile } from "../../core/infinite-list/index.js";
-import {
-  buildScreeningCandidateFromDetail,
-  htmlToText
-} from "../../core/screening/index.js";
-import {
-  closeBossAccountRightsBlockingPanel,
-  findBossAccountRightsBlockingPanel
-} from "../common/account-rights-panel.js";
-import {
-  DETAIL_CLOSE_SELECTORS,
-  DETAIL_NETWORK_PATTERNS,
-  DETAIL_POPUP_SELECTORS,
-  DETAIL_RESUME_IFRAME_SELECTORS,
-  RECOMMEND_AVATAR_PREVIEW_CLOSE_SELECTORS,
-  RECOMMEND_AVATAR_PREVIEW_SELECTORS
-} from "./constants.js";
+import {
+  clickNodeCenter,
+  clickPoint,
+  DETERMINISTIC_CLICK_OPTIONS,
+  getFrameDocumentNodeId,
+  getNodeBox,
+  getOuterHTML,
+  pressKey,
+  querySelectorAll,
+  scrollNodeIntoView,
+  sleep
+} from "../../core/browser/index.js";
+import { candidateKeyFromProfile } from "../../core/infinite-list/index.js";
+import {
+  buildScreeningCandidateFromDetail,
+  htmlToText
+} from "../../core/screening/index.js";
+import {
+  closeBossAccountRightsBlockingPanel,
+  findBossAccountRightsBlockingPanel
+} from "../common/account-rights-panel.js";
+import {
+  DETAIL_CLOSE_SELECTORS,
+  DETAIL_NETWORK_PATTERNS,
+  DETAIL_POPUP_SELECTORS,
+  DETAIL_RESUME_IFRAME_SELECTORS,
+  RECOMMEND_AVATAR_PREVIEW_CLOSE_SELECTORS,
+  RECOMMEND_AVATAR_PREVIEW_SELECTORS
+} from "./constants.js";
 import {
   getRecommendRoots
 } from "./roots.js";
-import {
-  findRecommendCardNodeIds,
-  readRecommendCardCandidate
-} from "./cards.js";
-
-const DETAIL_OUTSIDE_CLOSE_BOUNDARY_SELECTORS = Object.freeze([
-  ".resume-center-side .resume-detail-wrap",
-  ".resume-detail-wrap",
-  ".boss-popup__wrapper .boss-popup__body",
-  ".boss-popup__wrapper .dialog-body",
-  ".dialog-wrap.active .resume-detail-wrap",
-  ".geek-detail-modal .resume-detail-wrap"
-]);
-
-export function matchesRecommendDetailNetwork(url) {
+import {
+  findRecommendCardNodeIds,
+  readRecommendCardCandidate
+} from "./cards.js";
+
+const DETAIL_OUTSIDE_CLOSE_BOUNDARY_SELECTORS = Object.freeze([
+  ".resume-center-side .resume-detail-wrap",
+  ".resume-detail-wrap",
+  ".boss-popup__wrapper .boss-popup__body",
+  ".boss-popup__wrapper .dialog-body",
+  ".dialog-wrap.active .resume-detail-wrap",
+  ".geek-detail-modal .resume-detail-wrap"
+]);
+
+export function matchesRecommendDetailNetwork(url) {
   return DETAIL_NETWORK_PATTERNS.some((pattern) => pattern.test(String(url || "")));
 }
 
-export function createRecommendDetailNetworkRecorder(client) {
+export function createRecommendDetailNetworkRecorder(client) {
   const events = [];
   client.Network.responseReceived((event) => {
     const url = event?.response?.url || "";
@@ -83,29 +83,29 @@ export function createRecommendDetailNetworkRecorder(client) {
       events.length = 0;
     }
   };
-}
-
-export async function findRecommendBlockingPanel(client, options = {}) {
-  return findBossAccountRightsBlockingPanel(client, options);
-}
-
-export async function closeRecommendBlockingPanels(client, options = {}) {
-  return closeBossAccountRightsBlockingPanel(client, {
-    resolveRoots: getRecommendRoots,
-    ...options
-  });
-}
-
-function looksLikeRecommendAvatarPreviewHtml(html = "") {
-  return /\bavatar-preview\b|\bfigure-preview\b/i.test(String(html || ""));
-}
-
-function isRecommendAvatarPreviewOpenError(error) {
-  return error?.code === "RECOMMEND_AVATAR_PREVIEW_OPENED"
-    || /RECOMMEND_AVATAR_PREVIEW_OPENED/i.test(String(error?.message || error || ""));
-}
-
-export async function waitForRecommendDetailNetworkEvents(recorder, {
+}
+
+export async function findRecommendBlockingPanel(client, options = {}) {
+  return findBossAccountRightsBlockingPanel(client, options);
+}
+
+export async function closeRecommendBlockingPanels(client, options = {}) {
+  return closeBossAccountRightsBlockingPanel(client, {
+    resolveRoots: getRecommendRoots,
+    ...options
+  });
+}
+
+function looksLikeRecommendAvatarPreviewHtml(html = "") {
+  return /\bavatar-preview\b|\bfigure-preview\b/i.test(String(html || ""));
+}
+
+function isRecommendAvatarPreviewOpenError(error) {
+  return error?.code === "RECOMMEND_AVATAR_PREVIEW_OPENED"
+    || /RECOMMEND_AVATAR_PREVIEW_OPENED/i.test(String(error?.message || error || ""));
+}
+
+export async function waitForRecommendDetailNetworkEvents(recorder, {
   minCount = 1,
   requireLoaded = true,
   timeoutMs = 3500,
@@ -175,10 +175,10 @@ export async function waitForRecommendDetail(client, {
   return lastState;
 }
 
-async function readRecommendDetailState(client) {
-  const rootState = await getRecommendRoots(client);
-  const popup = await findVisibleDetailTarget(client, rootState.roots, DETAIL_POPUP_SELECTORS);
-  const resumeIframe = await findVisibleDetailTarget(client, rootState.roots, DETAIL_RESUME_IFRAME_SELECTORS);
+async function readRecommendDetailState(client) {
+  const rootState = await getRecommendRoots(client);
+  const popup = await findVisibleDetailTarget(client, rootState.roots, DETAIL_POPUP_SELECTORS);
+  const resumeIframe = await findVisibleDetailTarget(client, rootState.roots, DETAIL_RESUME_IFRAME_SELECTORS);
   return {
     iframe: rootState.iframe,
     roots: rootState.roots,
@@ -187,10 +187,10 @@ async function readRecommendDetailState(client) {
   };
 }
 
-export async function waitForRecommendDetailClosed(client, {
-  timeoutMs = 4000,
-  intervalMs = 250
-} = {}) {
+export async function waitForRecommendDetailClosed(client, {
+  timeoutMs = 4000,
+  intervalMs = 250
+} = {}) {
   const started = Date.now();
   let lastState = null;
   while (Date.now() - started <= timeoutMs) {
@@ -208,126 +208,126 @@ export async function waitForRecommendDetailClosed(client, {
     closed: false,
     elapsed_ms: Date.now() - started,
     state: lastState
-  };
-}
-
-export async function readRecommendAvatarPreviewState(client) {
-  const rootState = await getRecommendRoots(client);
-  const topRoot = rootState.rootNodes?.top
-    ? [{ name: "top", nodeId: rootState.rootNodes.top }]
-    : rootState.roots.filter((root) => root?.name === "top");
-  const preview = await findVisibleDetailTarget(client, topRoot, RECOMMEND_AVATAR_PREVIEW_SELECTORS, {
-    includeAvatarPreview: true
-  });
-  return {
-    open: Boolean(preview),
-    root: rootState.topRoot,
-    roots: topRoot,
-    preview
-  };
-}
-
-export async function waitForRecommendAvatarPreviewClosed(client, {
-  timeoutMs = 1200,
-  intervalMs = 120
-} = {}) {
-  const started = Date.now();
-  let state = null;
-  while (Date.now() - started <= timeoutMs) {
-    state = await readRecommendAvatarPreviewState(client);
-    if (!state.open) {
-      return {
-        closed: true,
-        elapsed_ms: Date.now() - started,
-        state
-      };
-    }
-    await sleep(intervalMs);
-  }
-  return {
-    closed: false,
-    elapsed_ms: Date.now() - started,
-    state
-  };
-}
-
-function compactRect(rect) {
-  if (!rect) return null;
-  return {
-    x: Math.round(Number(rect.x) || 0),
-    y: Math.round(Number(rect.y) || 0),
-    width: Math.round(Number(rect.width) || 0),
-    height: Math.round(Number(rect.height) || 0)
-  };
-}
-
-function compactDetailTarget(target) {
-  if (!target) return null;
-  return {
-    root: target.root || "",
-    root_node_id: target.root_node_id || null,
-    selector: target.selector || "",
-    node_id: target.node_id || null,
-    rect: compactRect(target.rect)
-  };
-}
-
-function compactDetailOpenState(state) {
-  if (!state) {
-    return {
-      open: false,
-      popup: null,
-      resume_iframe: null,
-      iframe_document_node_id: null
-    };
-  }
-  return {
-    open: Boolean(state.popup || state.resumeIframe),
-    popup: compactDetailTarget(state.popup),
-    resume_iframe: compactDetailTarget(state.resumeIframe),
-    iframe_document_node_id: state.iframe?.documentNodeId || null
-  };
-}
-
-async function verifyRecommendDetailStillOpen(client, {
-  settleMs = 350
-} = {}) {
-  const firstState = await readRecommendDetailState(client);
-  if (settleMs > 0) await sleep(settleMs);
-  const secondState = await readRecommendDetailState(client);
-  const first = compactDetailOpenState(firstState);
-  const second = compactDetailOpenState(secondState);
-  const stableOpen = Boolean(first.open && second.open);
-  return {
-    open: Boolean(second.open),
-    stable_open: stableOpen,
-    first,
-    second
-  };
-}
-
-async function findVisibleDetailTarget(client, roots, selectors, {
-  includeAvatarPreview = false
-} = {}) {
-  for (const root of roots) {
-    if (!root?.nodeId) continue;
-    for (const selector of selectors) {
-      const nodeIds = await querySelectorAll(client, root.nodeId, selector);
-      for (const nodeId of nodeIds) {
-        try {
-          const box = await getNodeBox(client, nodeId);
-          if (box.rect.width > 2 && box.rect.height > 2) {
-            if (!includeAvatarPreview) {
-              try {
-                const html = await getOuterHTML(client, nodeId);
-                if (looksLikeRecommendAvatarPreviewHtml(html)) continue;
-              } catch {
-                // If the node went stale, let the next candidate decide.
-              }
-            }
-            return {
-              root: root.name,
-              root_node_id: root.nodeId,
+  };
+}
+
+export async function readRecommendAvatarPreviewState(client) {
+  const rootState = await getRecommendRoots(client);
+  const topRoot = rootState.rootNodes?.top
+    ? [{ name: "top", nodeId: rootState.rootNodes.top }]
+    : rootState.roots.filter((root) => root?.name === "top");
+  const preview = await findVisibleDetailTarget(client, topRoot, RECOMMEND_AVATAR_PREVIEW_SELECTORS, {
+    includeAvatarPreview: true
+  });
+  return {
+    open: Boolean(preview),
+    root: rootState.topRoot,
+    roots: topRoot,
+    preview
+  };
+}
+
+export async function waitForRecommendAvatarPreviewClosed(client, {
+  timeoutMs = 1200,
+  intervalMs = 120
+} = {}) {
+  const started = Date.now();
+  let state = null;
+  while (Date.now() - started <= timeoutMs) {
+    state = await readRecommendAvatarPreviewState(client);
+    if (!state.open) {
+      return {
+        closed: true,
+        elapsed_ms: Date.now() - started,
+        state
+      };
+    }
+    await sleep(intervalMs);
+  }
+  return {
+    closed: false,
+    elapsed_ms: Date.now() - started,
+    state
+  };
+}
+
+function compactRect(rect) {
+  if (!rect) return null;
+  return {
+    x: Math.round(Number(rect.x) || 0),
+    y: Math.round(Number(rect.y) || 0),
+    width: Math.round(Number(rect.width) || 0),
+    height: Math.round(Number(rect.height) || 0)
+  };
+}
+
+function compactDetailTarget(target) {
+  if (!target) return null;
+  return {
+    root: target.root || "",
+    root_node_id: target.root_node_id || null,
+    selector: target.selector || "",
+    node_id: target.node_id || null,
+    rect: compactRect(target.rect)
+  };
+}
+
+function compactDetailOpenState(state) {
+  if (!state) {
+    return {
+      open: false,
+      popup: null,
+      resume_iframe: null,
+      iframe_document_node_id: null
+    };
+  }
+  return {
+    open: Boolean(state.popup || state.resumeIframe),
+    popup: compactDetailTarget(state.popup),
+    resume_iframe: compactDetailTarget(state.resumeIframe),
+    iframe_document_node_id: state.iframe?.documentNodeId || null
+  };
+}
+
+async function verifyRecommendDetailStillOpen(client, {
+  settleMs = 350
+} = {}) {
+  const firstState = await readRecommendDetailState(client);
+  if (settleMs > 0) await sleep(settleMs);
+  const secondState = await readRecommendDetailState(client);
+  const first = compactDetailOpenState(firstState);
+  const second = compactDetailOpenState(secondState);
+  const stableOpen = Boolean(first.open && second.open);
+  return {
+    open: Boolean(second.open),
+    stable_open: stableOpen,
+    first,
+    second
+  };
+}
+
+async function findVisibleDetailTarget(client, roots, selectors, {
+  includeAvatarPreview = false
+} = {}) {
+  for (const root of roots) {
+    if (!root?.nodeId) continue;
+    for (const selector of selectors) {
+      const nodeIds = await querySelectorAll(client, root.nodeId, selector);
+      for (const nodeId of nodeIds) {
+        try {
+          const box = await getNodeBox(client, nodeId);
+          if (box.rect.width > 2 && box.rect.height > 2) {
+            if (!includeAvatarPreview) {
+              try {
+                const html = await getOuterHTML(client, nodeId);
+                if (looksLikeRecommendAvatarPreviewHtml(html)) continue;
+              } catch {
+                // If the node went stale, let the next candidate decide.
+              }
+            }
+            return {
+              root: root.name,
+              root_node_id: root.nodeId,
               selector,
               node_id: nodeId,
               center: box.center,
@@ -388,113 +388,122 @@ export async function readRecommendDetailHtml(client, detailState) {
 }
 
 export function isStaleRecommendNodeError(error) {
-  const message = String(error?.message || error || "");
-  return /Could not find node with given id|No node with given id|Node is detached|Cannot find node|Could not compute box model/i.test(message);
-}
-
-export function isRecommendDetailOpenMissError(error) {
-  const message = String(error?.message || error || "");
-  return isRecommendAvatarPreviewOpenError(error)
-    || /Candidate detail did not open|no known detail selectors mounted/i.test(message);
-}
-
-export function resolveRecommendCardDetailClickPoint(cardBox, {
-  attemptIndex = 0
-} = {}) {
-  const rect = cardBox?.rect || {};
-  const width = Number(rect.width) || 0;
-  const height = Number(rect.height) || 0;
-  if (width <= 2 || height <= 2) {
-    return {
-      ...(cardBox?.center || { x: 0, y: 0 }),
-      mode: "card-center-fallback",
-      reason: "invalid_card_rect"
-    };
-  }
-
-  const xFractions = [0.22, 0.50, 0.72];
-  const xFraction = xFractions[Math.min(Math.max(0, attemptIndex), xFractions.length - 1)];
-  const minOffsetX = Math.min(width - 12, Math.max(110, Math.min(180, width * 0.18)));
-  const maxOffsetX = Math.max(minOffsetX, width - Math.min(220, Math.max(90, width * 0.22)));
-  const rawOffsetX = width * xFraction;
-  const offsetX = clampPointCoordinate(rawOffsetX, minOffsetX, maxOffsetX);
-  const offsetY = clampPointCoordinate(height * 0.28, Math.min(34, height / 2), Math.max(36, height - 28));
-  return {
-    x: rect.x + offsetX,
-    y: rect.y + offsetY,
-    mode: "card-body-safe-point",
-    attempt_index: attemptIndex,
-    offset_x: Math.round(offsetX),
-    offset_y: Math.round(offsetY)
-  };
-}
-
-async function clickRecommendCardDetailPoint(client, nodeId, {
-  scrollIntoView = true,
-  attemptIndex = 0
-} = {}) {
-  if (scrollIntoView) {
-    try {
-      await scrollNodeIntoView(client, nodeId);
-      await sleep(150);
-    } catch {
-      // Recommend list cards are selected from visible nodes; if this CDP
-      // helper races the virtual list, let the box lookup/retry decide.
-    }
+  const pattern = /Could not find node with given id|No node with given id|Node is detached|Cannot find node|Could not compute box model/i;
+  const seen = new Set();
+  let current = error;
+  for (let depth = 0; current && depth < 5; depth += 1) {
+    if ((typeof current === "object" || typeof current === "function") && seen.has(current)) break;
+    if (typeof current === "object" || typeof current === "function") seen.add(current);
+    const message = String(current?.message || current || "");
+    if (pattern.test(message)) return true;
+    current = current?.cause || null;
   }
-  const box = await getNodeBox(client, nodeId);
-  const clickTarget = resolveRecommendCardDetailClickPoint(box, { attemptIndex });
-  const clickResult = await clickPoint(client, clickTarget.x, clickTarget.y, DETERMINISTIC_CLICK_OPTIONS);
-  return {
-    ...box,
-    click_target: clickTarget,
-    click_result: clickResult
-  };
+  return false;
 }
-
-async function waitForRecommendDetailOpenOutcome(client, {
-  timeoutMs = 10000,
-  intervalMs = 250
-} = {}) {
-  const started = Date.now();
-  let detailState = null;
-  let avatarPreview = null;
-  while (Date.now() - started <= timeoutMs) {
-    detailState = await readRecommendDetailState(client);
-    if (detailState?.popup || detailState?.resumeIframe) {
-      return {
-        kind: "detail",
-        elapsed_ms: Date.now() - started,
-        detail_state: detailState
-      };
-    }
-    avatarPreview = await readRecommendAvatarPreviewState(client);
-    if (avatarPreview.open) {
-      return {
-        kind: "avatar_preview",
-        elapsed_ms: Date.now() - started,
-        avatar_preview: avatarPreview
-      };
-    }
-    await sleep(intervalMs);
-  }
-  return {
-    kind: "none",
-    elapsed_ms: Date.now() - started,
-    detail_state: detailState,
-    avatar_preview: avatarPreview
-  };
-}
-
-function makeRecommendAvatarPreviewOpenedError(outcome, clickAttempts = []) {
-  const error = new Error("RECOMMEND_AVATAR_PREVIEW_OPENED: candidate avatar preview opened instead of resume detail");
-  error.code = "RECOMMEND_AVATAR_PREVIEW_OPENED";
-  error.avatar_preview = outcome?.avatar_preview || null;
-  error.click_attempts = clickAttempts;
-  return error;
-}
-
-export async function findRecommendCardNodeForCandidateKey(client, {
+
+export function isRecommendDetailOpenMissError(error) {
+  const message = String(error?.message || error || "");
+  return isRecommendAvatarPreviewOpenError(error)
+    || /Candidate detail did not open|no known detail selectors mounted/i.test(message);
+}
+
+export function resolveRecommendCardDetailClickPoint(cardBox, {
+  attemptIndex = 0
+} = {}) {
+  const rect = cardBox?.rect || {};
+  const width = Number(rect.width) || 0;
+  const height = Number(rect.height) || 0;
+  if (width <= 2 || height <= 2) {
+    return {
+      ...(cardBox?.center || { x: 0, y: 0 }),
+      mode: "card-center-fallback",
+      reason: "invalid_card_rect"
+    };
+  }
+
+  const xFractions = [0.22, 0.50, 0.72];
+  const xFraction = xFractions[Math.min(Math.max(0, attemptIndex), xFractions.length - 1)];
+  const minOffsetX = Math.min(width - 12, Math.max(110, Math.min(180, width * 0.18)));
+  const maxOffsetX = Math.max(minOffsetX, width - Math.min(220, Math.max(90, width * 0.22)));
+  const rawOffsetX = width * xFraction;
+  const offsetX = clampPointCoordinate(rawOffsetX, minOffsetX, maxOffsetX);
+  const offsetY = clampPointCoordinate(height * 0.28, Math.min(34, height / 2), Math.max(36, height - 28));
+  return {
+    x: rect.x + offsetX,
+    y: rect.y + offsetY,
+    mode: "card-body-safe-point",
+    attempt_index: attemptIndex,
+    offset_x: Math.round(offsetX),
+    offset_y: Math.round(offsetY)
+  };
+}
+
+async function clickRecommendCardDetailPoint(client, nodeId, {
+  scrollIntoView = true,
+  attemptIndex = 0
+} = {}) {
+  if (scrollIntoView) {
+    try {
+      await scrollNodeIntoView(client, nodeId);
+      await sleep(150);
+    } catch {
+      // Recommend list cards are selected from visible nodes; if this CDP
+      // helper races the virtual list, let the box lookup/retry decide.
+    }
+  }
+  const box = await getNodeBox(client, nodeId);
+  const clickTarget = resolveRecommendCardDetailClickPoint(box, { attemptIndex });
+  const clickResult = await clickPoint(client, clickTarget.x, clickTarget.y, DETERMINISTIC_CLICK_OPTIONS);
+  return {
+    ...box,
+    click_target: clickTarget,
+    click_result: clickResult
+  };
+}
+
+async function waitForRecommendDetailOpenOutcome(client, {
+  timeoutMs = 10000,
+  intervalMs = 250
+} = {}) {
+  const started = Date.now();
+  let detailState = null;
+  let avatarPreview = null;
+  while (Date.now() - started <= timeoutMs) {
+    detailState = await readRecommendDetailState(client);
+    if (detailState?.popup || detailState?.resumeIframe) {
+      return {
+        kind: "detail",
+        elapsed_ms: Date.now() - started,
+        detail_state: detailState
+      };
+    }
+    avatarPreview = await readRecommendAvatarPreviewState(client);
+    if (avatarPreview.open) {
+      return {
+        kind: "avatar_preview",
+        elapsed_ms: Date.now() - started,
+        avatar_preview: avatarPreview
+      };
+    }
+    await sleep(intervalMs);
+  }
+  return {
+    kind: "none",
+    elapsed_ms: Date.now() - started,
+    detail_state: detailState,
+    avatar_preview: avatarPreview
+  };
+}
+
+function makeRecommendAvatarPreviewOpenedError(outcome, clickAttempts = []) {
+  const error = new Error("RECOMMEND_AVATAR_PREVIEW_OPENED: candidate avatar preview opened instead of resume detail");
+  error.code = "RECOMMEND_AVATAR_PREVIEW_OPENED";
+  error.avatar_preview = outcome?.avatar_preview || null;
+  error.click_attempts = clickAttempts;
+  return error;
+}
+
+export async function findRecommendCardNodeForCandidateKey(client, {
   candidateKey = "",
   rootState = null,
   targetUrl = "",
@@ -524,17 +533,17 @@ export async function findRecommendCardNodeForCandidateKey(client, {
       };
     }
 
-    let nodeIds = [];
-    try {
-      nodeIds = await findRecommendCardNodeIds(client, frameNodeId);
-    } catch (error) {
-      lastError = error;
-      if (!isStaleRecommendNodeError(error)) throw error;
-      rootState = null;
-      if (intervalMs > 0) await sleep(intervalMs);
-      continue;
-    }
-    lastCardCount = nodeIds.length;
+    let nodeIds = [];
+    try {
+      nodeIds = await findRecommendCardNodeIds(client, frameNodeId);
+    } catch (error) {
+      lastError = error;
+      if (!isStaleRecommendNodeError(error)) throw error;
+      rootState = null;
+      if (intervalMs > 0) await sleep(intervalMs);
+      continue;
+    }
+    lastCardCount = nodeIds.length;
     for (let visibleIndex = 0; visibleIndex < nodeIds.length; visibleIndex += 1) {
       const nodeId = nodeIds[visibleIndex];
       try {
@@ -580,71 +589,71 @@ export async function findRecommendCardNodeForCandidateKey(client, {
   };
 }
 
-export async function openRecommendCardDetail(client, cardNodeId, {
-  timeoutMs = 12000,
-  scrollIntoView = true
-} = {}) {
-  const started = Date.now();
-  const clickAttempts = [];
-  const maxClickAttempts = 3;
-  let lastOutcome = null;
-  let lastCardBox = null;
-  let candidateClickMs = 0;
-  let detailOpenMs = 0;
-
-  for (let attemptIndex = 0; attemptIndex < maxClickAttempts; attemptIndex += 1) {
-    const clickStarted = Date.now();
-    lastCardBox = await clickRecommendCardDetailPoint(client, cardNodeId, {
-      scrollIntoView: attemptIndex === 0 ? scrollIntoView : false,
-      attemptIndex
-    });
-    candidateClickMs += Date.now() - clickStarted;
-    const detailStarted = Date.now();
-    lastOutcome = await waitForRecommendDetailOpenOutcome(client, {
-      timeoutMs: attemptIndex === 0 ? timeoutMs : Math.max(2500, Math.floor(timeoutMs / 3)),
-      intervalMs: 250
-    });
-    detailOpenMs += Date.now() - detailStarted;
-    clickAttempts.push({
-      attempt: attemptIndex + 1,
-      click_target: lastCardBox.click_target,
-      click_result: lastCardBox.click_result,
-      outcome: lastOutcome.kind,
-      elapsed_ms: lastOutcome.elapsed_ms
-    });
-
-    if (lastOutcome.kind === "detail") {
-      return {
-        card_box: lastCardBox,
-        click_attempts: clickAttempts,
-        detail_state: lastOutcome.detail_state,
-        timings: {
-          candidate_click_ms: candidateClickMs,
-          detail_open_ms: detailOpenMs,
-          open_total_ms: Date.now() - started
-        }
-      };
-    }
-
-    if (lastOutcome.kind === "avatar_preview") {
-      await closeRecommendAvatarPreview(client, { attemptsLimit: 2, waitMs: 350 });
-      throw makeRecommendAvatarPreviewOpenedError(lastOutcome, clickAttempts);
-    }
-    break;
-  }
-
-  if (lastOutcome?.kind === "avatar_preview") {
-    throw makeRecommendAvatarPreviewOpenedError(lastOutcome, clickAttempts);
-  }
-  const error = new Error("Candidate detail did not open or no known detail selectors mounted");
-  error.click_attempts = clickAttempts;
-  error.last_open_outcome = lastOutcome;
-  throw error;
-}
+export async function openRecommendCardDetail(client, cardNodeId, {
+  timeoutMs = 12000,
+  scrollIntoView = true
+} = {}) {
+  const started = Date.now();
+  const clickAttempts = [];
+  const maxClickAttempts = 3;
+  let lastOutcome = null;
+  let lastCardBox = null;
+  let candidateClickMs = 0;
+  let detailOpenMs = 0;
+
+  for (let attemptIndex = 0; attemptIndex < maxClickAttempts; attemptIndex += 1) {
+    const clickStarted = Date.now();
+    lastCardBox = await clickRecommendCardDetailPoint(client, cardNodeId, {
+      scrollIntoView: attemptIndex === 0 ? scrollIntoView : false,
+      attemptIndex
+    });
+    candidateClickMs += Date.now() - clickStarted;
+    const detailStarted = Date.now();
+    lastOutcome = await waitForRecommendDetailOpenOutcome(client, {
+      timeoutMs: attemptIndex === 0 ? timeoutMs : Math.max(2500, Math.floor(timeoutMs / 3)),
+      intervalMs: 250
+    });
+    detailOpenMs += Date.now() - detailStarted;
+    clickAttempts.push({
+      attempt: attemptIndex + 1,
+      click_target: lastCardBox.click_target,
+      click_result: lastCardBox.click_result,
+      outcome: lastOutcome.kind,
+      elapsed_ms: lastOutcome.elapsed_ms
+    });
 
-export async function openRecommendCardDetailWithFreshRetry(client, {
-  cardNodeId,
-  candidateKey = "",
+    if (lastOutcome.kind === "detail") {
+      return {
+        card_box: lastCardBox,
+        click_attempts: clickAttempts,
+        detail_state: lastOutcome.detail_state,
+        timings: {
+          candidate_click_ms: candidateClickMs,
+          detail_open_ms: detailOpenMs,
+          open_total_ms: Date.now() - started
+        }
+      };
+    }
+
+    if (lastOutcome.kind === "avatar_preview") {
+      await closeRecommendAvatarPreview(client, { attemptsLimit: 2, waitMs: 350 });
+      throw makeRecommendAvatarPreviewOpenedError(lastOutcome, clickAttempts);
+    }
+    break;
+  }
+
+  if (lastOutcome?.kind === "avatar_preview") {
+    throw makeRecommendAvatarPreviewOpenedError(lastOutcome, clickAttempts);
+  }
+  const error = new Error("Candidate detail did not open or no known detail selectors mounted");
+  error.click_attempts = clickAttempts;
+  error.last_open_outcome = lastOutcome;
+  throw error;
+}
+
+export async function openRecommendCardDetailWithFreshRetry(client, {
+  cardNodeId,
+  candidateKey = "",
   cardCandidate = null,
   rootState = null,
   targetUrl = "",
@@ -672,20 +681,20 @@ export async function openRecommendCardDetailWithFreshRetry(client, {
         card_candidate: currentCandidate,
         retry_attempts: attempts
       };
-    } catch (error) {
-      const stale = isStaleRecommendNodeError(error);
-      const detailOpenMiss = isRecommendDetailOpenMissError(error);
-      attempts.push({
-        attempt: attemptIndex + 1,
-        node_id: currentNodeId,
-        stale_node: stale,
-        detail_open_miss: detailOpenMiss,
-        error: error?.message || String(error)
-      });
-      if ((!stale && !detailOpenMiss) || attemptIndex >= limit - 1 || !candidateKey) {
-        error.recommend_detail_open_attempts = attempts;
-        throw error;
-      }
+    } catch (error) {
+      const stale = isStaleRecommendNodeError(error);
+      const detailOpenMiss = isRecommendDetailOpenMissError(error);
+      attempts.push({
+        attempt: attemptIndex + 1,
+        node_id: currentNodeId,
+        stale_node: stale,
+        detail_open_miss: detailOpenMiss,
+        error: error?.message || String(error)
+      });
+      if ((!stale && !detailOpenMiss) || attemptIndex >= limit - 1 || !candidateKey) {
+        error.recommend_detail_open_attempts = attempts;
+        throw error;
+      }
 
       const resolved = await findRecommendCardNodeForCandidateKey(client, {
         candidateKey,
@@ -711,100 +720,100 @@ export async function openRecommendCardDetailWithFreshRetry(client, {
       currentRootState = resolved.root_state || null;
     }
   }
-
-  throw new Error("Recommend detail retry exhausted");
-}
-
-export async function closeRecommendAvatarPreview(client, {
-  attemptsLimit = 2,
-  waitMs = 500
-} = {}) {
-  const attempts = [];
-  for (let index = 0; index < attemptsLimit; index += 1) {
-    const state = await readRecommendAvatarPreviewState(client);
-    if (!state.open) {
-      return {
-        closed: true,
-        already_closed: true,
-        attempts
-      };
-    }
-
-    const closeTarget = await findVisibleCloseTarget(client, state.roots, RECOMMEND_AVATAR_PREVIEW_CLOSE_SELECTORS);
-    if (closeTarget) {
-      try {
-        if (closeTarget.center) {
-          await clickPoint(client, closeTarget.center.x, closeTarget.center.y, DETERMINISTIC_CLICK_OPTIONS);
-        } else {
-          await clickNodeCenter(client, closeTarget.node_id, DETERMINISTIC_CLICK_OPTIONS);
-        }
-        attempts.push({
-          mode: "avatar-preview-close-selector",
-          selector: closeTarget.selector,
-          root: closeTarget.root
-        });
-      } catch (error) {
-        attempts.push({
-          mode: "avatar-preview-close-selector-error",
-          selector: closeTarget.selector,
-          root: closeTarget.root,
-          error: error?.message || String(error)
-        });
-      }
-    } else {
-      await pressEscape(client);
-      attempts.push({ mode: "avatar-preview-Escape" });
-    }
-
-    const closed = await waitForRecommendAvatarPreviewClosed(client, {
-      timeoutMs: waitMs,
-      intervalMs: 100
-    });
-    attempts.push({
-      mode: "wait-avatar-preview-closed",
-      closed: closed.closed,
-      elapsed_ms: closed.elapsed_ms
-    });
-    if (closed.closed) {
-      return {
-        closed: true,
-        already_closed: false,
-        attempts
-      };
-    }
-
-    await pressEscape(client);
-    attempts.push({ mode: "avatar-preview-Escape-fallback" });
-    const closedAfterEscape = await waitForRecommendAvatarPreviewClosed(client, {
-      timeoutMs: waitMs,
-      intervalMs: 100
-    });
-    attempts.push({
-      mode: "wait-avatar-preview-closed-after-escape",
-      closed: closedAfterEscape.closed,
-      elapsed_ms: closedAfterEscape.elapsed_ms
-    });
-    if (closedAfterEscape.closed) {
-      return {
-        closed: true,
-        already_closed: false,
-        attempts
-      };
-    }
-  }
-
-  const state = await readRecommendAvatarPreviewState(client);
-  return {
-    closed: !state.open,
-    already_closed: false,
-    reason: state.open ? "avatar_preview_still_visible_after_close_attempts" : null,
-    attempts,
-    state
-  };
-}
-
-export async function closeRecommendDetail(client, {
-  attemptsLimit = 4,
+
+  throw new Error("Recommend detail retry exhausted");
+}
+
+export async function closeRecommendAvatarPreview(client, {
+  attemptsLimit = 2,
+  waitMs = 500
+} = {}) {
+  const attempts = [];
+  for (let index = 0; index < attemptsLimit; index += 1) {
+    const state = await readRecommendAvatarPreviewState(client);
+    if (!state.open) {
+      return {
+        closed: true,
+        already_closed: true,
+        attempts
+      };
+    }
+
+    const closeTarget = await findVisibleCloseTarget(client, state.roots, RECOMMEND_AVATAR_PREVIEW_CLOSE_SELECTORS);
+    if (closeTarget) {
+      try {
+        if (closeTarget.center) {
+          await clickPoint(client, closeTarget.center.x, closeTarget.center.y, DETERMINISTIC_CLICK_OPTIONS);
+        } else {
+          await clickNodeCenter(client, closeTarget.node_id, DETERMINISTIC_CLICK_OPTIONS);
+        }
+        attempts.push({
+          mode: "avatar-preview-close-selector",
+          selector: closeTarget.selector,
+          root: closeTarget.root
+        });
+      } catch (error) {
+        attempts.push({
+          mode: "avatar-preview-close-selector-error",
+          selector: closeTarget.selector,
+          root: closeTarget.root,
+          error: error?.message || String(error)
+        });
+      }
+    } else {
+      await pressEscape(client);
+      attempts.push({ mode: "avatar-preview-Escape" });
+    }
+
+    const closed = await waitForRecommendAvatarPreviewClosed(client, {
+      timeoutMs: waitMs,
+      intervalMs: 100
+    });
+    attempts.push({
+      mode: "wait-avatar-preview-closed",
+      closed: closed.closed,
+      elapsed_ms: closed.elapsed_ms
+    });
+    if (closed.closed) {
+      return {
+        closed: true,
+        already_closed: false,
+        attempts
+      };
+    }
+
+    await pressEscape(client);
+    attempts.push({ mode: "avatar-preview-Escape-fallback" });
+    const closedAfterEscape = await waitForRecommendAvatarPreviewClosed(client, {
+      timeoutMs: waitMs,
+      intervalMs: 100
+    });
+    attempts.push({
+      mode: "wait-avatar-preview-closed-after-escape",
+      closed: closedAfterEscape.closed,
+      elapsed_ms: closedAfterEscape.elapsed_ms
+    });
+    if (closedAfterEscape.closed) {
+      return {
+        closed: true,
+        already_closed: false,
+        attempts
+      };
+    }
+  }
+
+  const state = await readRecommendAvatarPreviewState(client);
+  return {
+    closed: !state.open,
+    already_closed: false,
+    reason: state.open ? "avatar_preview_still_visible_after_close_attempts" : null,
+    attempts,
+    state
+  };
+}
+
+export async function closeRecommendDetail(client, {
+  attemptsLimit = 4,
   closeWaitMs = 5000,
   escapeWaitMs = 3500
 } = {}) {
@@ -822,11 +831,11 @@ export async function closeRecommendDetail(client, {
     const closeTarget = await findVisibleCloseTarget(client, rootState.roots, DETAIL_CLOSE_SELECTORS);
     if (closeTarget) {
       try {
-        if (closeTarget.center) {
-          await clickPoint(client, closeTarget.center.x, closeTarget.center.y, DETERMINISTIC_CLICK_OPTIONS);
-        } else {
-          await clickNodeCenter(client, closeTarget.node_id, DETERMINISTIC_CLICK_OPTIONS);
-        }
+        if (closeTarget.center) {
+          await clickPoint(client, closeTarget.center.x, closeTarget.center.y, DETERMINISTIC_CLICK_OPTIONS);
+        } else {
+          await clickNodeCenter(client, closeTarget.node_id, DETERMINISTIC_CLICK_OPTIONS);
+        }
         attempts.push({
           mode: "close-selector",
           selector: closeTarget.selector,
@@ -856,35 +865,35 @@ export async function closeRecommendDetail(client, {
       closed: closedAfterClick.closed,
       elapsed_ms: closedAfterClick.elapsed_ms
     });
-    if (closedAfterClick.closed) {
-      return {
-        closed: true,
-        attempts
-      };
-    }
-
-    const outsideClick = await clickOutsideRecommendDetail(client, closedAfterClick.state || existingState);
-    attempts.push(outsideClick);
-    if (outsideClick.clicked) {
-      const closedAfterOutsideClick = await waitForRecommendDetailClosed(client, {
-        timeoutMs: closeWaitMs,
-        intervalMs: 250
-      });
-      attempts.push({
-        mode: "wait-closed-after-outside-click",
-        closed: closedAfterOutsideClick.closed,
-        elapsed_ms: closedAfterOutsideClick.elapsed_ms
-      });
-      if (closedAfterOutsideClick.closed) {
-        return {
-          closed: true,
-          attempts
-        };
-      }
-    }
-
-    await pressEscape(client);
-    attempts.push({ mode: "Escape-fallback" });
+    if (closedAfterClick.closed) {
+      return {
+        closed: true,
+        attempts
+      };
+    }
+
+    const outsideClick = await clickOutsideRecommendDetail(client, closedAfterClick.state || existingState);
+    attempts.push(outsideClick);
+    if (outsideClick.clicked) {
+      const closedAfterOutsideClick = await waitForRecommendDetailClosed(client, {
+        timeoutMs: closeWaitMs,
+        intervalMs: 250
+      });
+      attempts.push({
+        mode: "wait-closed-after-outside-click",
+        closed: closedAfterOutsideClick.closed,
+        elapsed_ms: closedAfterOutsideClick.elapsed_ms
+      });
+      if (closedAfterOutsideClick.closed) {
+        return {
+          closed: true,
+          attempts
+        };
+      }
+    }
+
+    await pressEscape(client);
+    attempts.push({ mode: "Escape-fallback" });
 
     const closedAfterEscape = await waitForRecommendDetailClosed(client, {
       timeoutMs: escapeWaitMs,
@@ -901,33 +910,33 @@ export async function closeRecommendDetail(client, {
         attempts
       };
     }
-  }
-
-  const verification = await verifyRecommendDetailStillOpen(client);
-  attempts.push({
-    mode: "final-close-verification",
-    open: verification.open,
-    stable_open: verification.stable_open,
-    popup: verification.second.popup,
-    resume_iframe: verification.second.resume_iframe
-  });
-  if (!verification.open) {
-    return {
-      closed: true,
-      attempts,
-      verification
-    };
-  }
-
-  return {
-    closed: false,
-    reason: verification.stable_open
-      ? "detail_still_visible_after_close_attempts"
-      : "detail_visibility_ambiguous_after_close_attempts",
-    attempts,
-    verification
-  };
-}
+  }
+
+  const verification = await verifyRecommendDetailStillOpen(client);
+  attempts.push({
+    mode: "final-close-verification",
+    open: verification.open,
+    stable_open: verification.stable_open,
+    popup: verification.second.popup,
+    resume_iframe: verification.second.resume_iframe
+  });
+  if (!verification.open) {
+    return {
+      closed: true,
+      attempts,
+      verification
+    };
+  }
+
+  return {
+    closed: false,
+    reason: verification.stable_open
+      ? "detail_still_visible_after_close_attempts"
+      : "detail_visibility_ambiguous_after_close_attempts",
+    attempts,
+    verification
+  };
+}
 
 async function findVisibleCloseTarget(client, roots, selectors) {
   let fallback = null;
@@ -959,107 +968,107 @@ async function findVisibleCloseTarget(client, roots, selectors) {
   return fallback;
 }
 
-async function pressEscape(client) {
-  await pressKey(client, "Escape", {
-    code: "Escape",
-    windowsVirtualKeyCode: 27,
-    nativeVirtualKeyCode: 27
-  });
-}
-
-function clampPointCoordinate(value, min, max) {
-  return Math.max(min, Math.min(max, value));
-}
-
-async function getClickViewport(client) {
-  try {
-    const metrics = typeof client?.Page?.getLayoutMetrics === "function"
-      ? await client.Page.getLayoutMetrics()
-      : null;
-    const viewport = metrics?.cssLayoutViewport || metrics?.layoutViewport || metrics?.visualViewport || {};
-    return {
-      width: Number(viewport.clientWidth || viewport.width || 1440),
-      height: Number(viewport.clientHeight || viewport.height || 900)
-    };
-  } catch {
-    return {
-      width: 1440,
-      height: 900
-    };
-  }
-}
-
-function getOutsideClickPoint(rect, viewport) {
-  if (!rect || rect.width <= 2 || rect.height <= 2) return null;
-  const margin = 24;
-  const minX = 8;
-  const minY = 8;
-  const maxX = Math.max(minX, (Number(viewport?.width) || 1440) - 8);
-  const maxY = Math.max(minY, (Number(viewport?.height) || 900) - 8);
-  const midX = rect.x + rect.width / 2;
-  const midY = rect.y + Math.min(Math.max(rect.height * 0.2, 48), Math.max(48, rect.height - 24));
-  const candidates = [
-    { side: "left", x: rect.x - margin, y: midY },
-    { side: "right", x: rect.x + rect.width + margin, y: midY },
-    { side: "above", x: midX, y: rect.y - margin },
-    { side: "below", x: midX, y: rect.y + rect.height + margin },
-    { side: "viewport-corner", x: 16, y: 16 }
-  ];
-
-  for (const candidate of candidates) {
-    const x = clampPointCoordinate(candidate.x, minX, maxX);
-    const y = clampPointCoordinate(candidate.y, minY, maxY);
-    const insideRect = (
-      x >= rect.x
-      && x <= rect.x + rect.width
-      && y >= rect.y
-      && y <= rect.y + rect.height
-    );
-    if (!insideRect) {
-      return {
-        ...candidate,
-        x,
-        y
-      };
-    }
-  }
-  return null;
-}
-
-async function clickOutsideRecommendDetail(client, detailState) {
-  const rootState = detailState?.roots?.length
-    ? detailState
-    : await readRecommendDetailState(client);
-  const boundaryTarget = await findVisibleDetailTarget(
-    client,
-    rootState.roots || [],
-    DETAIL_OUTSIDE_CLOSE_BOUNDARY_SELECTORS
-  );
-  const target = boundaryTarget || rootState.resumeIframe || rootState.popup || null;
-  const viewport = await getClickViewport(client);
-  const point = getOutsideClickPoint(target?.rect, viewport);
-  if (!point) {
-    return {
-      clicked: false,
-      mode: "outside-modal-click",
-      reason: "no_outside_click_point",
-      selector: target?.selector || null,
-      root: target?.root || null
-    };
-  }
-  await clickPoint(client, point.x, point.y, DETERMINISTIC_CLICK_OPTIONS);
-  return {
-    clicked: true,
-    mode: "outside-modal-click",
-    selector: target?.selector || null,
-    root: target?.root || null,
-    side: point.side,
-    x: Math.round(point.x),
-    y: Math.round(point.y)
-  };
-}
-
-export async function extractRecommendDetailCandidate(client, {
+async function pressEscape(client) {
+  await pressKey(client, "Escape", {
+    code: "Escape",
+    windowsVirtualKeyCode: 27,
+    nativeVirtualKeyCode: 27
+  });
+}
+
+function clampPointCoordinate(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+async function getClickViewport(client) {
+  try {
+    const metrics = typeof client?.Page?.getLayoutMetrics === "function"
+      ? await client.Page.getLayoutMetrics()
+      : null;
+    const viewport = metrics?.cssLayoutViewport || metrics?.layoutViewport || metrics?.visualViewport || {};
+    return {
+      width: Number(viewport.clientWidth || viewport.width || 1440),
+      height: Number(viewport.clientHeight || viewport.height || 900)
+    };
+  } catch {
+    return {
+      width: 1440,
+      height: 900
+    };
+  }
+}
+
+function getOutsideClickPoint(rect, viewport) {
+  if (!rect || rect.width <= 2 || rect.height <= 2) return null;
+  const margin = 24;
+  const minX = 8;
+  const minY = 8;
+  const maxX = Math.max(minX, (Number(viewport?.width) || 1440) - 8);
+  const maxY = Math.max(minY, (Number(viewport?.height) || 900) - 8);
+  const midX = rect.x + rect.width / 2;
+  const midY = rect.y + Math.min(Math.max(rect.height * 0.2, 48), Math.max(48, rect.height - 24));
+  const candidates = [
+    { side: "left", x: rect.x - margin, y: midY },
+    { side: "right", x: rect.x + rect.width + margin, y: midY },
+    { side: "above", x: midX, y: rect.y - margin },
+    { side: "below", x: midX, y: rect.y + rect.height + margin },
+    { side: "viewport-corner", x: 16, y: 16 }
+  ];
+
+  for (const candidate of candidates) {
+    const x = clampPointCoordinate(candidate.x, minX, maxX);
+    const y = clampPointCoordinate(candidate.y, minY, maxY);
+    const insideRect = (
+      x >= rect.x
+      && x <= rect.x + rect.width
+      && y >= rect.y
+      && y <= rect.y + rect.height
+    );
+    if (!insideRect) {
+      return {
+        ...candidate,
+        x,
+        y
+      };
+    }
+  }
+  return null;
+}
+
+async function clickOutsideRecommendDetail(client, detailState) {
+  const rootState = detailState?.roots?.length
+    ? detailState
+    : await readRecommendDetailState(client);
+  const boundaryTarget = await findVisibleDetailTarget(
+    client,
+    rootState.roots || [],
+    DETAIL_OUTSIDE_CLOSE_BOUNDARY_SELECTORS
+  );
+  const target = boundaryTarget || rootState.resumeIframe || rootState.popup || null;
+  const viewport = await getClickViewport(client);
+  const point = getOutsideClickPoint(target?.rect, viewport);
+  if (!point) {
+    return {
+      clicked: false,
+      mode: "outside-modal-click",
+      reason: "no_outside_click_point",
+      selector: target?.selector || null,
+      root: target?.root || null
+    };
+  }
+  await clickPoint(client, point.x, point.y, DETERMINISTIC_CLICK_OPTIONS);
+  return {
+    clicked: true,
+    mode: "outside-modal-click",
+    selector: target?.selector || null,
+    root: target?.root || null,
+    side: point.side,
+    x: Math.round(point.x),
+    y: Math.round(point.y)
+  };
+}
+
+export async function extractRecommendDetailCandidate(client, {
   cardCandidate,
   cardNodeId,
   detailState,