ppxc-leads-mcp 0.1.0

package/dist/browser/kernel/runner-page-session.js

@@ -0,0 +1,1465 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunnerPageSession = void 0;
+const node_crypto_1 = require("node:crypto");
+const electron_1 = require("electron");
+const logger_1 = require("./logger");
+const page_scripts_1 = require("./page-scripts");
+const runner_page_session_search_parser_1 = require("./runner-page-session.search-parser");
+const runner_page_session_user_agent_1 = require("./runner-page-session.user-agent");
+const DOUYIN_SCROLL_MORE_SCRIPT = `(async () => {
+  try {
+    const opts = (globalThis.__OPC1_SCROLL_OPTS || {});
+    const times = Math.max(1, Math.min(12, Number(opts.times) || 3));
+    const pauseMs = Math.max(200, Math.min(2000, Number(opts.pauseMs) || 450));
+    const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+    const before = Math.max(
+      document.documentElement.scrollHeight || 0,
+      document.body ? document.body.scrollHeight || 0 : 0,
+    );
+    for (let i = 0; i < times; i++) {
+      window.scrollBy({ top: window.innerHeight, behavior: 'instant' });
+      await sleep(pauseMs);
+    }
+    const afterHeight = Math.max(
+      document.documentElement.scrollHeight || 0,
+      document.body ? document.body.scrollHeight || 0 : 0,
+    );
+    return { ok: true, before, afterHeight, stepsDone: times };
+  } catch (err) {
+    return { ok: false, message: (err && err.message) || String(err) };
+  }
+})();`;
+const DOUYIN_OPEN_LOGIN_PANEL_SCRIPT = `(async () => {
+  try {
+    const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+    const visible = (el) => {
+      if (!el) return false;
+      const rect = el.getBoundingClientRect();
+      const style = window.getComputedStyle(el);
+      return rect.width > 0 && rect.height > 0 && style.visibility !== 'hidden' && style.display !== 'none';
+    };
+    const hasSessionId = /(?:^|;\\s*)(sessionid|sessionid_ss|sid_guard)=/.test(String(document.cookie || ''));
+    const findLoginModal = () => document.querySelector(
+      '[data-e2e="login-modal"], [class*="login-mask"], [id="login-pannel"], [class*="login-modal"]'
+    );
+    const findQrSignal = () => document.querySelector(
+      'canvas, img[src*="qr"], img[src*="scan"], [class*="qr"], [class*="qrcode"], [class*="scan"]'
+    );
+    const modalNow = findLoginModal();
+    if (modalNow && visible(modalNow)) {
+      return { ok: true, status: 'login_required', opened: true, clicked: false, hasQrSignal: Boolean(findQrSignal()) };
+    }
+    if (hasSessionId) {
+      return { ok: true, status: 'logged_in', opened: false, clicked: false, hasQrSignal: false };
+    }
+
+    const selectors = [
+      '[data-e2e="login-button"]',
+      '[data-e2e*="login"]',
+      '[class*="login"]',
+      'button',
+      'a',
+      '[role="button"]',
+      '[tabindex]'
+    ];
+    const candidates = [];
+    for (const selector of selectors) {
+      for (const el of Array.from(document.querySelectorAll(selector))) {
+        if (!visible(el)) continue;
+        const text = String(el.innerText || el.textContent || el.getAttribute('aria-label') || el.getAttribute('title') || '')
+          .replace(/\\s+/g, ' ')
+          .trim();
+        const cls = String(el.className || '');
+        const id = String(el.id || '');
+        const attrs = [text, cls, id, String(el.getAttribute('data-e2e') || '')].join(' ');
+        if (/扫码登录|登录\\/注册|登录后|立即登录|手机号登录|密码登录|未登录|\\blogin\\b/i.test(attrs) || /^登录$/.test(text)) {
+          candidates.push({ el, text });
+        }
+      }
+    }
+
+    const target = candidates[0] && candidates[0].el;
+    if (target) {
+      target.dispatchEvent(new MouseEvent('mouseover', { bubbles: true, cancelable: true, view: window }));
+      target.dispatchEvent(new MouseEvent('mousedown', { bubbles: true, cancelable: true, view: window }));
+      target.dispatchEvent(new MouseEvent('mouseup', { bubbles: true, cancelable: true, view: window }));
+      target.click();
+    }
+
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < 6000) {
+      const modal = findLoginModal();
+      const qr = findQrSignal();
+      if ((modal && visible(modal)) || (qr && visible(qr))) {
+        return {
+          ok: true,
+          status: 'login_required',
+          opened: true,
+          clicked: Boolean(target),
+          hasQrSignal: Boolean(qr),
+        };
+      }
+      await sleep(250);
+    }
+
+    return {
+      ok: false,
+      status: 'unknown',
+      code: target ? 'login_panel_not_visible' : 'login_trigger_missing',
+      message: target ? 'login trigger clicked but panel did not become visible' : 'login trigger not found',
+      opened: false,
+      clicked: Boolean(target),
+      hasQrSignal: false,
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      status: 'unknown',
+      code: 'page_throw',
+      message: (err && err.message) || String(err),
+      opened: false,
+      clicked: false,
+      hasQrSignal: false,
+    };
+  }
+})();`;
+const log = logger_1.logger.scope("page-session");
+const DEFAULT_PROBE_TIMEOUT_MS = 15000;
+const DEFAULT_COOKIE_SNAPSHOT_TIMEOUT_MS = 3000;
+const DEFAULT_LOGIN_PANEL_TIMEOUT_MS = 8500;
+const DEFAULT_PROFILE_SNAPSHOT_TIMEOUT_MS = 2500;
+const DEFAULT_DOM_MAX_SCROLL_ROUNDS = 5;
+const DEFAULT_DOM_MIN_SCROLL_ROUNDS = 3;
+const DEFAULT_DOM_RENDER_WAIT_MS = 650;
+const DOUYIN_SEARCH_HOOK_BINDING = "__OPC1_DOUYIN_SEARCH_CAPTURE__";
+const MAX_PAGE_HOOK_PAYLOAD_CHARS = 5 * 1024 * 1024;
+const ENABLE_SEARCH_SNIFFER = process.env.OPC1_DISABLE_DOUYIN_SEARCH_SNIFFER !== "1";
+const ENABLE_PAGE_SEARCH_HOOK = process.env.OPC1_DISABLE_DOUYIN_PAGE_SEARCH_HOOK !== "1";
+function readBoundedIntEnv(name, fallback, min, max) {
+    const parsed = Math.floor(Number(process.env[name]));
+    if (!Number.isFinite(parsed))
+        return fallback;
+    return Math.max(min, Math.min(max, parsed));
+}
+function summarizePayloadShape(payload) {
+    const keys = Object.keys(payload).slice(0, 12);
+    const counts = keys
+        .map((key) => {
+        const value = payload[key];
+        if (Array.isArray(value))
+            return `${key}[${value.length}]`;
+        if (value && typeof value === "object")
+            return `${key}{}`;
+        return key;
+    })
+        .join(",");
+    return counts.slice(0, 300);
+}
+class AsyncSemaphore {
+    constructor(_limit) {
+        this._limit = _limit;
+        this._active = 0;
+        this._queue = [];
+    }
+    async run(body) {
+        if (this._active >= this._limit) {
+            await new Promise((resolve) => this._queue.push(resolve));
+        }
+        this._active += 1;
+        try {
+            return await body();
+        }
+        finally {
+            this._active = Math.max(0, this._active - 1);
+            const next = this._queue.shift();
+            if (next)
+                next();
+        }
+    }
+}
+const DEFAULT_NAV_CONCURRENCY = process.env.NODE_ENV === "production" ? 2 : 3;
+const DOUYIN_NAV_CONCURRENCY = readBoundedIntEnv("OPC1_DOUYIN_NAV_CONCURRENCY", DEFAULT_NAV_CONCURRENCY, 1, 8);
+const DOUYIN_NAV_STAGGER_MS = readBoundedIntEnv("OPC1_DOUYIN_NAV_STAGGER_MS", 900, 0, 5000);
+const douyinNavigationSemaphore = new AsyncSemaphore(DOUYIN_NAV_CONCURRENCY);
+let lastDouyinNavigationStartedAt = 0;
+async function withDouyinNavigationPermit(slotId, body) {
+    return douyinNavigationSemaphore.run(async () => {
+        const sinceLast = Date.now() - lastDouyinNavigationStartedAt;
+        const waitMs = Math.max(0, DOUYIN_NAV_STAGGER_MS - sinceLast);
+        if (waitMs > 0) {
+            log.info(`slot ${slotId} waiting douyin navigation gate waitMs=${waitMs}`);
+            await new Promise((resolve) => setTimeout(resolve, waitMs));
+        }
+        lastDouyinNavigationStartedAt = Date.now();
+        return await body();
+    });
+}
+function withTimeout(promise, timeoutMs, onTimeoutMessage) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            reject(new Error(onTimeoutMessage()));
+        }, timeoutMs);
+        promise.then((v) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(v);
+        }, (err) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            reject(err instanceof Error ? err : new Error(String(err)));
+        });
+    });
+}
+class RunnerPageSession {
+    constructor(opts) {
+        this._win = null;
+        this._crashed = false;
+        this._closed = false;
+        this._warmed = false;
+        this._loggedInCached = null;
+        this._debugger = null;
+        this._debuggerAttached = false;
+        this._searchRequests = new Map();
+        this._searchBatches = [];
+        this._searchBatchWaiters = [];
+        this._lastSnifferError = null;
+        this._lastSearchBodyUnavailableError = null;
+        this._searchResponseSeenCount = 0;
+        this._lastSearchResponseStatus = null;
+        this._lastSearchResponseBodyReadable = null;
+        this._lastSearchResponseShape = null;
+        this._pageSearchHookInstalled = false;
+        this._pageSearchHookReady = null;
+        this._keywordsSinceWindowCreated = 0;
+        this._lastRecycleReason = null;
+        this._willRecycleSession = false;
+        this._slotId = opts.slotId;
+        this._partition = opts.partition ?? "persist:opc1-runner-0";
+        this._cookieDomain = opts.cookieDomain ?? ".douyin.com";
+        this._enableSearchSniffer = opts.enableSearchSniffer !== false;
+        this._userAgentOverride = opts.userAgent?.trim() || null;
+        this._sessionId = (0, node_crypto_1.randomUUID)();
+        this._windowCreateIndex = Math.max(1, Math.floor(Number(opts.windowCreateIndex) || 1));
+        this._createdAt = new Date().toISOString();
+        this._lastRecycleReason = opts.lastRecycleReason ?? null;
+        this._navigationTimeoutMs = opts.navigationTimeoutMs ?? 25000;
+        this._collectMaxWaitMs = opts.collectMaxWaitMs ?? 12000;
+        this._collectMaxItems = opts.collectMaxItems ?? 30;
+        this._probeTimeoutMs = opts.probeTimeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS;
+        this._cookieSnapshotTimeoutMs =
+            opts.cookieSnapshotTimeoutMs ?? DEFAULT_COOKIE_SNAPSHOT_TIMEOUT_MS;
+        this._collectMaxScrollRounds = readBoundedIntEnv("OPC1_DOUYIN_DOM_MAX_SCROLL_ROUNDS", DEFAULT_DOM_MAX_SCROLL_ROUNDS, 3, 8);
+        this._collectMinScrollRounds = Math.min(this._collectMaxScrollRounds, readBoundedIntEnv("OPC1_DOUYIN_DOM_MIN_SCROLL_ROUNDS", DEFAULT_DOM_MIN_SCROLL_ROUNDS, 1, 5));
+        this._collectRenderWaitMs = readBoundedIntEnv("OPC1_DOUYIN_DOM_RENDER_WAIT_MS", DEFAULT_DOM_RENDER_WAIT_MS, 250, 2000);
+        this._win = new electron_1.BrowserWindow({
+            width: 1200,
+            height: 800,
+            show: opts.visible === true,
+            title: opts.windowTitle ?? `OPC1 Runner #${this._slotId}`,
+            webPreferences: {
+                contextIsolation: true,
+                nodeIntegration: false,
+                partition: this._partition,
+                sandbox: true,
+                backgroundThrottling: false,
+            },
+        });
+        this._win.webContents.setAudioMuted(true);
+        this._win.webContents.on("did-attach-webview", (_e, attached) => {
+            try {
+                attached.setAudioMuted(true);
+            }
+            catch {
+            }
+        });
+        const userAgent = this._userAgentOverride ?? (0, runner_page_session_user_agent_1.resolveDouyinUserAgent)(process.platform, process.versions);
+        this._win.webContents.setUserAgent(userAgent);
+        log.info(`slot ${this._slotId} ua applied platform=${process.platform} partition=${this._partition}`);
+        const wc = this._win.webContents;
+        wc.setWindowOpenHandler(({ url }) => {
+            if (/^https?:\/\//i.test(url)) {
+                wc.loadURL(url).catch((err) => {
+                    log.warn(`slot ${this._slotId} load popup url failed`, {
+                        url,
+                        msg: err instanceof Error ? err.message : String(err),
+                    });
+                });
+            }
+            else {
+                log.info(`slot ${this._slotId} blocked external popup url`, {
+                    scheme: extractUrlScheme(url),
+                });
+            }
+            return { action: "deny" };
+        });
+        const blockExternalNavigation = (event, url, source) => {
+            if (isHttpLikeUrl(url))
+                return;
+            event.preventDefault();
+            log.info(`slot ${this._slotId} blocked external navigation`, {
+                source,
+                scheme: extractUrlScheme(url),
+            });
+        };
+        wc.on("will-navigate", (event, url) => {
+            blockExternalNavigation(event, url, "will-navigate");
+        });
+        const frameNavigationContents = wc;
+        frameNavigationContents.on("will-frame-navigate", (event, url) => {
+            blockExternalNavigation(event, url, "will-navigate");
+        });
+        wc.on("will-redirect", (event, url) => {
+            blockExternalNavigation(event, url, "will-redirect");
+        });
+        wc.on("did-start-navigation", (event, url, isInPlace, isMainFrame) => {
+            if (isInPlace || isHttpLikeUrl(url))
+                return;
+            event.preventDefault();
+            log.info(`slot ${this._slotId} blocked external navigation`, {
+                source: "did-start-navigation",
+                isMainFrame,
+                scheme: extractUrlScheme(url),
+            });
+        });
+        wc.session.webRequest.onBeforeRequest((details, callback) => {
+            const url = String(details.url || "");
+            if (isHttpLikeUrl(url)) {
+                callback({ cancel: false });
+                return;
+            }
+            log.info(`slot ${this._slotId} blocked external request`, {
+                scheme: extractUrlScheme(url),
+                resourceType: details.resourceType,
+            });
+            callback({ cancel: true });
+        });
+        wc.on("render-process-gone", (_e, det) => {
+            this._crashed = true;
+            log.warn(`slot ${this._slotId} render-process-gone`, { reason: det.reason });
+        });
+        wc.on("destroyed", () => {
+            this._closed = true;
+        });
+        this._win.on("closed", () => {
+            this._closed = true;
+            this._win = null;
+        });
+        if (this._enableSearchSniffer && ENABLE_SEARCH_SNIFFER) {
+            this._attachSearchSniffer();
+        }
+        else {
+            log.info(`slot ${this._slotId} cdp search sniffer disabled`);
+        }
+    }
+    get slotId() {
+        return this._slotId;
+    }
+    getWebContents() {
+        if (!this._win || this._win.isDestroyed())
+            return null;
+        return this._win.webContents;
+    }
+    get sessionId() {
+        return this._sessionId;
+    }
+    get windowCreateIndex() {
+        return this._windowCreateIndex;
+    }
+    get keywordsSinceWindowCreated() {
+        return this._keywordsSinceWindowCreated;
+    }
+    get createdAt() {
+        return this._createdAt;
+    }
+    get lastRecycleReason() {
+        return this._lastRecycleReason;
+    }
+    shouldRecycleOnRelease() {
+        return this._willRecycleSession;
+    }
+    markKeywordCompleted() {
+        this._keywordsSinceWindowCreated += 1;
+        return this._keywordsSinceWindowCreated;
+    }
+    markForRecycle(reason) {
+        this._willRecycleSession = true;
+        this._lastRecycleReason = reason;
+    }
+    getSessionDiagnostics() {
+        return {
+            sessionId: this._sessionId,
+            windowCreateIndex: this._windowCreateIndex,
+            slotId: this._slotId,
+            keywordsSinceWindowCreated: this._keywordsSinceWindowCreated,
+            createdAt: this._createdAt,
+            lastRecycleReason: this._lastRecycleReason,
+            willRecycleSession: this._willRecycleSession,
+        };
+    }
+    isAlive() {
+        return !this._closed && !this._crashed && !!this._win && !this._win.isDestroyed();
+    }
+    reveal() {
+        return this.revealStatus().alive;
+    }
+    revealStatus() {
+        const platform = process.platform;
+        if (!this._win || this._win.isDestroyed()) {
+            return {
+                alive: false,
+                visible: false,
+                focused: false,
+                minimized: false,
+                bounds: null,
+                platform,
+            };
+        }
+        const win = this._win;
+        const safeBool = (fn) => {
+            try {
+                return fn() === true;
+            }
+            catch {
+                return false;
+            }
+        };
+        try {
+            if (safeBool(() => win.isMinimized())) {
+                try {
+                    win.restore();
+                }
+                catch {
+                }
+            }
+            if (!safeBool(() => win.isVisible())) {
+                try {
+                    win.show();
+                }
+                catch {
+                }
+            }
+            try {
+                win.setAlwaysOnTop(true, "screen-saver");
+            }
+            catch {
+            }
+            try {
+                win.focus();
+            }
+            catch {
+            }
+            try {
+                win.moveTop();
+            }
+            catch {
+            }
+            if (platform === "win32") {
+                try {
+                    win.flashFrame(true);
+                }
+                catch {
+                }
+                setTimeout(() => {
+                    if (this._win && !this._win.isDestroyed()) {
+                        try {
+                            if (this._win.isMinimized())
+                                this._win.restore();
+                            this._win.show();
+                            this._win.focus();
+                            this._win.moveTop();
+                            this._win.flashFrame(false);
+                        }
+                        catch {
+                        }
+                    }
+                }, 180);
+            }
+            setTimeout(() => {
+                try {
+                    if (this._win && !this._win.isDestroyed()) {
+                        this._win.setAlwaysOnTop(false);
+                    }
+                }
+                catch {
+                }
+            }, 800);
+        }
+        catch (err) {
+            log.warn(`slot ${this._slotId} reveal failed`, {
+                msg: err instanceof Error ? err.message : String(err),
+            });
+        }
+        let bounds = null;
+        try {
+            const b = win.getBounds();
+            bounds = { x: b.x, y: b.y, width: b.width, height: b.height };
+        }
+        catch {
+        }
+        return {
+            alive: !win.isDestroyed(),
+            visible: safeBool(() => win.isVisible()),
+            focused: safeBool(() => win.isFocused()),
+            minimized: safeBool(() => win.isMinimized()),
+            bounds,
+            platform,
+        };
+    }
+    hide() {
+        if (!this._win || this._win.isDestroyed())
+            return;
+        if (this._win.isVisible())
+            this._win.hide();
+    }
+    async loadUrl(url) {
+        return await withDouyinNavigationPermit(this._slotId, async () => {
+            this._assertAlive();
+            const wc = this._win.webContents;
+            const timeoutMs = this._navigationTimeoutMs;
+            let timer = null;
+            const cleanupListeners = [];
+            const waitSettled = new Promise((resolve, reject) => {
+                let done = false;
+                const finish = (err) => {
+                    if (done)
+                        return;
+                    done = true;
+                    if (timer) {
+                        clearTimeout(timer);
+                        timer = null;
+                    }
+                    for (const off of cleanupListeners) {
+                        try {
+                            off();
+                        }
+                        catch {
+                        }
+                    }
+                    if (err)
+                        reject(err);
+                    else
+                        resolve();
+                };
+                const onLoad = () => finish();
+                const onFail = (_e, errCode, errDesc, validatedUrl, isMain) => {
+                    if (!isMain)
+                        return;
+                    if (errCode === -3) {
+                        log.info(`slot ${this._slotId} loadUrl aborted path=event url=${validatedUrl}`);
+                        return;
+                    }
+                    finish(new Error(`navigation failed: ${errCode} ${errDesc} (${validatedUrl})`));
+                };
+                const onCrash = () => finish(new Error("render process gone during navigation"));
+                wc.on("did-finish-load", onLoad);
+                wc.on("dom-ready", onLoad);
+                wc.on("did-fail-load", onFail);
+                wc.on("render-process-gone", onCrash);
+                cleanupListeners.push(() => wc.removeListener("did-finish-load", onLoad), () => wc.removeListener("dom-ready", onLoad), () => wc.removeListener("did-fail-load", onFail), () => wc.removeListener("render-process-gone", onCrash));
+                timer = setTimeout(() => {
+                    finish(new Error(`navigation timeout after ${timeoutMs}ms`));
+                }, timeoutMs);
+                wc.loadURL(url).then(() => finish(), (err) => {
+                    const raw = err instanceof Error ? err : new Error(String(err));
+                    if (isNavigationAbortedError(raw)) {
+                        log.info(`slot ${this._slotId} loadUrl aborted path=promise url=${url} msg=${raw.message}`);
+                        return;
+                    }
+                    finish(raw);
+                });
+            });
+            await waitSettled;
+            return {
+                finalUrl: wc.getURL(),
+                pageTitle: wc.getTitle() || undefined,
+            };
+        });
+    }
+    navigateNoWait(url) {
+        this._assertAlive();
+        this._win.webContents.loadURL(url).catch((err) => {
+            const raw = err instanceof Error ? err : new Error(String(err));
+            if (isNavigationAbortedError(raw)) {
+                log.info(`slot ${this._slotId} navigateNoWait aborted url=${url} msg=${raw.message}`);
+                return;
+            }
+            log.warn(`slot ${this._slotId} navigateNoWait failed`, {
+                url,
+                msg: raw.message,
+            });
+        });
+    }
+    currentUrl() {
+        if (!this.isAlive())
+            return "";
+        return this._win.webContents.getURL();
+    }
+    async reloadCurrentOrLoadFallback(fallbackUrl) {
+        const current = this.currentUrl();
+        const target = /^https?:\/\//i.test(current) ? current : fallbackUrl;
+        return await this.loadUrl(target);
+    }
+    async probe() {
+        this._assertAlive();
+        const started = Date.now();
+        try {
+            const raw = await withTimeout(this._win.webContents.executeJavaScript(page_scripts_1.DOUYIN_PROBE_SCRIPT, true), this._probeTimeoutMs, () => `probe timed out after ${this._probeTimeoutMs}ms (executeJavaScript stuck)`);
+            if (!raw || typeof raw !== "object") {
+                return {
+                    ok: false,
+                    status: "unknown",
+                    code: "page_invalid",
+                    message: "probe returned non-object",
+                };
+            }
+            const parsed = raw;
+            return {
+                ok: parsed.ok !== false,
+                status: parsed.status ?? "unknown",
+                details: parsed.details,
+                code: parsed.code,
+                message: parsed.message,
+            };
+        }
+        catch (err) {
+            const elapsedMs = Date.now() - started;
+            const msg = err instanceof Error ? err.message : String(err);
+            if (/probe timed out/i.test(msg)) {
+                log.warn(`slot ${this._slotId} probe timed out timeoutMs=${this._probeTimeoutMs} elapsedMs=${elapsedMs}`);
+                return {
+                    ok: true,
+                    status: "unknown",
+                    details: { url: "", title: "" },
+                    message: msg,
+                };
+            }
+            log.warn(`slot ${this._slotId} probe threw elapsedMs=${elapsedMs} msg=${msg}`);
+            return {
+                ok: false,
+                status: "unknown",
+                code: "execute_throw",
+                message: msg,
+            };
+        }
+    }
+    async openLoginPanel() {
+        this._assertAlive();
+        const raw = await safeJson(this._win.webContents, DOUYIN_OPEN_LOGIN_PANEL_SCRIPT, "openLoginPanel", DEFAULT_LOGIN_PANEL_TIMEOUT_MS);
+        return {
+            ok: raw.ok === true,
+            status: raw.status ?? "unknown",
+            opened: raw.opened === true,
+            clicked: raw.clicked === true,
+            hasQrSignal: raw.hasQrSignal === true,
+            code: raw.code,
+            message: raw.message,
+        };
+    }
+    async getSessionCookieSnapshot() {
+        this._assertAlive();
+        const started = Date.now();
+        const cookies = await withTimeout(this._win.webContents.session.cookies.get({ domain: this._cookieDomain }), this._cookieSnapshotTimeoutMs, () => `cookie snapshot timed out after ${this._cookieSnapshotTimeoutMs}ms`);
+        const elapsedMs = Date.now() - started;
+        if (elapsedMs > 1000) {
+            log.warn(`slot ${this._slotId} cookie snapshot slow elapsedMs=${elapsedMs}`);
+        }
+        const names = cookies.map((cookie) => cookie.name);
+        return {
+            hasSessionId: names.includes("sessionid"),
+            hasSessionIdSs: names.includes("sessionid_ss"),
+            hasSidGuard: names.includes("sid_guard"),
+            names,
+        };
+    }
+    async hasAnyLoginCookies(cookieNames) {
+        const snap = await this.getSessionCookieSnapshot();
+        return cookieNames.some((n) => snap.names.includes(n));
+    }
+    async fetchJsonInPage(url, timeoutMs = 15000) {
+        this._assertAlive();
+        const script = `(async () => {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), ${Math.max(1000, Math.floor(timeoutMs))});
+      try {
+        const res = await fetch(${JSON.stringify(url)}, {
+          method: "GET",
+          credentials: "include",
+          headers: {
+            "accept": "application/json, text/plain, */*",
+          },
+          signal: controller.signal,
+        });
+        const text = await res.text();
+        let json = null;
+        try { json = text ? JSON.parse(text) : null; } catch {}
+        return {
+          ok: res.ok,
+          status: res.status,
+          json,
+          textHead: text.slice(0, 200),
+          textLength: text.length,
+        };
+      } catch (err) {
+        return {
+          ok: false,
+          status: 0,
+          error: (err && err.message) || String(err),
+        };
+      } finally {
+        clearTimeout(timer);
+      }
+    })();`;
+        const hostTimeoutMs = Math.max(2000, Math.floor(timeoutMs) + 2000);
+        const raw = await Promise.race([
+            this._win.webContents.executeJavaScript(script, true),
+            new Promise((resolve) => {
+                setTimeout(() => {
+                    resolve({
+                        ok: false,
+                        status: 0,
+                        error: `fetchJsonInPage host timeout after ${hostTimeoutMs}ms`,
+                    });
+                }, hostTimeoutMs);
+            }),
+        ]);
+        if (!raw || typeof raw !== "object") {
+            return {
+                ok: false,
+                status: 0,
+                error: "fetchJsonInPage returned non-object",
+            };
+        }
+        return raw;
+    }
+    async getDouyinProfileSnapshot() {
+        this._assertAlive();
+        const script = `(() => {
+      const banned = /^(登录|注册|上传|发布|消息|关注|推荐|首页|我的|朋友|直播|商城|创作服务平台|抖音|搜索)$/;
+      const clean = (value) => {
+        const text = String(value || '').replace(/\\s+/g, ' ').trim();
+        if (!text || text.length < 2 || text.length > 32 || banned.test(text)) return '';
+        return text;
+      };
+      const pickText = (el) => clean(
+        el && (el.getAttribute('aria-label') || el.getAttribute('title') || el.textContent)
+      );
+      const candidates = [];
+      const push = (value) => {
+        const text = clean(value);
+        if (text && !candidates.includes(text)) candidates.push(text);
+      };
+      document.querySelectorAll('a[href*="/user/"], [class*="user"], [class*="avatar"], [data-e2e*="user"]').forEach((el) => {
+        push(pickText(el));
+        el.querySelectorAll && el.querySelectorAll('img[alt]').forEach((img) => push(img.getAttribute('alt')));
+      });
+      const seen = new Set();
+      const visit = (value, depth = 0) => {
+        if (!value || depth > 5) return;
+        if (typeof value === 'string') {
+          push(value);
+          return;
+        }
+        if (typeof value !== 'object' || seen.has(value)) return;
+        seen.add(value);
+        if (Array.isArray(value)) {
+          value.slice(0, 20).forEach((item) => visit(item, depth + 1));
+          return;
+        }
+        for (const [key, val] of Object.entries(value)) {
+          if (/^(nickname|nickName|nick_name|name|displayName|userName)$/i.test(key)) push(val);
+          if (/user|account|profile|author|self/i.test(key)) visit(val, depth + 1);
+        }
+      };
+      try {
+        for (let i = 0; i < localStorage.length; i++) {
+          const key = localStorage.key(i) || '';
+          if (!/user|account|profile|login|self|douyin/i.test(key)) continue;
+          const raw = localStorage.getItem(key);
+          if (!raw || raw.length > 200000) continue;
+          try { visit(JSON.parse(raw)); } catch { push(raw); }
+        }
+      } catch {}
+      return { displayName: candidates[0] || null };
+    })();`;
+        try {
+            const raw = await withTimeout(this._win.webContents.executeJavaScript(script, true), DEFAULT_PROFILE_SNAPSHOT_TIMEOUT_MS, () => `profile snapshot timed out after ${DEFAULT_PROFILE_SNAPSHOT_TIMEOUT_MS}ms`);
+            const displayName = raw && typeof raw === "object" && typeof raw.displayName === "string"
+                ? (raw.displayName.trim() || null)
+                : null;
+            return { displayName };
+        }
+        catch (err) {
+            log.warn(`slot ${this._slotId} profile snapshot failed`, {
+                msg: err instanceof Error ? err.message : String(err),
+            });
+            return { displayName: null };
+        }
+    }
+    async preScroll() {
+        this._assertAlive();
+        try {
+            await this._win.webContents.executeJavaScript(page_scripts_1.DOUYIN_PRESCROLL_SCRIPT, true);
+        }
+        catch (e) {
+            log.warn(`slot ${this._slotId} pre-scroll ignored`, {
+                msg: e instanceof Error ? e.message : String(e),
+            });
+        }
+    }
+    async scrollMore(times = 3, pauseMs = 450) {
+        if (!this.isAlive())
+            return { ok: false, heightGrew: false };
+        const wc = this._win.webContents;
+        const setOpts = `globalThis.__OPC1_SCROLL_OPTS = ${JSON.stringify({ times, pauseMs })};`;
+        try {
+            await wc.executeJavaScript(setOpts, true);
+        }
+        catch (e) {
+            log.warn(`slot ${this._slotId} scroll-more set-opts failed`, {
+                msg: e instanceof Error ? e.message : String(e),
+            });
+        }
+        try {
+            const raw = await wc.executeJavaScript(DOUYIN_SCROLL_MORE_SCRIPT, true);
+            if (!raw || typeof raw !== "object") {
+                return { ok: false, heightGrew: false };
+            }
+            const obj = raw;
+            const before = Number(obj.before ?? 0);
+            const after = Number(obj.afterHeight ?? 0);
+            return {
+                ok: obj.ok !== false,
+                heightGrew: after > before,
+                before,
+                after,
+            };
+        }
+        catch (e) {
+            log.warn(`slot ${this._slotId} scroll-more threw`, {
+                msg: e instanceof Error ? e.message : String(e),
+            });
+            return { ok: false, heightGrew: false };
+        }
+    }
+    async getSearchReadinessSnapshot() {
+        this._assertAlive();
+        const script = `(() => {
+      function count(sel) {
+        try { return document.querySelectorAll(sel).length; } catch (_) { return 0; }
+      }
+      function has(sel) {
+        try { return !!document.querySelector(sel); } catch (_) { return false; }
+      }
+      return {
+        readyState: String(document.readyState || ''),
+        videoLinkCount: count('a[href*="/video/"], a[href*="douyin.com/video/"]'),
+        candidateVideoSignals: count('[data-e2e*="video" i], [class*="video" i], [class*="aweme" i], [class*="card" i], [class*="result" i]'),
+        hasLoadingSignal: has('[class*="skeleton" i], [class*="loading" i], [class*="spinner" i], [class*="placeholder" i]'),
+        scrollHeight: Math.max(document.documentElement.scrollHeight || 0, document.body ? document.body.scrollHeight || 0 : 0),
+      };
+    })();`;
+        const raw = await this._win.webContents.executeJavaScript(script, true);
+        const obj = raw && typeof raw === "object" ? raw : {};
+        return {
+            readyState: typeof obj.readyState === "string" ? obj.readyState : "",
+            videoLinkCount: Number.isFinite(Number(obj.videoLinkCount)) ? Number(obj.videoLinkCount) : 0,
+            candidateVideoSignals: Number.isFinite(Number(obj.candidateVideoSignals))
+                ? Number(obj.candidateVideoSignals)
+                : 0,
+            hasLoadingSignal: obj.hasLoadingSignal === true,
+            scrollHeight: Number.isFinite(Number(obj.scrollHeight)) ? Number(obj.scrollHeight) : 0,
+            pendingSearchRequests: this._searchRequests.size,
+        };
+    }
+    async getSearchPageDomSnapshot() {
+        this._assertAlive();
+        const script = `(() => {
+      const text = (value) => String(value || '').replace(/\\s+/g, ' ').trim();
+      const lowerBody = text(document.body && document.body.innerText).toLowerCase();
+      const title = text(document.title);
+      const inputSelectors = [
+        'input[type="search"]',
+        'input[placeholder*="搜索"]',
+        'input[aria-label*="搜索"]',
+        'input',
+        '[contenteditable="true"]'
+      ];
+      let searchInputValue = '';
+      for (const selector of inputSelectors) {
+        const el = document.querySelector(selector);
+        if (!el) continue;
+        searchInputValue = text(el.value || el.getAttribute('value') || el.textContent || el.getAttribute('aria-label'));
+        if (searchInputValue) break;
+      }
+      const count = (selector) => {
+        try { return document.querySelectorAll(selector).length; } catch (_) { return 0; }
+      };
+      const hasVideoLinkSignal = count('a[href*="/video/"], a[href*="douyin.com/video/"]') > 0;
+      const candidateVideoSignals = count('[data-e2e*="video" i], [class*="video" i], [class*="aweme" i], [class*="card" i], [class*="result" i]');
+      const homeHints = ['精选', '推荐', '首页', '朋友', '直播', '商城'];
+      const verificationHints = ['验证码中间页', '验证码', '安全验证', '人机验证', '请完成验证', '访问异常', '环境异常', '滑动验证', '请拖动滑块'];
+      const loginHints = ['扫码登录', '登录后', '登录抖音', '手机号登录'];
+      return {
+        pageTitle: title,
+        searchInputValue,
+        hasVideoLinkSignal,
+        candidateVideoSignals,
+        pageLooksLikeHome: homeHints.some((hit) => title.includes(hit) || lowerBody.includes(hit.toLowerCase())),
+        pageLooksLikeLogin: loginHints.some((hit) => lowerBody.includes(hit.toLowerCase())),
+        pageLooksLikeVerification: verificationHints.some((hit) => title.includes(hit) || lowerBody.includes(hit.toLowerCase())),
+      };
+    })();`;
+        const raw = await this._win.webContents.executeJavaScript(script, true);
+        const obj = raw && typeof raw === "object" ? raw : {};
+        return {
+            pageTitle: typeof obj.pageTitle === "string" ? obj.pageTitle : "",
+            searchInputValue: typeof obj.searchInputValue === "string" ? obj.searchInputValue : "",
+            hasVideoLinkSignal: obj.hasVideoLinkSignal === true,
+            candidateVideoSignals: Number.isFinite(Number(obj.candidateVideoSignals))
+                ? Number(obj.candidateVideoSignals)
+                : 0,
+            pageLooksLikeHome: obj.pageLooksLikeHome === true,
+            pageLooksLikeLogin: obj.pageLooksLikeLogin === true,
+            pageLooksLikeVerification: obj.pageLooksLikeVerification === true,
+        };
+    }
+    async collect() {
+        this._assertAlive();
+        const wc = this._win.webContents;
+        const setOpts = `globalThis.__OPC1_COLLECT_OPTS = ${JSON.stringify({
+            maxWaitMs: this._collectMaxWaitMs,
+            maxItems: this._collectMaxItems,
+            maxScrollRounds: this._collectMaxScrollRounds,
+            minScrollRounds: this._collectMinScrollRounds,
+            renderWaitMs: this._collectRenderWaitMs,
+        })};`;
+        try {
+            await wc.executeJavaScript(setOpts, true);
+        }
+        catch (e) {
+            log.warn(`slot ${this._slotId} collect set-opts failed`, {
+                msg: e instanceof Error ? e.message : String(e),
+            });
+        }
+        return safeJson(wc, page_scripts_1.DOUYIN_COLLECT_SCRIPT, "collect");
+    }
+    async runUserLikeSearch(keyword, opts = {}) {
+        this._assertAlive();
+        const wc = this._win.webContents;
+        const maxWaitMs = Math.max(3000, Math.min(20000, Math.floor(Number(opts.maxWaitMs) || 12000)));
+        const timeoutMs = Math.max(maxWaitMs + 3000, Math.floor(Number(opts.timeoutMs) || maxWaitMs + 5000));
+        const setOpts = `globalThis.__OPC1_USER_LIKE_SEARCH_OPTS = ${JSON.stringify({
+            keyword,
+            maxWaitMs,
+            pollIntervalMs: 300,
+        })};`;
+        try {
+            await withTimeout(wc.executeJavaScript(setOpts, true), 2000, () => "user-like search set opts timed out after 2000ms");
+        }
+        catch (e) {
+            log.warn(`slot ${this._slotId} user-like search set-opts failed`, {
+                msg: e instanceof Error ? e.message : String(e),
+            });
+        }
+        try {
+            const raw = await withTimeout(wc.executeJavaScript(page_scripts_1.DOUYIN_USER_LIKE_SEARCH_SCRIPT, true), timeoutMs, () => `user-like search timed out after ${timeoutMs}ms`);
+            if (!raw || typeof raw !== "object") {
+                return {
+                    ok: false,
+                    code: "page_invalid",
+                    message: "user-like search returned non-object",
+                };
+            }
+            return raw;
+        }
+        catch (err) {
+            return {
+                ok: false,
+                code: "execute_throw",
+                message: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    async reset() {
+        if (!this.isAlive())
+            return;
+        const wc = this._win.webContents;
+        try {
+            if (wc.isLoading())
+                wc.stop();
+            await wc.loadURL("about:blank");
+        }
+        catch {
+        }
+    }
+    async cancelActiveWork() {
+        this.clearSearchBuffer({ resolveWaiters: true });
+        await this.reset();
+    }
+    async close() {
+        this._closed = true;
+        this._detachSearchSniffer();
+        const w = this._win;
+        this._win = null;
+        if (!w || w.isDestroyed())
+            return;
+        try {
+            w.destroy();
+        }
+        catch {
+        }
+    }
+    isWarmed() {
+        return this._warmed;
+    }
+    markWarmed(loggedIn) {
+        this._warmed = true;
+        this._loggedInCached = loggedIn;
+    }
+    getCachedLoggedIn() {
+        return this._loggedInCached;
+    }
+    invalidateWarmed() {
+        this._warmed = false;
+        this._loggedInCached = null;
+    }
+    isSearchSnifferReady() {
+        return (this._debuggerAttached &&
+            this.isAlive() &&
+            this._lastSnifferError === null);
+    }
+    lastSnifferError() {
+        return this._lastSnifferError;
+    }
+    lastSearchBodyUnavailableError() {
+        return this._lastSearchBodyUnavailableError;
+    }
+    getSearchResponseDiagnostics() {
+        return {
+            cdpResponseSeen: this._searchResponseSeenCount > 0,
+            responseBodyReadable: this._lastSearchResponseBodyReadable,
+            responseStatusCode: this._lastSearchResponseStatus,
+            rawResponseShape: this._lastSearchResponseShape,
+        };
+    }
+    clearSearchBuffer(opts = {}) {
+        this._searchRequests.clear();
+        this._searchBatches.length = 0;
+        this._lastSearchBodyUnavailableError = null;
+        this._searchResponseSeenCount = 0;
+        this._lastSearchResponseStatus = null;
+        this._lastSearchResponseBodyReadable = null;
+        this._lastSearchResponseShape = null;
+        if (opts.resolveWaiters) {
+            const waiters = this._searchBatchWaiters.splice(0);
+            for (const resolve of waiters) {
+                try {
+                    resolve(null);
+                }
+                catch {
+                }
+            }
+        }
+    }
+    async awaitNextSearchBatch(timeoutMs) {
+        if (this._searchBatches.length > 0) {
+            return this._searchBatches.shift() ?? null;
+        }
+        return await new Promise((resolve) => {
+            let settled = false;
+            const onBatch = (b) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                resolve(b);
+            };
+            this._searchBatchWaiters.push(onBatch);
+            const timer = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                const idx = this._searchBatchWaiters.indexOf(onBatch);
+                if (idx >= 0)
+                    this._searchBatchWaiters.splice(idx, 1);
+                resolve(null);
+            }, Math.max(50, timeoutMs));
+        });
+    }
+    _attachSearchSniffer() {
+        if (!this._win || this._win.isDestroyed())
+            return;
+        if (this._debuggerAttached)
+            return;
+        const wc = this._win.webContents;
+        try {
+            const dbg = wc.debugger;
+            if (!dbg.isAttached()) {
+                dbg.attach("1.3");
+            }
+            this._debugger = dbg;
+            this._debuggerAttached = true;
+            this._lastSnifferError = null;
+            dbg.on("detach", (_e, reason) => {
+                this._debuggerAttached = false;
+                log.warn(`slot ${this._slotId} cdp detach reason=${reason}`);
+            });
+            dbg.on("message", (_e, method, params) => {
+                const p = params;
+                if (method === "Runtime.bindingCalled") {
+                    this._handlePageSearchHookBinding(p);
+                }
+                else if (method === "Network.requestWillBeSent") {
+                    const req = p.request;
+                    if (!req)
+                        return;
+                    const url = String(req.url ?? "");
+                    if (!(0, runner_page_session_search_parser_1.isLikelyDouyinSearchJsonResponse)(url))
+                        return;
+                    const requestId = String(p.requestId ?? "");
+                    const { offset, count } = parseSearchUrlOffsetCount(url);
+                    this._searchRequests.set(requestId, { url, offset, count });
+                }
+                else if (method === "Network.responseReceived") {
+                    const resp = p.response;
+                    if (!resp)
+                        return;
+                    const url = String(resp.url ?? "");
+                    const mimeType = String(resp.mimeType ?? "");
+                    if (!(0, runner_page_session_search_parser_1.isLikelyDouyinSearchJsonResponse)(url, mimeType))
+                        return;
+                    const requestId = String(p.requestId ?? "");
+                    const cur = this._searchRequests.get(requestId) ?? {
+                        url,
+                        offset: 0,
+                        count: 0,
+                    };
+                    cur.url = url;
+                    cur.mimeType = mimeType;
+                    cur.status = Number(resp.status ?? 0);
+                    this._searchResponseSeenCount += 1;
+                    this._lastSearchResponseStatus = Number.isFinite(cur.status) ? cur.status : null;
+                    this._lastSearchResponseBodyReadable = null;
+                    this._searchRequests.set(requestId, cur);
+                }
+                else if (method === "Network.loadingFinished") {
+                    const requestId = String(p.requestId ?? "");
+                    const meta = this._searchRequests.get(requestId);
+                    if (!meta)
+                        return;
+                    this._searchRequests.delete(requestId);
+                    this._fetchAndPublishSearchBody(requestId, meta).catch((err) => {
+                        this._lastSnifferError = err instanceof Error ? err.message : String(err);
+                        log.warn(`slot ${this._slotId} sniffer fetch body failed`, {
+                            msg: this._lastSnifferError,
+                        });
+                    });
+                }
+                else if (method === "Network.loadingFailed") {
+                    const requestId = String(p.requestId ?? "");
+                    if (this._searchRequests.has(requestId)) {
+                        this._searchRequests.delete(requestId);
+                    }
+                }
+            });
+            if (ENABLE_PAGE_SEARCH_HOOK) {
+                void this._installPageSearchHook(dbg);
+            }
+            else {
+                log.info(`slot ${this._slotId} page search hook disabled`);
+            }
+            dbg
+                .sendCommand("Network.enable")
+                .then(() => {
+                log.info(`slot ${this._slotId} cdp attached + Network.enable`);
+            })
+                .catch((err) => {
+                this._lastSnifferError = err instanceof Error ? err.message : String(err);
+                log.warn(`slot ${this._slotId} cdp Network.enable failed`, {
+                    msg: this._lastSnifferError,
+                });
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            this._lastSnifferError = msg;
+            this._debuggerAttached = false;
+            log.warn(`slot ${this._slotId} cdp attach failed`, { msg });
+        }
+    }
+    async _installPageSearchHook(dbg) {
+        if (this._pageSearchHookInstalled)
+            return;
+        try {
+            await dbg.sendCommand("Runtime.enable");
+            await dbg.sendCommand("Page.enable");
+            await dbg.sendCommand("Runtime.addBinding", {
+                name: DOUYIN_SEARCH_HOOK_BINDING,
+            });
+            await dbg.sendCommand("Page.addScriptToEvaluateOnNewDocument", {
+                source: page_scripts_1.DOUYIN_SEARCH_RESPONSE_HOOK_SCRIPT,
+            });
+            this._pageSearchHookInstalled = true;
+            log.info(`slot ${this._slotId} page search hook installed`);
+            const wc = this._win?.webContents;
+            if (wc && !wc.isDestroyed()) {
+                wc.executeJavaScript(page_scripts_1.DOUYIN_SEARCH_RESPONSE_HOOK_SCRIPT, true).catch((err) => {
+                    log.info(`slot ${this._slotId} current page search hook skipped`, {
+                        msg: err instanceof Error ? err.message : String(err),
+                    });
+                });
+            }
+        }
+        catch (err) {
+            log.warn(`slot ${this._slotId} page search hook install failed`, {
+                msg: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    _handlePageSearchHookBinding(params) {
+        if (String(params.name ?? "") !== DOUYIN_SEARCH_HOOK_BINDING)
+            return;
+        const rawPayload = String(params.payload ?? "");
+        if (!rawPayload || rawPayload.length > MAX_PAGE_HOOK_PAYLOAD_CHARS) {
+            log.warn(`slot ${this._slotId} page search hook payload ignored`, {
+                reason: rawPayload ? "payload_too_large" : "empty_payload",
+                payloadLength: rawPayload.length,
+            });
+            return;
+        }
+        let envelope;
+        try {
+            envelope = JSON.parse(rawPayload);
+        }
+        catch (err) {
+            log.warn(`slot ${this._slotId} page search hook envelope parse failed`, {
+                msg: err instanceof Error ? err.message : String(err),
+            });
+            return;
+        }
+        const url = String(envelope.url ?? "");
+        const contentType = String(envelope.contentType ?? "");
+        if (!(0, runner_page_session_search_parser_1.isLikelyDouyinSearchJsonResponse)(url, contentType))
+            return;
+        const bodyText = String(envelope.body ?? "");
+        this._searchResponseSeenCount += 1;
+        this._lastSearchResponseStatus = Number.isFinite(Number(envelope.status))
+            ? Number(envelope.status)
+            : null;
+        if (!bodyText || bodyText.length > MAX_PAGE_HOOK_PAYLOAD_CHARS) {
+            this._lastSearchResponseBodyReadable = false;
+            this._lastSearchResponseShape = bodyText ? "body_too_large" : "empty_body";
+            log.warn(`slot ${this._slotId} page search hook body ignored`, {
+                reason: bodyText ? "body_too_large" : "empty_body",
+                url: (0, runner_page_session_search_parser_1.redactSearchUrl)(url),
+            });
+            return;
+        }
+        let payload;
+        try {
+            payload = JSON.parse(bodyText);
+            this._lastSearchResponseBodyReadable = true;
+            this._lastSearchResponseShape = summarizePayloadShape(payload);
+        }
+        catch (err) {
+            this._lastSearchResponseBodyReadable = false;
+            this._lastSearchResponseShape = "json_parse_failed";
+            log.warn(`slot ${this._slotId} page search hook json parse failed`, {
+                msg: err instanceof Error ? err.message : String(err),
+                url: (0, runner_page_session_search_parser_1.redactSearchUrl)(url),
+            });
+            return;
+        }
+        const batch = (0, runner_page_session_search_parser_1.parseSearchItemPayload)(payload, {
+            url,
+            ...parseSearchUrlOffsetCount(url),
+        });
+        if (!batch)
+            return;
+        log.info(`slot ${this._slotId} page hook search batch`, {
+            source: String(envelope.source ?? "unknown"),
+            status: Number(envelope.status ?? 0),
+            offset: batch.offset,
+            count: batch.count,
+            sourceUrlPattern: batch.sourceUrlPattern,
+            parsedVideoCount: batch.parsedVideoCount,
+            items: batch.items.length,
+            hasMore: batch.hasMore,
+            verifyCheck: batch.verifyCheck,
+        });
+        this._publishSearchBatch(batch);
+    }
+    async _fetchAndPublishSearchBody(requestId, meta) {
+        if (!this._debuggerAttached || !this._debugger)
+            return;
+        let body;
+        try {
+            body = (await this._debugger.sendCommand("Network.getResponseBody", {
+                requestId,
+            }));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            this._lastSearchBodyUnavailableError = classifyCdpBodyError(msg);
+            this._lastSearchResponseBodyReadable = false;
+            this._lastSearchResponseShape = "body_unavailable";
+            log.warn(`slot ${this._slotId} getResponseBody throw`, {
+                requestId,
+                errorType: this._lastSearchBodyUnavailableError,
+                msg,
+                url: (0, runner_page_session_search_parser_1.redactSearchUrl)(meta.url),
+            });
+            return;
+        }
+        let raw;
+        try {
+            raw = body.base64Encoded ? Buffer.from(body.body, "base64").toString("utf8") : body.body;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            this._lastSearchResponseBodyReadable = false;
+            this._lastSearchResponseShape = "decode_failed";
+            log.warn(`slot ${this._slotId} decode response body failed`, {
+                requestId,
+                errorType: "decode_failed",
+                msg,
+                url: (0, runner_page_session_search_parser_1.redactSearchUrl)(meta.url),
+            });
+            return;
+        }
+        let payload;
+        try {
+            payload = JSON.parse(raw);
+            this._lastSearchResponseBodyReadable = true;
+            this._lastSearchResponseShape = summarizePayloadShape(payload);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            this._lastSearchResponseBodyReadable = false;
+            this._lastSearchResponseShape = "json_parse_failed";
+            log.warn(`slot ${this._slotId} sniffer parse json failed`, {
+                requestId,
+                errorType: "json_parse_failed",
+                msg,
+                url: (0, runner_page_session_search_parser_1.redactSearchUrl)(meta.url),
+                bodyHead: raw.slice(0, 80),
+            });
+            return;
+        }
+        const batch = (0, runner_page_session_search_parser_1.parseSearchItemPayload)(payload, meta);
+        if (!batch)
+            return;
+        log.info(`slot ${this._slotId} cdp search batch`, {
+            offset: batch.offset,
+            count: batch.count,
+            sourceUrlPattern: batch.sourceUrlPattern,
+            parsedVideoCount: batch.parsedVideoCount,
+            items: batch.items.length,
+            hasMore: batch.hasMore,
+            verifyCheck: batch.verifyCheck,
+        });
+        this._publishSearchBatch(batch);
+    }
+    _publishSearchBatch(batch) {
+        if (this._searchBatchWaiters.length > 0) {
+            const next = this._searchBatchWaiters.shift();
+            if (next) {
+                next(batch);
+                return;
+            }
+        }
+        this._searchBatches.push(batch);
+    }
+    _detachSearchSniffer() {
+        if (!this._debugger)
+            return;
+        try {
+            if (this._debugger.isAttached()) {
+                this._debugger.detach();
+            }
+        }
+        catch {
+        }
+        this._debugger = null;
+        this._debuggerAttached = false;
+        this._pageSearchHookInstalled = false;
+        this._pageSearchHookReady = null;
+        this._searchRequests.clear();
+        this._searchBatches.length = 0;
+        this._searchBatchWaiters.length = 0;
+    }
+    _assertAlive() {
+        if (this._crashed)
+            throw new Error("page crashed");
+        if (this._closed || !this._win || this._win.isDestroyed()) {
+            throw new Error("session already closed");
+        }
+    }
+}
+exports.RunnerPageSession = RunnerPageSession;
+function isNavigationAbortedError(err) {
+    const msg = err.message ?? "";
+    return /\bERR_ABORTED\b/i.test(msg) || /\(-3\)/.test(msg);
+}
+function parseSearchUrlOffsetCount(url) {
+    let offset = 0;
+    let count = 0;
+    try {
+        const u = new URL(url);
+        offset = Number(u.searchParams.get("offset") ?? 0) || 0;
+        count = Number(u.searchParams.get("count") ?? 0) || 0;
+    }
+    catch {
+    }
+    return { offset, count };
+}
+function classifyCdpBodyError(message) {
+    if (/no resource|not found|not available/i.test(message))
+        return "body_unavailable";
+    if (/frame|detached|navigation/i.test(message))
+        return "frame_detached";
+    if (/protocol/i.test(message))
+        return "protocol_error";
+    if (/timeout/i.test(message))
+        return "timeout";
+    return "unknown";
+}
+function isHttpLikeUrl(url) {
+    return /^(https?|about|data|blob):/i.test(String(url || ""));
+}
+function extractUrlScheme(url) {
+    const match = String(url || "").match(/^([a-z][a-z0-9+.-]*):/i);
+    return match ? match[1].toLowerCase() : "unknown";
+}
+async function safeJson(wc, script, label, timeoutMs) {
+    try {
+        const raw = timeoutMs
+            ? await withTimeout(wc.executeJavaScript(script, true), timeoutMs, () => `${label} timed out after ${timeoutMs}ms`)
+            : await wc.executeJavaScript(script, true);
+        if (!raw || typeof raw !== "object") {
+            return {
+                ok: false,
+                code: "page_invalid",
+                message: `${label} returned non-object`,
+            };
+        }
+        return raw;
+    }
+    catch (err) {
+        return {
+            ok: false,
+            code: "execute_throw",
+            message: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+//# sourceMappingURL=runner-page-session.js.map