sourceloop 0.1.1

package/dist/core/notebooklm/browser-agent.js

@@ -0,0 +1,1604 @@
+import { access } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import net from "node:net";
+import { chromium } from "playwright";
+import { NOTEBOOKLM_ADD_SOURCE_SELECTORS, NOTEBOOKLM_ANSWER_BODY_SELECTORS, NOTEBOOKLM_CITATION_SELECTORS, NOTEBOOKLM_CITATION_OVERFLOW_SELECTORS, NOTEBOOKLM_CITATION_POPOVER_SELECTORS, NOTEBOOKLM_CREATE_NOTEBOOK_SELECTORS, NOTEBOOKLM_DEFAULT_URL, NOTEBOOKLM_IMPORT_ERROR_SELECTORS, NOTEBOOKLM_IMPORT_FILE_INPUT_SELECTORS, NOTEBOOKLM_IMPORT_FILE_OPTION_SELECTORS, NOTEBOOKLM_INITIAL_SOURCE_INTAKE_SELECTORS, NOTEBOOKLM_IMPORT_SUCCESS_CANDIDATE_SELECTORS, NOTEBOOKLM_IMPORT_SUBMIT_SELECTORS, NOTEBOOKLM_IMPORT_URL_INPUT_SELECTORS, NOTEBOOKLM_IMPORT_URL_OPTION_SELECTORS, NOTEBOOKLM_NOTEBOOK_TITLE_INPUT_SELECTORS, NOTEBOOKLM_QUERY_INPUT_SELECTORS, NOTEBOOKLM_RESPONSE_SELECTORS, NOTEBOOKLM_SUBMIT_SELECTORS, NOTEBOOKLM_THINKING_SELECTOR } from "./config.js";
+import { extractCitationReferencesFromSnapshot, extractNormalizedAnswerFromSnapshot } from "./response-extraction.js";
+const NOTEBOOKLM_CITATION_OVERFLOW_PATTERNS = [
+    /^\.{3,}$/,
+    /^…$/,
+    /^more_horiz$/i,
+    /\bshow more\b/i,
+    /\bmore citations?\b/i,
+    /\bexpand\b/i,
+    /더보기/,
+    /펼치기/,
+    /추가/
+];
+const NOTEBOOKLM_NON_OVERFLOW_CONTROL_PATTERNS = [
+    /\bcopy\b/i,
+    /\bshare\b/i,
+    /\bretry\b/i,
+    /\brefresh\b/i,
+    /\bthumb/i,
+    /좋아요/,
+    /싫어요/,
+    /복사/,
+    /공유/
+];
+export function isLikelyCitationOverflowControl(candidate) {
+    const values = [
+        candidate.text,
+        candidate.ariaLabel,
+        candidate.title,
+        candidate.className,
+        candidate.dataTestId
+    ]
+        .map((value) => normalizeControlText(value))
+        .filter(Boolean);
+    if (values.length === 0) {
+        return false;
+    }
+    const combined = values.join(" | ");
+    if (NOTEBOOKLM_NON_OVERFLOW_CONTROL_PATTERNS.some((pattern) => pattern.test(combined))) {
+        return false;
+    }
+    return NOTEBOOKLM_CITATION_OVERFLOW_PATTERNS.some((pattern) => values.some((value) => pattern.test(value)));
+}
+export function shouldExpandCitationOverflowControl(candidate) {
+    return Boolean(candidate.citationAdjacent) && isLikelyCitationOverflowControl(candidate);
+}
+export function isLikelyNotebookLMCitationMarker(candidate) {
+    const text = normalizeControlText(candidate.text);
+    const ariaLabel = normalizeControlText(candidate.ariaLabel);
+    const dialogLabel = normalizeControlText(candidate.dialogLabel);
+    const triggerDescription = normalizeControlText(candidate.triggerDescription);
+    if (/^\d+$/.test(text)) {
+        return true;
+    }
+    if (/^\d+\s*:/.test(ariaLabel)) {
+        return true;
+    }
+    const combined = `${dialogLabel} ${triggerDescription}`.trim();
+    if (/citation|인용/i.test(combined)) {
+        return true;
+    }
+    return false;
+}
+export function hasNotebookLMCitationSnippet(note) {
+    const normalized = normalizeControlText(note);
+    if (!normalized) {
+        return false;
+    }
+    return normalized.split(" | ").length >= 3;
+}
+export class ChromeAttachValidationError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "ChromeAttachValidationError";
+    }
+}
+export async function disposeNotebookBrowserSessionResources(input) {
+    await input.closePage().catch(() => undefined);
+    await input.closeBrowserConnection().catch(() => undefined);
+    if (input.ownsBrowserProcess) {
+        await input.killSpawnedProcess?.();
+    }
+}
+export async function validateChromeAttachTarget(input) {
+    const sessionFactory = input.sessionFactory ?? defaultNotebookBrowserSessionFactory;
+    const session = await sessionFactory.createSession({
+        target: input.target,
+        ...(input.showBrowser !== undefined ? { showBrowser: input.showBrowser } : {})
+    });
+    try {
+        await session.preflight(input.notebookUrl);
+        return { ok: true };
+    }
+    catch (error) {
+        if (error instanceof ChromeAttachValidationError) {
+            return {
+                ok: false,
+                code: error.code,
+                message: error.message
+            };
+        }
+        throw error;
+    }
+    finally {
+        await session.close();
+    }
+}
+export const defaultNotebookBrowserSessionFactory = {
+    async createSession(input) {
+        return createPlaywrightNotebookBrowserSession(input);
+    }
+};
+async function createPlaywrightNotebookBrowserSession(input) {
+    const state = await connectToAttachedChrome(input.target, input.showBrowser ?? false);
+    const context = getDefaultContext(state.browser);
+    let page;
+    let ownsPage = false;
+    const ensurePage = async (notebookUrl) => {
+        if (page) {
+            return page;
+        }
+        if (input.reuseExistingNotebookPage && notebookUrl) {
+            const existingPage = await findReusableNotebookPage(context, notebookUrl);
+            if (existingPage) {
+                page = existingPage;
+                ownsPage = false;
+                return page;
+            }
+        }
+        page = await context.newPage();
+        ownsPage = true;
+        return page;
+    };
+    return {
+        async preflight(notebookUrl) {
+            const targetUrl = notebookUrl ?? NOTEBOOKLM_DEFAULT_URL;
+            const activePage = await ensurePage(targetUrl);
+            if (notebookUrl && input.reuseExistingNotebookPage && isNotebookPageMatch(activePage.url(), notebookUrl)) {
+                await activePage.bringToFront().catch(() => undefined);
+            }
+            else {
+                await openNotebookPage(activePage, targetUrl);
+            }
+            if (notebookUrl) {
+                await ensureNotebookAccessible(activePage);
+                await waitForNotebookSettled(activePage);
+                return;
+            }
+            await ensureNotebookHomeAccessible(activePage);
+        },
+        async askQuestion(question) {
+            const activePage = await ensurePage();
+            const inputSelector = await waitForFirstVisibleSelector(activePage, NOTEBOOKLM_QUERY_INPUT_SELECTORS, 10_000, "Could not find a visible NotebookLM query input.");
+            await waitForNotebookSettled(activePage, inputSelector);
+            const previousAnswer = await snapshotLatestResponse(activePage);
+            await clearQueryInput(activePage, inputSelector);
+            await setQueryInputText(activePage, inputSelector, question.prompt);
+            await submitQuery(activePage, inputSelector);
+            const latestElement = await waitForStableLatestResponse(activePage, previousAnswer);
+            await waitForStableCitationMetadata(latestElement);
+            let responseSnapshot = await collectResponseSnapshot(activePage, latestElement);
+            const answer = extractNormalizedAnswerFromSnapshot(responseSnapshot);
+            if (!answer) {
+                throw new Error(`NotebookLM returned an empty answer for question ${question.id}`);
+            }
+            let citations = extractCitationReferencesFromSnapshot(responseSnapshot.citationCandidates);
+            if (shouldRetryNotebookLMCitationCapture(citations)) {
+                const refreshedSnapshot = await recaptureLatestResponseSnapshot(activePage);
+                if (refreshedSnapshot) {
+                    const refreshedCitations = extractCitationReferencesFromSnapshot(refreshedSnapshot.citationCandidates);
+                    if (countRichNotebookLMCitations(refreshedCitations) > countRichNotebookLMCitations(citations)) {
+                        responseSnapshot = refreshedSnapshot;
+                        citations = refreshedCitations;
+                    }
+                }
+            }
+            return {
+                answer,
+                citations
+            };
+        },
+        async captureLatestAnswer() {
+            const activePage = await ensurePage();
+            await waitForNotebookSettled(activePage);
+            const latestElement = await waitForLatestVisibleResponse(activePage, 30_000);
+            if (!latestElement) {
+                throw new Error("Could not find a latest NotebookLM response to import.");
+            }
+            await waitForStableCitationMetadata(latestElement);
+            let responseSnapshot = await collectResponseSnapshot(activePage, latestElement);
+            const answer = extractNormalizedAnswerFromSnapshot(responseSnapshot);
+            if (!answer) {
+                throw new Error("NotebookLM did not expose a readable latest answer.");
+            }
+            let citations = extractCitationReferencesFromSnapshot(responseSnapshot.citationCandidates);
+            if (shouldRetryNotebookLMCitationCapture(citations)) {
+                const refreshedSnapshot = await recaptureLatestResponseSnapshot(activePage);
+                if (refreshedSnapshot) {
+                    const refreshedCitations = extractCitationReferencesFromSnapshot(refreshedSnapshot.citationCandidates);
+                    if (countRichNotebookLMCitations(refreshedCitations) > countRichNotebookLMCitations(citations)) {
+                        responseSnapshot = refreshedSnapshot;
+                        citations = refreshedCitations;
+                    }
+                }
+            }
+            return {
+                answer,
+                citations
+            };
+        },
+        async createNotebook(title) {
+            const activePage = await ensurePage();
+            await openNotebookPage(activePage, NOTEBOOKLM_DEFAULT_URL);
+            await ensureNotebookHomeAccessible(activePage);
+            await clickFirstVisibleLocator(activePage, NOTEBOOKLM_CREATE_NOTEBOOK_SELECTORS, "Could not find a NotebookLM create notebook control.");
+            await waitForNotebookUrl(activePage, 30_000);
+            await waitForNotebookSettled(activePage).catch(() => undefined);
+            await bestEffortFillNotebookTitle(activePage, title);
+            return {
+                notebookUrl: canonicalizeNotebookUrl(activePage.url())
+            };
+        },
+        async importSource(input) {
+            const activePage = await ensurePage(input.notebookUrl);
+            if (input.notebookUrl) {
+                if (isNotebookPageMatch(activePage.url(), input.notebookUrl)) {
+                    await activePage.bringToFront().catch(() => undefined);
+                }
+                else {
+                    await openNotebookPage(activePage, input.notebookUrl);
+                }
+            }
+            await ensureNotebookPageAccessible(activePage);
+            if (input.notebookUrl) {
+                ensureNotebookTargetMatch(activePage.url(), input.notebookUrl);
+            }
+            const importSurface = await waitForNotebookImportSurface(activePage);
+            const baselineCandidates = await captureImportSuccessCandidates(activePage).catch(() => []);
+            const baselineSourceCount = await captureVisibleSourceCount(activePage).catch(() => undefined);
+            try {
+                if (importSurface === "add_source") {
+                    const clickedAddSource = await bestEffortClickAny(activePage, NOTEBOOKLM_ADD_SOURCE_SELECTORS);
+                    if (!clickedAddSource && !(await hasVisibleSelector(activePage, NOTEBOOKLM_INITIAL_SOURCE_INTAKE_SELECTORS))) {
+                        throw new Error("Could not find a NotebookLM add source control.");
+                    }
+                    await waitForImportChoiceSurface(activePage, 5_000);
+                }
+                if (input.importKind === "file_upload") {
+                    if (!(await hasVisibleSelector(activePage, NOTEBOOKLM_IMPORT_FILE_INPUT_SELECTORS))) {
+                        await bestEffortClickAny(activePage, NOTEBOOKLM_IMPORT_FILE_OPTION_SELECTORS);
+                    }
+                    const fileSelector = await waitForFirstExistingSelector(activePage, NOTEBOOKLM_IMPORT_FILE_INPUT_SELECTORS, 10_000);
+                    await activePage.locator(fileSelector).first().setInputFiles(input.filePath);
+                }
+                else {
+                    if (!(await hasVisibleSelector(activePage, NOTEBOOKLM_IMPORT_URL_INPUT_SELECTORS))) {
+                        await bestEffortClickAny(activePage, NOTEBOOKLM_IMPORT_URL_OPTION_SELECTORS);
+                    }
+                    const urlSelector = await waitForFirstVisibleSelector(activePage, NOTEBOOKLM_IMPORT_URL_INPUT_SELECTORS, 10_000, "Could not find a visible NotebookLM URL input control.");
+                    await clearInputLike(activePage, urlSelector);
+                    await fillInputLike(activePage, urlSelector, input.url);
+                    await clickFirstVisibleLocator(activePage, NOTEBOOKLM_IMPORT_SUBMIT_SELECTORS, "Could not find a NotebookLM import submit control.");
+                }
+                return await waitForImportOutcome(activePage, baselineCandidates, baselineSourceCount, input, importSurface, 12_000);
+            }
+            catch (error) {
+                return {
+                    status: "failed",
+                    failureReason: formatError(error)
+                };
+            }
+        },
+        async close() {
+            const spawnedProcess = state.spawnedProcess;
+            const killSpawnedProcess = spawnedProcess
+                ? async () => {
+                    await terminateSpawnedChromeProcess(spawnedProcess);
+                }
+                : undefined;
+            await disposeNotebookBrowserSessionResources({
+                closePage: () => (page && ownsPage ? page.close() : Promise.resolve()),
+                closeBrowserConnection: () => state.browser.close(),
+                ownsBrowserProcess: state.ownsBrowser,
+                ...(killSpawnedProcess ? { killSpawnedProcess } : {})
+            });
+        }
+    };
+}
+async function findReusableNotebookPage(context, notebookUrl) {
+    const targetPath = normalizeNotebookPath(notebookUrl);
+    if (!targetPath) {
+        return undefined;
+    }
+    return context.pages().find((candidatePage) => isNotebookPageMatch(candidatePage.url(), notebookUrl));
+}
+export function isNotebookPageMatch(currentUrl, notebookUrl) {
+    return normalizeNotebookPath(currentUrl) === normalizeNotebookPath(notebookUrl);
+}
+export function canonicalizeNotebookUrl(url) {
+    try {
+        const parsed = new URL(url);
+        parsed.searchParams.delete("addSource");
+        parsed.hash = "";
+        const search = parsed.searchParams.toString();
+        return `${parsed.origin}${parsed.pathname}${search ? `?${search}` : ""}`.replace(/\/+$/, "");
+    }
+    catch {
+        return url;
+    }
+}
+export function extractNotebookResourceId(url) {
+    try {
+        const parsed = new URL(canonicalizeNotebookUrl(url));
+        const segments = parsed.pathname.split("/").filter(Boolean);
+        const notebookIndex = segments.findIndex((segment) => segment === "notebook");
+        if (notebookIndex === -1) {
+            return undefined;
+        }
+        const resourceId = segments[notebookIndex + 1];
+        return resourceId?.trim() ? resourceId : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function normalizeNotebookPath(url) {
+    try {
+        return canonicalizeNotebookUrl(url).replace(/\?.*$/, "");
+    }
+    catch {
+        return undefined;
+    }
+}
+export function ensureNotebookTargetMatch(currentUrl, notebookUrl) {
+    if (isNotebookPageMatch(currentUrl, notebookUrl)) {
+        return;
+    }
+    throw new Error(`NotebookLM did not open the requested notebook. Expected ${canonicalizeNotebookUrl(notebookUrl)}, but landed on ${canonicalizeNotebookUrl(currentUrl)}.`);
+}
+async function connectToAttachedChrome(target, showBrowser) {
+    if (target.targetType === "remote_debugging_endpoint") {
+        try {
+            const browser = await chromium.connectOverCDP(target.endpoint);
+            return { browser, ownsBrowser: false };
+        }
+        catch (error) {
+            throw new ChromeAttachValidationError("chrome_unreachable", `Could not reach Chrome remote debugging endpoint ${target.endpoint}: ${formatError(error)}`);
+        }
+    }
+    return launchProfileChrome(target, showBrowser);
+}
+async function launchProfileChrome(target, showBrowser) {
+    const port = target.remoteDebuggingPort ?? (await allocateFreePort());
+    const endpoint = `http://127.0.0.1:${port}`;
+    try {
+        const browser = await chromium.connectOverCDP(endpoint);
+        return { browser, ownsBrowser: false };
+    }
+    catch {
+        // no running endpoint for this profile target; fall back to launching Chrome
+    }
+    const executablePath = await resolveChromeExecutablePath(target.chromeExecutablePath);
+    const launchArgs = [
+        `--user-data-dir=${target.profileDirPath}`,
+        `--remote-debugging-port=${port}`,
+        "--no-first-run",
+        "--no-default-browser-check",
+        ...(showBrowser ? [] : ["--headless=new"]),
+        ...target.launchArgs,
+        NOTEBOOKLM_DEFAULT_URL
+    ];
+    const spawnedProcess = spawn(executablePath, launchArgs, {
+        stdio: "ignore"
+    });
+    try {
+        await waitForRemoteDebuggingEndpoint(endpoint, 15_000);
+        const browser = await chromium.connectOverCDP(endpoint);
+        return { browser, spawnedProcess, ownsBrowser: true };
+    }
+    catch (error) {
+        spawnedProcess.kill("SIGTERM");
+        throw new ChromeAttachValidationError("chrome_unreachable", `Could not launch Chrome from profile ${target.profileDirPath}: ${formatError(error)}`);
+    }
+}
+const GRACEFUL_CHROME_SHUTDOWN_TIMEOUT_MS = 5_000;
+const FORCEFUL_CHROME_SHUTDOWN_TIMEOUT_MS = 2_000;
+async function terminateSpawnedChromeProcess(spawnedProcess) {
+    if (spawnedProcess.exitCode !== null || spawnedProcess.signalCode !== null) {
+        return;
+    }
+    const exitPromise = waitForChildProcessExit(spawnedProcess);
+    const terminatedGracefully = requestChildProcessSignal(spawnedProcess, "SIGTERM");
+    if (!terminatedGracefully && spawnedProcess.exitCode === null && spawnedProcess.signalCode === null) {
+        return;
+    }
+    if (await waitForChildProcessExitWithin(exitPromise, GRACEFUL_CHROME_SHUTDOWN_TIMEOUT_MS)) {
+        return;
+    }
+    requestChildProcessSignal(spawnedProcess, "SIGKILL");
+    await waitForChildProcessExitWithin(exitPromise, FORCEFUL_CHROME_SHUTDOWN_TIMEOUT_MS);
+}
+function requestChildProcessSignal(spawnedProcess, signal) {
+    try {
+        return spawnedProcess.kill(signal);
+    }
+    catch {
+        return false;
+    }
+}
+function waitForChildProcessExit(spawnedProcess) {
+    if (spawnedProcess.exitCode !== null || spawnedProcess.signalCode !== null) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+        const finalize = () => {
+            spawnedProcess.off("close", finalize);
+            spawnedProcess.off("exit", finalize);
+            spawnedProcess.off("error", finalize);
+            resolve();
+        };
+        spawnedProcess.once("close", finalize);
+        spawnedProcess.once("exit", finalize);
+        spawnedProcess.once("error", finalize);
+    });
+}
+async function waitForChildProcessExitWithin(exitPromise, timeoutMs) {
+    return Promise.race([
+        exitPromise.then(() => true),
+        sleep(timeoutMs).then(() => false)
+    ]);
+}
+export async function resolveChromeExecutablePath(customPath) {
+    const candidates = customPath
+        ? [customPath]
+        : process.platform === "darwin"
+            ? ["/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"]
+            : process.platform === "win32"
+                ? [
+                    "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+                    "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe"
+                ]
+                : ["/usr/bin/google-chrome", "/usr/bin/google-chrome-stable", "/usr/bin/chromium-browser", "/usr/bin/chromium"];
+    for (const candidate of candidates) {
+        try {
+            await access(candidate);
+            return candidate;
+        }
+        catch { }
+    }
+    throw new Error("Could not resolve a Google Chrome executable path. Provide --chrome-path when registering the attach target.");
+}
+export async function allocateFreePort() {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.on("error", reject);
+        server.listen(0, "127.0.0.1", () => {
+            const address = server.address();
+            if (!address || typeof address === "string") {
+                reject(new Error("Could not allocate a free TCP port."));
+                return;
+            }
+            const port = address.port;
+            server.close((error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve(port);
+            });
+        });
+    });
+}
+export async function waitForRemoteDebuggingEndpoint(endpoint, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        try {
+            const response = await fetch(`${endpoint}/json/version`);
+            if (response.ok) {
+                return;
+            }
+        }
+        catch { }
+        await sleep(250);
+    }
+    throw new Error(`Timed out waiting for Chrome remote debugging endpoint at ${endpoint}`);
+}
+function getDefaultContext(browser) {
+    const [defaultContext] = browser.contexts();
+    if (!defaultContext) {
+        throw new ChromeAttachValidationError("chrome_unreachable", "Chrome attached successfully but did not expose a default browser context.");
+    }
+    return defaultContext;
+}
+async function openNotebookPage(page, url) {
+    try {
+        await page.goto(url, { waitUntil: "domcontentloaded" });
+    }
+    catch (error) {
+        if (!(error instanceof Error) || !error.message.includes("ERR_INVALID_ARGUMENT")) {
+            throw error;
+        }
+        await page.goto(url, { waitUntil: "domcontentloaded" });
+    }
+}
+async function ensureNotebookAccessible(page) {
+    await ensureNotebookPageAccessible(page);
+    try {
+        await waitForFirstVisibleSelector(page, NOTEBOOKLM_QUERY_INPUT_SELECTORS, 10_000, "Could not find a visible NotebookLM query input.");
+    }
+    catch (error) {
+        if (await looksLikeSignInPage(page)) {
+            throw new ChromeAttachValidationError("notebooklm_sign_in_required", "Chrome is reachable, but NotebookLM is not ready because the session is not signed in.");
+        }
+        throw new ChromeAttachValidationError("notebooklm_preflight_failed", `Chrome is reachable, but NotebookLM is not usable yet: ${formatError(error)}`);
+    }
+}
+async function ensureNotebookHomeAccessible(page) {
+    await page.waitForLoadState("domcontentloaded");
+    await sleep(750);
+    const currentUrl = page.url();
+    if (!currentUrl.startsWith("https://notebooklm.google.com/")) {
+        if (currentUrl.includes("accounts.google.com")) {
+            throw new ChromeAttachValidationError("notebooklm_sign_in_required", "Chrome is reachable, but NotebookLM redirected to Google sign-in. Sign in to NotebookLM in this Chrome target first.");
+        }
+        throw new ChromeAttachValidationError("notebooklm_preflight_failed", `Chrome is reachable, but NotebookLM home did not open successfully: ${currentUrl}`);
+    }
+}
+async function ensureNotebookPageAccessible(page) {
+    await page.waitForLoadState("domcontentloaded");
+    await sleep(750);
+    const currentUrl = page.url();
+    if (!currentUrl.startsWith("https://notebooklm.google.com/")) {
+        if (currentUrl.includes("accounts.google.com")) {
+            throw new ChromeAttachValidationError("notebooklm_sign_in_required", "Chrome is reachable, but NotebookLM redirected to Google sign-in. Sign in to NotebookLM in this Chrome target first.");
+        }
+        throw new ChromeAttachValidationError("notebooklm_preflight_failed", `Chrome is reachable, but NotebookLM did not open successfully: ${currentUrl}`);
+    }
+}
+async function waitForNotebookSettled(page, knownInputSelector) {
+    await page.waitForLoadState("domcontentloaded");
+    await page.waitForLoadState("networkidle", { timeout: 5_000 }).catch(() => undefined);
+    const inputSelector = knownInputSelector ??
+        (await waitForFirstVisibleSelector(page, NOTEBOOKLM_QUERY_INPUT_SELECTORS, 10_000, "Could not find a visible NotebookLM query input."));
+    await waitForUsableQueryInput(page, inputSelector, 10_000);
+    await scrollNotebookToLatest(page);
+    await sleep(1_000);
+}
+async function looksLikeSignInPage(page) {
+    const text = (await page.textContent("body").catch(() => null))?.toLowerCase() ?? "";
+    return text.includes("sign in") || text.includes("로그인") || text.includes("continue to");
+}
+async function waitForFirstVisibleSelector(page, selectors, timeout = 10_000, errorMessage = "Could not find a visible NotebookLM control.") {
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+        for (const selector of selectors) {
+            try {
+                const element = await page.$(selector);
+                if (element && (await element.isVisible())) {
+                    return selector;
+                }
+            }
+            catch { }
+        }
+        await sleep(250);
+    }
+    throw new Error(errorMessage);
+}
+async function waitForNotebookImportSurface(page, timeout = 10_000) {
+    const deadline = Date.now() + timeout;
+    const initialIntakeAssumptionThreshold = Date.now() + 2_000;
+    while (Date.now() < deadline) {
+        if (await looksLikeNotebookHomePage(page)) {
+            throw new Error("NotebookLM rendered the home notebook list instead of the requested notebook detail view.");
+        }
+        if (page.url().includes("addSource=true") ||
+            (await hasVisibleSelector(page, NOTEBOOKLM_INITIAL_SOURCE_INTAKE_SELECTORS))) {
+            return "initial_source_intake";
+        }
+        if (await hasVisibleSelector(page, NOTEBOOKLM_ADD_SOURCE_SELECTORS)) {
+            return "add_source";
+        }
+        if (Date.now() >= initialIntakeAssumptionThreshold &&
+            (await looksLikeEmptyNotebookDetail(page))) {
+            return "initial_source_intake";
+        }
+        if (await looksLikeSignInPage(page)) {
+            throw new ChromeAttachValidationError("notebooklm_sign_in_required", "Chrome is reachable, but NotebookLM is not ready because the session is not signed in.");
+        }
+        await sleep(250);
+    }
+    throw new Error("Could not find a NotebookLM source import control.");
+}
+async function waitForImportChoiceSurface(page, timeout = 5_000) {
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+        if ((await hasVisibleSelector(page, NOTEBOOKLM_IMPORT_URL_OPTION_SELECTORS)) ||
+            (await hasVisibleSelector(page, NOTEBOOKLM_IMPORT_URL_INPUT_SELECTORS)) ||
+            (await hasVisibleSelector(page, NOTEBOOKLM_IMPORT_FILE_OPTION_SELECTORS)) ||
+            (await hasVisibleSelector(page, NOTEBOOKLM_IMPORT_FILE_INPUT_SELECTORS))) {
+            return;
+        }
+        await sleep(100);
+    }
+}
+async function looksLikeNotebookHomePage(page) {
+    const normalizedPath = normalizeNotebookPath(page.url()) ?? "";
+    if (normalizedPath.includes("/notebook/")) {
+        return false;
+    }
+    return hasVisibleSelector(page, NOTEBOOKLM_CREATE_NOTEBOOK_SELECTORS);
+}
+async function looksLikeEmptyNotebookDetail(page) {
+    const normalizedPath = normalizeNotebookPath(page.url()) ?? "";
+    if (!normalizedPath.includes("/notebook/")) {
+        return false;
+    }
+    if (await hasVisibleSelector(page, NOTEBOOKLM_QUERY_INPUT_SELECTORS)) {
+        return false;
+    }
+    if (await hasVisibleSelector(page, NOTEBOOKLM_ADD_SOURCE_SELECTORS)) {
+        return false;
+    }
+    return true;
+}
+async function hasVisibleSelector(page, selectors) {
+    for (const selector of selectors) {
+        try {
+            const locator = page.locator(selector).first();
+            if ((await locator.count()) > 0 && (await locator.isVisible())) {
+                return true;
+            }
+        }
+        catch { }
+    }
+    return false;
+}
+async function clickFirstVisibleLocator(page, selectors, errorMessage) {
+    for (const selector of selectors) {
+        const locator = page.locator(selector).first();
+        try {
+            if ((await locator.count()) > 0 && (await locator.isVisible()) && (await isActionableLocator(locator))) {
+                await locator.click();
+                return;
+            }
+        }
+        catch { }
+    }
+    throw new Error(errorMessage);
+}
+async function waitForFirstExistingSelector(page, selectors, timeout = 10_000) {
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+        for (const selector of selectors) {
+            try {
+                if ((await page.locator(selector).count()) > 0) {
+                    return selector;
+                }
+            }
+            catch { }
+        }
+        await sleep(250);
+    }
+    throw new Error("Could not find a matching NotebookLM control.");
+}
+async function bestEffortClickAny(page, selectors) {
+    for (const selector of selectors) {
+        const locator = page.locator(selector).first();
+        try {
+            if ((await locator.count()) > 0 && (await locator.isVisible()) && (await isActionableLocator(locator))) {
+                await locator.click();
+                return true;
+            }
+        }
+        catch { }
+    }
+    return false;
+}
+async function isActionableLocator(locator) {
+    try {
+        return await locator.evaluate((element) => {
+            const candidate = element;
+            if (candidate.disabled) {
+                return false;
+            }
+            const ariaDisabled = candidate.getAttribute("aria-disabled");
+            return ariaDisabled !== "true";
+        });
+    }
+    catch {
+        return false;
+    }
+}
+async function waitForUsableQueryInput(page, selector, timeout = 10_000) {
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+        try {
+            const handle = await page.$(selector);
+            if (handle && (await handle.isVisible())) {
+                const isUsable = await handle.evaluate((node) => {
+                    const textarea = node;
+                    return !textarea.disabled && !textarea.readOnly;
+                });
+                if (isUsable) {
+                    return;
+                }
+            }
+        }
+        catch { }
+        await sleep(250);
+    }
+    throw new Error("NotebookLM query input did not become usable in time.");
+}
+async function waitForNotebookUrl(page, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const currentUrl = page.url();
+        if (normalizeNotebookPath(currentUrl)?.includes("/notebook/")) {
+            return;
+        }
+        await sleep(250);
+    }
+    throw new Error("Timed out waiting for NotebookLM to open a notebook page.");
+}
+async function bestEffortFillNotebookTitle(page, title) {
+    for (const selector of NOTEBOOKLM_NOTEBOOK_TITLE_INPUT_SELECTORS) {
+        const locator = page.locator(selector).first();
+        try {
+            if ((await locator.count()) > 0 && (await locator.isVisible())) {
+                await clearInputLike(page, selector);
+                await fillInputLike(page, selector, title);
+                await page.keyboard.press("Enter").catch(() => undefined);
+                return;
+            }
+        }
+        catch { }
+    }
+}
+async function snapshotLatestResponse(page) {
+    const latestElement = await getLatestResponseElement(page);
+    if (latestElement) {
+        const text = extractNormalizedAnswerFromSnapshot(await collectResponseTextSnapshot(latestElement));
+        if (text) {
+            return text;
+        }
+    }
+    return null;
+}
+async function getLatestResponseElement(page) {
+    for (const selector of NOTEBOOKLM_RESPONSE_SELECTORS) {
+        const elements = await page.$$(selector);
+        const latestElement = elements[elements.length - 1];
+        if (latestElement) {
+            return latestElement;
+        }
+    }
+    return null;
+}
+async function waitForLatestVisibleResponse(page, timeout) {
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+        await scrollNotebookToLatest(page);
+        const latestElement = await getLatestResponseElement(page);
+        if (latestElement) {
+            try {
+                if (await latestElement.isVisible()) {
+                    const text = extractNormalizedAnswerFromSnapshot(await collectResponseTextSnapshot(latestElement));
+                    if (text) {
+                        return latestElement;
+                    }
+                }
+            }
+            catch { }
+        }
+        await sleep(250);
+    }
+    return null;
+}
+async function scrollNotebookToLatest(page) {
+    await page
+        .evaluate(() => {
+        const g = globalThis;
+        const scrollingElement = g.document.scrollingElement ?? g.document.documentElement ?? g.document.body;
+        scrollingElement.scrollTo?.({ top: scrollingElement.scrollHeight, behavior: "instant" });
+        g.scrollTo({ top: g.document.body.scrollHeight, behavior: "instant" });
+    })
+        .catch(() => undefined);
+}
+async function waitForStableLatestResponse(page, previousAnswer) {
+    const deadline = Date.now() + 120_000;
+    let stableCount = 0;
+    let latestText = null;
+    let latestElement = null;
+    while (Date.now() < deadline) {
+        const thinkingElement = await page.$(NOTEBOOKLM_THINKING_SELECTOR);
+        if (thinkingElement && (await thinkingElement.isVisible())) {
+            await sleep(500);
+            continue;
+        }
+        for (const selector of NOTEBOOKLM_RESPONSE_SELECTORS) {
+            const elements = await page.$$(selector);
+            const candidate = elements[elements.length - 1];
+            if (!candidate) {
+                continue;
+            }
+            const candidateText = extractNormalizedAnswerFromSnapshot(await collectResponseTextSnapshot(candidate));
+            if (!candidateText || candidateText === previousAnswer) {
+                continue;
+            }
+            if (candidateText === latestText) {
+                stableCount += 1;
+            }
+            else {
+                latestText = candidateText;
+                latestElement = candidate;
+                stableCount = 1;
+            }
+            if (stableCount >= 3 && latestElement) {
+                await scrollNotebookToLatest(page);
+                return (await getLatestResponseElement(page)) ?? latestElement;
+            }
+        }
+        await sleep(500);
+    }
+    throw new Error("Timed out waiting for NotebookLM to return a stable answer.");
+}
+const EMPTY_CITATION_METADATA_SETTLE_POLLS = 6;
+export function shouldTreatCitationMetadataAsSettled(input) {
+    const signature = normalizeControlText(input.signature);
+    const latestSignature = normalizeControlText(input.latestSignature);
+    if (!signature) {
+        const emptyStableCount = latestSignature ? 1 : input.emptyStableCount + 1;
+        return {
+            stableCount: 0,
+            emptyStableCount,
+            settled: emptyStableCount >= EMPTY_CITATION_METADATA_SETTLE_POLLS
+        };
+    }
+    const stableCount = signature === latestSignature ? input.stableCount + 1 : 1;
+    return {
+        stableCount,
+        emptyStableCount: 0,
+        settled: stableCount >= 3
+    };
+}
+async function waitForStableCitationMetadata(element, timeoutMs = 6_000) {
+    const deadline = Date.now() + timeoutMs;
+    let stableCount = 0;
+    let emptyStableCount = 0;
+    let latestSignature = "";
+    while (Date.now() < deadline) {
+        const signature = await element
+            .evaluate((root) => {
+            const normalize = (value) => (value ?? "").replace(/\u00a0/g, " ").replace(/\s+/g, " ").trim();
+            const markers = [...root.querySelectorAll(".citation-marker")].map((node) => {
+                const elementNode = node;
+                const text = normalize(elementNode.innerText || elementNode.textContent || "");
+                const ariaNode = elementNode.querySelector?.("[aria-label]");
+                const ariaLabel = normalize(elementNode.getAttribute?.("aria-label") || ariaNode?.getAttribute?.("aria-label") || "");
+                const dialogLabel = normalize(elementNode.getAttribute?.("dialoglabel"));
+                const triggerDescription = normalize(elementNode.getAttribute?.("triggerdescription"));
+                const real = /^\d+$/.test(text) || /^\d+\s*:/.test(ariaLabel) || /citation|인용/i.test(`${dialogLabel} ${triggerDescription}`.trim());
+                if (!real) {
+                    return "";
+                }
+                return `${text}|${ariaLabel}|${dialogLabel}|${triggerDescription}`;
+            });
+            return markers.filter(Boolean).join("||");
+        })
+            .catch(() => "");
+        const state = shouldTreatCitationMetadataAsSettled({
+            signature,
+            latestSignature,
+            stableCount,
+            emptyStableCount
+        });
+        stableCount = state.stableCount;
+        emptyStableCount = state.emptyStableCount;
+        latestSignature = normalizeControlText(signature);
+        if (state.settled) {
+            return;
+        }
+        await sleep(250);
+    }
+}
+export function countRichNotebookLMCitations(citations) {
+    return citations.filter((citation) => hasNotebookLMCitationSnippet(citation.note)).length;
+}
+export function shouldRetryNotebookLMCitationCapture(citations) {
+    if (citations.length < 3) {
+        return false;
+    }
+    return countRichNotebookLMCitations(citations) < Math.min(3, citations.length);
+}
+async function recaptureLatestResponseSnapshot(page) {
+    const notebookUrl = page.url();
+    if (!normalizeNotebookPath(notebookUrl)?.includes("/notebook/")) {
+        return undefined;
+    }
+    await openNotebookPage(page, notebookUrl);
+    await ensureNotebookAccessible(page);
+    await waitForNotebookSettled(page);
+    await sleep(3_000);
+    const latestElement = await waitForLatestVisibleResponse(page, 30_000);
+    if (!latestElement) {
+        return undefined;
+    }
+    await waitForStableCitationMetadata(latestElement, 4_000);
+    return collectResponseSnapshot(page, latestElement);
+}
+async function collectResponseTextSnapshot(element) {
+    return element.evaluate((root, selectors) => {
+        const normalize = (value) => (value ?? "").replace(/\u00a0/g, " ").trim();
+        const dedupe = (items, key) => {
+            const seen = new Set();
+            return items.filter((item) => {
+                const itemKey = key(item);
+                if (!itemKey || seen.has(itemKey)) {
+                    return false;
+                }
+                seen.add(itemKey);
+                return true;
+            });
+        };
+        const queryAll = (scope, selector) => scope.querySelectorAll ? [...scope.querySelectorAll(selector)] : [];
+        const extractMarkerLabels = (scope) => {
+            const markerNodes = queryAll(scope, ".citation-marker, .citation-marker [aria-label]");
+            const labels = markerNodes
+                .map((node) => {
+                const elementNode = node;
+                const ariaLabel = normalize(elementNode.getAttribute?.("aria-label"));
+                const text = normalize(elementNode.innerText || elementNode.textContent || "");
+                const numbered = ariaLabel.match(/^(\d+)\s*:/);
+                if (numbered?.[1]) {
+                    return numbered[1];
+                }
+                if (/^\d+$/.test(text)) {
+                    return text;
+                }
+                return "";
+            })
+                .filter((value, index, array) => value && array.indexOf(value) === index);
+            return labels;
+        };
+        const extractMarkerLabel = (scope) => {
+            const ariaLabel = normalize(scope.getAttribute?.("aria-label"));
+            const text = normalize(scope.innerText || scope.textContent || "");
+            const numbered = ariaLabel.match(/^(\d+)\s*:/);
+            if (numbered?.[1]) {
+                return numbered[1];
+            }
+            if (/^\d+$/.test(text)) {
+                return text;
+            }
+            return "";
+        };
+        const serializeBodyNode = (scope) => {
+            if (scope.nodeType === 3) {
+                return scope.textContent ?? "";
+            }
+            if (scope.matches?.(".citation-marker, .citation-marker [aria-label]")) {
+                const label = extractMarkerLabel(scope);
+                return label ? `[${label}]` : "";
+            }
+            const childNodes = scope.childNodes ? [...scope.childNodes] : [];
+            if (childNodes.length === 0) {
+                return scope.textContent ?? "";
+            }
+            return childNodes.map((child) => serializeBodyNode(child)).join("");
+        };
+        const bodyTexts = dedupe(selectors.answerBodySelectors.flatMap((selector) => queryAll(root, selector).map((node) => {
+            const elementNode = node;
+            const text = normalize(serializeBodyNode(elementNode));
+            if (!text) {
+                return "";
+            }
+            return text;
+        })), (item) => item);
+        const rootNode = root;
+        return {
+            responseText: normalize(rootNode.innerText || rootNode.textContent || ""),
+            bodyTexts,
+            citationCandidates: []
+        };
+    }, {
+        answerBodySelectors: NOTEBOOKLM_ANSWER_BODY_SELECTORS
+    });
+}
+async function collectResponseSnapshot(page, element) {
+    const markerAttribute = "data-sourceloop-citation-marker";
+    const overflowAttribute = "data-sourceloop-citation-overflow";
+    await expandCitationOverflowControls(page, element, overflowAttribute);
+    const snapshotElement = (await getLatestResponseElement(page)) ?? element;
+    const snapshot = await snapshotElement.evaluate((root, selectors) => {
+        const normalize = (value) => (value ?? "").replace(/\u00a0/g, " ").trim();
+        const dedupe = (items, key) => {
+            const seen = new Set();
+            return items.filter((item) => {
+                const itemKey = key(item);
+                if (!itemKey || seen.has(itemKey)) {
+                    return false;
+                }
+                seen.add(itemKey);
+                return true;
+            });
+        };
+        const queryAll = (scope, selector) => scope.querySelectorAll ? [...scope.querySelectorAll(selector)] : [];
+        const extractMarkerLabels = (scope) => {
+            const markerNodes = queryAll(scope, ".citation-marker, .citation-marker [aria-label]");
+            const labels = markerNodes
+                .map((node) => {
+                const elementNode = node;
+                const ariaLabel = normalize(elementNode.getAttribute?.("aria-label"));
+                const text = normalize(elementNode.innerText || elementNode.textContent || "");
+                const numbered = ariaLabel.match(/^(\d+)\s*:/);
+                if (numbered?.[1]) {
+                    return numbered[1];
+                }
+                if (/^\d+$/.test(text)) {
+                    return text;
+                }
+                return "";
+            })
+                .filter((value, index, array) => value && array.indexOf(value) === index);
+            return labels;
+        };
+        const extractMarkerLabel = (scope) => {
+            const ariaLabel = normalize(scope.getAttribute?.("aria-label"));
+            const text = normalize(scope.innerText || scope.textContent || "");
+            const numbered = ariaLabel.match(/^(\d+)\s*:/);
+            if (numbered?.[1]) {
+                return numbered[1];
+            }
+            if (/^\d+$/.test(text)) {
+                return text;
+            }
+            return "";
+        };
+        const serializeBodyNode = (scope) => {
+            if (scope.nodeType === 3) {
+                return scope.textContent ?? "";
+            }
+            if (scope.matches?.(".citation-marker, .citation-marker [aria-label]")) {
+                const label = extractMarkerLabel(scope);
+                return label ? `[${label}]` : "";
+            }
+            const childNodes = scope.childNodes ? [...scope.childNodes] : [];
+            if (childNodes.length === 0) {
+                return scope.textContent ?? "";
+            }
+            return childNodes.map((child) => serializeBodyNode(child)).join("");
+        };
+        const getFirstMeaningfulDescendantAriaLabel = (scope) => {
+            const ariaNodes = queryAll(scope, "[aria-label]");
+            for (const node of ariaNodes) {
+                const elementNode = node;
+                const ariaLabel = normalize(elementNode.getAttribute?.("aria-label"));
+                if (ariaLabel) {
+                    return ariaLabel;
+                }
+            }
+            return "";
+        };
+        const bodyTexts = dedupe(selectors.answerBodySelectors.flatMap((selector) => queryAll(root, selector).map((node) => {
+            const elementNode = node;
+            const text = normalize(serializeBodyNode(elementNode));
+            if (!text) {
+                return "";
+            }
+            return text;
+        })), (item) => item);
+        let markerCounter = 0;
+        const citationCandidates = dedupe(queryAll(root, ".citation-marker")
+            .map((node) => {
+            const markerNode = node;
+            const text = normalize(markerNode.innerText || markerNode.textContent || "");
+            const ariaLabel = normalize(markerNode.getAttribute?.("aria-label")) || getFirstMeaningfulDescendantAriaLabel(markerNode);
+            const dialogLabel = normalize(markerNode.getAttribute?.("dialoglabel"));
+            const triggerDescription = normalize(markerNode.getAttribute?.("triggerdescription"));
+            if (!selectors.citationSelectors.some((selector) => markerNode.matches?.(selector) || queryAll(markerNode, selector).length > 0) ||
+                !(/^\d+$/.test(text) ||
+                    /^\d+\s*:/.test(ariaLabel) ||
+                    /citation|인용/i.test(`${dialogLabel} ${triggerDescription}`.trim()))) {
+                return undefined;
+            }
+            let markerId = normalize(markerNode.getAttribute?.(selectors.markerAttribute));
+            if (!markerId) {
+                markerCounter += 1;
+                markerId = `marker-${markerCounter}`;
+                markerNode.setAttribute?.(selectors.markerAttribute, markerId);
+            }
+            return {
+                text,
+                ariaLabel,
+                title: normalize(markerNode.getAttribute?.("title") ?? markerNode.title),
+                href: normalize(markerNode.getAttribute?.("href") ?? markerNode.href),
+                markerId,
+                selector: ".citation-marker",
+                dialogLabel,
+                triggerDescription,
+                dataTestId: normalize(markerNode.dataset?.testid),
+                role: normalize(markerNode.getAttribute?.("role")),
+                className: normalize(markerNode.className)
+            };
+        })
+            .filter((candidate) => Boolean(candidate)), (item) => JSON.stringify(item));
+        const rootNode = root;
+        return {
+            responseText: normalize(rootNode.innerText || rootNode.textContent || ""),
+            bodyTexts,
+            citationCandidates
+        };
+    }, {
+        answerBodySelectors: NOTEBOOKLM_ANSWER_BODY_SELECTORS,
+        citationSelectors: NOTEBOOKLM_CITATION_SELECTORS,
+        markerAttribute
+    });
+    try {
+        const popoverTextsByMarkerId = await collectCitationPopoverTexts(page, snapshot.citationCandidates, markerAttribute);
+        return {
+            ...snapshot,
+            citationCandidates: snapshot.citationCandidates.map((candidate) => {
+                const popoverText = candidate.markerId ? popoverTextsByMarkerId.get(candidate.markerId) : undefined;
+                return popoverText
+                    ? {
+                        ...candidate,
+                        popoverText
+                    }
+                    : candidate;
+            })
+        };
+    }
+    finally {
+        await clearTemporaryCitationMarkers(page, markerAttribute);
+        await clearTemporaryCitationMarkers(page, overflowAttribute);
+    }
+}
+async function expandCitationOverflowControls(page, element, overflowAttribute) {
+    const candidates = await element.evaluate((root, selectors) => {
+        const normalize = (value) => (value ?? "").replace(/\u00a0/g, " ").trim();
+        const queryAll = (scope, selector) => scope.querySelectorAll ? [...scope.querySelectorAll(selector)] : [];
+        const collectScopes = (start) => {
+            const scopes = [start];
+            let current = start.parentElement ?? null;
+            let depth = 0;
+            while (current && depth < 3) {
+                scopes.push(current);
+                current = current.parentElement ?? null;
+                depth += 1;
+            }
+            return scopes;
+        };
+        const isCitationAdjacent = (node) => {
+            if (node.closest?.(".citation-marker")) {
+                return true;
+            }
+            let current = node.parentElement ?? null;
+            let depth = 0;
+            while (current && depth < 3) {
+                const nearbyMarkers = queryAll(current, ".citation-marker");
+                if (nearbyMarkers.length > 0) {
+                    return true;
+                }
+                current = current.parentElement ?? null;
+                depth += 1;
+            }
+            return false;
+        };
+        const scopes = collectScopes(root);
+        let counter = 0;
+        const seen = new Set();
+        const results = [];
+        for (const scope of scopes) {
+            for (const selector of selectors.overflowSelectors) {
+                for (const node of queryAll(scope, selector)) {
+                    const elementNode = node;
+                    const overflowId = `overflow-${++counter}`;
+                    elementNode.setAttribute?.(selectors.overflowAttribute, overflowId);
+                    const candidate = {
+                        overflowId,
+                        text: normalize(elementNode.innerText || elementNode.textContent || ""),
+                        ariaLabel: normalize(elementNode.getAttribute?.("aria-label")),
+                        title: normalize(elementNode.getAttribute?.("title") ?? elementNode.title),
+                        className: normalize(elementNode.className),
+                        dataTestId: normalize(elementNode.dataset?.testid),
+                        selector,
+                        citationAdjacent: isCitationAdjacent(elementNode)
+                    };
+                    const key = JSON.stringify(candidate);
+                    if (seen.has(key)) {
+                        continue;
+                    }
+                    seen.add(key);
+                    results.push(candidate);
+                }
+            }
+        }
+        return results;
+    }, {
+        overflowSelectors: NOTEBOOKLM_CITATION_OVERFLOW_SELECTORS,
+        overflowAttribute
+    });
+    for (const candidate of candidates.filter((item) => shouldExpandCitationOverflowControl(item))) {
+        const locator = page.locator(`[${overflowAttribute}="${escapeAttributeValue(candidate.overflowId)}"]`).first();
+        try {
+            if ((await locator.count()) === 0 || !(await locator.isVisible())) {
+                continue;
+            }
+            await locator.click({ timeout: 1_000 });
+            await sleep(250);
+        }
+        catch { }
+    }
+}
+async function collectCitationPopoverTexts(page, candidates, markerAttribute) {
+    const markerIds = [...new Set(candidates.map((candidate) => candidate.markerId).filter((value) => Boolean(value)))];
+    const popoverTextsByMarkerId = new Map();
+    for (const markerId of markerIds) {
+        const markerLocator = page.locator(`[${markerAttribute}="${escapeAttributeValue(markerId)}"]`).first();
+        if ((await markerLocator.count()) === 0) {
+            continue;
+        }
+        try {
+            await markerLocator.scrollIntoViewIfNeeded().catch(() => undefined);
+            await dismissCitationPopover(page);
+            const previousPopoverTexts = await captureVisibleCitationPopoverTexts(page);
+            await markerLocator.click({ timeout: 1_000 });
+            const popoverText = await waitForCitationPopoverText(page, previousPopoverTexts, 2_000);
+            if (popoverText) {
+                popoverTextsByMarkerId.set(markerId, popoverText);
+            }
+        }
+        catch {
+            try {
+                await dismissCitationPopover(page);
+                const previousPopoverTexts = await captureVisibleCitationPopoverTexts(page);
+                await markerLocator.hover({ timeout: 1_000 });
+                const popoverText = await waitForCitationPopoverText(page, previousPopoverTexts, 1_500);
+                if (popoverText) {
+                    popoverTextsByMarkerId.set(markerId, popoverText);
+                }
+            }
+            catch { }
+        }
+        finally {
+            await dismissCitationPopover(page);
+        }
+    }
+    return popoverTextsByMarkerId;
+}
+async function captureVisibleCitationPopoverTexts(page) {
+    return page.evaluate((selectors) => {
+        const g = globalThis;
+        const normalize = (value) => (value ?? "").replace(/\u00a0/g, " ").replace(/\s+/g, " ").trim();
+        const values = selectors.flatMap((selector) => [...g.document.querySelectorAll(selector)].map((node) => {
+            const element = node;
+            const style = g.getComputedStyle(element);
+            const rect = element.getBoundingClientRect();
+            if (style.visibility === "hidden" || style.display === "none" || rect.width === 0 || rect.height === 0) {
+                return "";
+            }
+            return normalize(element.innerText || element.textContent || "");
+        }));
+        return [...new Set(values.filter((value) => value && value !== "인용 세부정보"))];
+    }, NOTEBOOKLM_CITATION_POPOVER_SELECTORS);
+}
+async function waitForCitationPopoverText(page, previousTexts, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    const previous = new Set(previousTexts);
+    while (Date.now() < deadline) {
+        const currentTexts = await captureVisibleCitationPopoverTexts(page);
+        const next = currentTexts.find((text) => !previous.has(text));
+        if (next) {
+            return next;
+        }
+        const stable = currentTexts.find((text) => text.length > 0 && text !== "인용 세부정보");
+        if (stable && currentTexts.length === 1 && previousTexts.length === 0) {
+            return stable;
+        }
+        await sleep(150);
+    }
+    return undefined;
+}
+async function dismissCitationPopover(page) {
+    await page.keyboard.press("Escape").catch(() => undefined);
+    await sleep(100);
+}
+async function clearTemporaryCitationMarkers(page, markerAttribute) {
+    await page
+        .evaluate((attributeName) => {
+        const g = globalThis;
+        for (const node of g.document.querySelectorAll(`[${attributeName}]`)) {
+            node.removeAttribute(attributeName);
+        }
+    }, markerAttribute)
+        .catch(() => undefined);
+}
+function escapeAttributeValue(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function normalizeControlText(value) {
+    return (value ?? "").replace(/\u00a0/g, " ").replace(/\s+/g, " ").trim();
+}
+async function clearQueryInput(page, selector) {
+    await clearInputLike(page, selector);
+}
+async function clearInputLike(page, selector) {
+    await page.click(selector);
+    await page.keyboard.press(process.platform === "darwin" ? "Meta+A" : "Control+A");
+    await page.keyboard.press("Backspace");
+}
+async function setQueryInputText(page, selector, text) {
+    await fillInputLike(page, selector, text);
+}
+async function fillInputLike(page, selector, text) {
+    const input = page.locator(selector).first();
+    await input.click();
+    try {
+        await input.fill(text);
+        return;
+    }
+    catch { }
+    await page.locator(selector).evaluate((element, value) => {
+        const candidate = element;
+        if ((candidate.tagName?.toLowerCase() !== "textarea" && candidate.tagName?.toLowerCase() !== "input") ||
+            typeof candidate.value !== "string" ||
+            !candidate.dispatchEvent) {
+            throw new Error("NotebookLM input is not a text field.");
+        }
+        candidate.value = value;
+        candidate.dispatchEvent(new Event("input", { bubbles: true }));
+        candidate.dispatchEvent(new Event("change", { bubbles: true }));
+    }, text);
+}
+async function submitQuery(page, inputSelector) {
+    if (await clickSubmitButton(page, inputSelector)) {
+        return;
+    }
+    await page.click(inputSelector);
+    await page.keyboard.press("Enter");
+    await sleep(250);
+    await page.keyboard.press(process.platform === "darwin" ? "Meta+Enter" : "Control+Enter");
+}
+async function clickSubmitButton(page, inputSelector) {
+    for (const selector of NOTEBOOKLM_SUBMIT_SELECTORS) {
+        const button = page.locator(selector).first();
+        if ((await button.count()) === 0) {
+            continue;
+        }
+        try {
+            if (await button.isVisible()) {
+                await button.click();
+                return true;
+            }
+        }
+        catch { }
+    }
+    const input = page.locator(inputSelector).first();
+    const submitHandle = await input.evaluateHandle((element) => {
+        let current = element;
+        while (current) {
+            const buttons = current.querySelectorAll ? [...current.querySelectorAll("button")] : [];
+            const candidate = buttons.find((button) => {
+                const candidateButton = button;
+                const disabled = candidateButton.hasAttribute?.("disabled") ||
+                    candidateButton.getAttribute?.("aria-disabled") === "true";
+                const visible = candidateButton.offsetParent !== null && candidateButton.offsetParent !== undefined;
+                return !disabled && visible;
+            });
+            if (candidate) {
+                return candidate;
+            }
+            current = current.parentElement ?? null;
+        }
+        return null;
+    });
+    const submitButton = submitHandle.asElement();
+    if (!submitButton) {
+        await submitHandle.dispose();
+        return false;
+    }
+    try {
+        await submitButton.click();
+        return true;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        await submitHandle.dispose();
+    }
+}
+async function waitForImportFailure(page, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        for (const selector of NOTEBOOKLM_IMPORT_ERROR_SELECTORS) {
+            const locator = page.locator(selector).first();
+            try {
+                if ((await locator.count()) > 0 && (await locator.isVisible())) {
+                    const text = normalizeControlText(await locator.innerText());
+                    if (text) {
+                        return text;
+                    }
+                }
+            }
+            catch { }
+        }
+        await sleep(200);
+    }
+    return undefined;
+}
+async function waitForImportOutcome(page, baselineCandidates, baselineSourceCount, input, importSurface, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const failureReason = await waitForImportFailure(page, 200);
+        if (failureReason) {
+            return {
+                status: "failed",
+                failureReason
+            };
+        }
+        try {
+            const currentCandidates = await captureImportSuccessCandidates(page);
+            const currentSourceCount = await captureVisibleSourceCount(page).catch(() => undefined);
+            if (didImportProduceNewMatchingCandidate(baselineCandidates, currentCandidates, input) &&
+                (await hasImportSurfaceSettled(page, importSurface))) {
+                return {
+                    status: "imported"
+                };
+            }
+            if (didImportProduceNewSourceCandidate(baselineCandidates, currentCandidates) &&
+                (await hasImportSurfaceSettled(page, importSurface))) {
+                return {
+                    status: "imported"
+                };
+            }
+            if (didImportIncreaseVisibleSourceCount(baselineSourceCount, currentSourceCount) &&
+                (await hasImportSurfaceSettled(page, importSurface))) {
+                return {
+                    status: "imported"
+                };
+            }
+        }
+        catch { }
+        await sleep(150);
+    }
+    return {
+        status: "queued"
+    };
+}
+async function waitForImportSuccess(page, baselineCandidates, input, importSurface, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        try {
+            const currentCandidates = await captureImportSuccessCandidates(page);
+            if (didImportProduceNewMatchingCandidate(baselineCandidates, currentCandidates, input) &&
+                (await hasImportSurfaceSettled(page, importSurface))) {
+                return true;
+            }
+        }
+        catch { }
+        await sleep(400);
+    }
+    return false;
+}
+async function hasImportSurfaceSettled(page, importSurface) {
+    if (importSurface === "initial_source_intake") {
+        if (page.url().includes("addSource=true")) {
+            return false;
+        }
+        if (await hasVisibleSelector(page, NOTEBOOKLM_INITIAL_SOURCE_INTAKE_SELECTORS)) {
+            return false;
+        }
+        return true;
+    }
+    return !(await hasVisibleImportDialog(page));
+}
+async function hasVisibleImportDialog(page) {
+    return page.evaluate(({ urlSelectors, fileSelectors }) => {
+        const g = globalThis;
+        const selectors = [...urlSelectors, ...fileSelectors];
+        const elements = selectors.flatMap((selector) => Array.from(g.document.querySelectorAll(selector)));
+        return elements.some((element) => {
+            const candidate = element;
+            const style = g.getComputedStyle(candidate);
+            const visible = style.display !== "none" && style.visibility !== "hidden" && candidate.offsetParent !== null;
+            const insideModal = Boolean(candidate.closest('[role="dialog"], dialog, [aria-modal="true"], .cdk-overlay-pane'));
+            return visible && insideModal;
+        });
+    }, {
+        urlSelectors: NOTEBOOKLM_IMPORT_URL_INPUT_SELECTORS,
+        fileSelectors: NOTEBOOKLM_IMPORT_FILE_INPUT_SELECTORS
+    });
+}
+async function captureImportSuccessCandidates(page) {
+    return page.evaluate(({ selectors }) => {
+        const g = globalThis;
+        const normalize = (value) => (value ?? "").replace(/\s+/g, " ").trim().toLowerCase();
+        const isVisible = (element) => {
+            const style = g.getComputedStyle(element);
+            return style.display !== "none" && style.visibility !== "hidden" && element.offsetParent !== null;
+        };
+        const isInsideModal = (element) => Boolean(element.closest('[role="dialog"], dialog, [aria-modal="true"], .cdk-overlay-pane'));
+        const unique = new Map();
+        const elements = Array.from(g.document.querySelectorAll(selectors.join(",")));
+        for (const element of elements) {
+            if (!isVisible(element) || isInsideModal(element)) {
+                continue;
+            }
+            const text = normalize([
+                element.innerText,
+                element.textContent,
+                element.getAttribute("aria-label"),
+                element.getAttribute("title")
+            ]
+                .filter(Boolean)
+                .join(" "));
+            if (!text) {
+                continue;
+            }
+            const signature = [
+                normalize(element.getAttribute("data-testid")),
+                normalize(element.getAttribute("data-test-id")),
+                normalize(element.getAttribute("aria-label")),
+                element.tagName.toLowerCase(),
+                text
+            ].join("|");
+            if (!unique.has(signature)) {
+                unique.set(signature, {
+                    signature,
+                    text
+                });
+            }
+        }
+        return Array.from(unique.values());
+    }, {
+        selectors: [...NOTEBOOKLM_IMPORT_SUCCESS_CANDIDATE_SELECTORS]
+    });
+}
+async function captureVisibleSourceCount(page) {
+    const bodyText = await page.locator("body").innerText().catch(() => "");
+    return parseNotebookSourceCount(bodyText);
+}
+function didImportProduceNewSourceCandidate(baselineCandidates, currentCandidates) {
+    const baselineSignatures = new Set(baselineCandidates.map((candidate) => candidate.signature));
+    return currentCandidates.some((candidate) => !baselineSignatures.has(candidate.signature));
+}
+export function parseNotebookSourceCount(text) {
+    const normalized = normalizeControlText(text);
+    if (!normalized) {
+        return undefined;
+    }
+    const patterns = [
+        /\bsources?\s*(\d+)\b/i,
+        /\b(\d+)\s+sources?\b/i,
+        /소스\s*(\d+)\s*개/,
+        /(\d+)\s*개\s*소스/
+    ];
+    for (const pattern of patterns) {
+        const match = normalized.match(pattern);
+        if (match?.[1]) {
+            const parsed = Number.parseInt(match[1], 10);
+            if (Number.isFinite(parsed)) {
+                return parsed;
+            }
+        }
+    }
+    return undefined;
+}
+export function didImportIncreaseVisibleSourceCount(baselineSourceCount, currentSourceCount) {
+    if (baselineSourceCount === undefined || currentSourceCount === undefined) {
+        return false;
+    }
+    return currentSourceCount > baselineSourceCount;
+}
+export function getManagedImportSuccessNeedles(input) {
+    const values = [input.title, input.sourceUri, input.importKind === "file_upload" ? input.filePath : input.url]
+        .map((value) => normalizeControlText(value).toLowerCase())
+        .filter((value) => Boolean(value));
+    return Array.from(new Set(values));
+}
+export function didImportProduceNewMatchingCandidate(baselineCandidates, currentCandidates, input) {
+    const baselineSignatures = new Set(baselineCandidates.map((candidate) => candidate.signature));
+    const needles = getManagedImportSuccessNeedles(input);
+    return currentCandidates.some((candidate) => {
+        if (baselineSignatures.has(candidate.signature)) {
+            return false;
+        }
+        const normalizedText = normalizeControlText(candidate.text);
+        return Boolean(normalizedText) && needles.some((needle) => normalizedText.includes(needle));
+    });
+}
+async function sleep(milliseconds) {
+    await new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+function formatError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=browser-agent.js.map