import cors from "cors";
import { createHash } from "crypto";
import express from "express";
import fs from "fs/promises";
import { chromium } from "playwright";

const port = Number(process.env.PORT || 3001);
const maxBaseUrl = process.env.MAX_BASE_URL || "https://web.max.ru/";
const userDataDir = process.env.MAX_USER_DATA_DIR || "/data/max-profile";
const headless = (process.env.MAX_HEADLESS || "true").toLowerCase() !== "false";
const domDownloadPrefix = "qmax-dom-download:";
const domAudioPrefix = "qmax-dom-audio:";
const domStickerPrefix = "qmax-dom-sticker:";
const domEmojiPrefix = "qmax-dom-emoji:";

let context;
let contextInitialization;
let page;
let lastError = null;
const pagesByRole = new Map();
const pageOperations = new Map();
const networkLog = [];

const app = express();
app.use(cors());
app.use(express.json({ limit: "10mb" }));

function normalizeMaxChatUrl(value) {
  const raw = String(value || "").trim();
  if (!raw) return "";

  try {
    const url = new URL(raw, maxBaseUrl);
    const base = new URL(maxBaseUrl);
    if (url.origin !== base.origin) {
      return "";
    }

    return url.href;
  } catch {
    return "";
  }
}

async function getCurrentChatUrl(p) {
  const current = normalizeMaxChatUrl(p.url());
  if (!current) {
    return null;
  }

  const base = new URL(maxBaseUrl).href;
  return current === base ? null : current;
}

app.get("/health", (_req, res) => {
  res.json({ status: "ok", serverTime: new Date().toISOString() });
});

app.get("/status", async (_req, res) => {
  res.json(await withPageLock(() => status()));
});

app.post("/login/start", async (req, res) => {
  try {
    const phoneNumber = String(req.body?.phoneNumber || "").trim();
    if (!phoneNumber) {
      return res.status(400).json({ error: "phoneNumber is required" });
    }

    const result = await withPageLock(async () => {
    const p = await ensurePage();
    await p.goto(maxBaseUrl, { waitUntil: "domcontentloaded", timeout: 60000 });
    await p.waitForTimeout(1500);
    await openPhoneLogin(p);
    const filled = await fillFirst(p, normalizePhoneNumberForMax(phoneNumber), [
      "input[type='tel']",
      "input[autocomplete='tel']",
      "input[name*='phone' i]",
      "input[placeholder*='тел' i]",
      "input"
    ]);
    if (filled) {
      await clickLikelySubmitFixed(p);
      await p.waitForLoadState("networkidle", { timeout: 15000 }).catch(() => {});
      await p.waitForTimeout(1500);
    }

    return await status("LoginStarted");
    });

    res.json(result);
  } catch (error) {
    res.status(500).json(errorStatus(error));
  }
});

app.post("/login/code", async (req, res) => {
  try {
    const code = normalizeLoginCode(req.body?.code);
    if (!code) {
      return res.status(400).json({ error: "code is required" });
    }

    const result = await withPageLock(async () => {
      const p = await ensurePage();
      const waitMs = clampNumber(req.body?.waitMs ?? req.query?.waitMs, 0, 120000, 45000);
      const codeScreenReady = await waitForLoginStage(p, "CodeEntry", waitMs);
      if (!codeScreenReady) {
        const currentStatus = await status("CodeScreenNotReady");
        currentStatus.lastError = "MAX is not showing the SMS code entry screen.";
        return currentStatus;
      }

      const filled = await fillLoginCode(p, code);
      if (!filled) {
        await p.keyboard.insertText(code);
      }
      await clickLikelySubmitFixed(p);
      await p.waitForLoadState("networkidle", { timeout: 15000 }).catch(() => {});
      await p.waitForTimeout(2500);
      return await status("CodeSubmitted");
    });

    res.json(result);
  } catch (error) {
    res.status(500).json(errorStatus(error));
  }
});

app.get("/snapshot", async (_req, res) => {
  try {
    const snapshot = await withPageLock(async () => {
      const p = await ensurePage();
      const screenshot = await p.screenshot({ fullPage: true, type: "png" });
      return {
        url: p.url(),
        title: await safeTitle(p),
        bodyText: await safeBodyText(p),
        screenshotPngBase64: screenshot.toString("base64"),
        capturedAt: new Date().toISOString()
      };
    });
    res.json(snapshot);
  } catch (error) {
    res.status(500).json(errorStatus(error));
  }
});

app.post("/browser/click", async (req, res) => {
  try {
    const result = await withPageLock(async () => {
      const p = await ensurePage();
      await p.mouse.click(Number(req.body?.x), Number(req.body?.y));
      await p.waitForTimeout(500);
      return await status("Clicked");
    });
    res.json(result);
  } catch (error) {
    res.status(500).json(errorStatus(error));
  }
});

app.post("/browser/type", async (req, res) => {
  try {
    const result = await withPageLock(async () => {
      const p = await ensurePage();
      await p.keyboard.insertText(String(req.body?.text || ""));
      return await status("Typed");
    });
    res.json(result);
  } catch (error) {
    res.status(500).json(errorStatus(error));
  }
});

app.post("/browser/press", async (req, res) => {
  try {
    const result = await withPageLock(async () => {
      const p = await ensurePage();
      await p.keyboard.press(String(req.body?.key || "Enter"));
      await p.waitForTimeout(500);
      return await status("Pressed");
    });
    res.json(result);
  } catch (error) {
    res.status(500).json(errorStatus(error));
  }
});

app.get("/inspect/indexeddb", async (_req, res) => {
  try {
    const databases = await withPageLock(async () => {
      const p = await ensurePage();
      return await p.evaluate(async () => {
        if (!indexedDB.databases) return [];
        const dbs = await indexedDB.databases();
        return dbs.map((db) => ({ name: db.name, version: db.version }));
      });
    });
    res.json({ databases });
  } catch (error) {
    res.status(500).json(errorStatus(error));
  }
});

app.get("/inspect/indexeddb/sample", async (req, res) => {
  try {
    const sampleLimit = clampNumber(req.query?.sampleLimit, 1, 10, 3);
    const dbLimit = clampNumber(req.query?.dbLimit, 1, 20, 10);
    const storeLimit = clampNumber(req.query?.storeLimit, 1, 80, 40);
    const stringLimit = clampNumber(req.query?.stringLimit, 16, 512, 96);
    const result = await withPageLock(async () => {
      const p = await ensurePage();
      return await inspectIndexedDbSamples(p, { sampleLimit, dbLimit, storeLimit, stringLimit });
    });
    res.json(result);
  } catch (error) {
    res.status(500).json(errorStatus(error));
  }
});

app.get("/inspect/dom", async (req, res) => {
  try {
    res.json(await withPageLock(async () => {
      const role = String(req.query?.role || "default").trim() || "default";
      const p = await ensurePage(role);
      return await inspectDom(p);
    }, String(req.query?.role || "default").trim() || "default"));
  } catch (error) {
    res.status(500).json(errorStatus(error));
  }
});

app.get("/inspect/storage", async (_req, res) => {
  try {
    res.json(await withPageLock(async () => {
      const p = await ensurePage();
      return await inspectStorage(p);
    }));
  } catch (error) {
    res.status(500).json(errorStatus(error));
  }
});

app.get("/inspect/network", async (_req, res) => {
  res.json({
    capturedAt: new Date().toISOString(),
    entries: networkLog.slice(-200)
  });
});

app.get("/inspect/chat-urls", async (req, res) => {
  try {
    const limit = clampNumber(req.query?.limit, 1, 800, 600);
    const result = await withPageLock(async () => {
      const p = await ensurePage("incoming");
      const currentStatus = await status(null, p);
      if (!currentStatus.isAuthorized) {
        return { chats: [], error: "MAX is not authorized." };
      }

      return { chats: await collectSidebarChatUrls(p, limit), error: null };
    }, "incoming");
    res.json(result);
  } catch (error) {
    res.status(500).json(errorStatus(error));
  }
});

app.get("/media/fetch", async (req, res) => {
  try {
    const mediaUrl = String(req.query?.url || "").trim();
    if (!isAllowedMediaUrl(mediaUrl)) {
      return res.status(400).json({ error: "Unsupported media URL." });
    }

    const media = await withPageLock(async () => {
      const p = await ensurePage("incoming");
      return await fetchMediaThroughMaxSession(p, mediaUrl);
    }, "incoming");

    res.setHeader("Content-Type", media.contentType || "application/octet-stream");
    res.setHeader("Content-Length", String(media.buffer.length));
    res.send(media.buffer);
  } catch (error) {
    res.status(502).json(errorStatus(error));
  }
});

app.get("/updates", async (_req, res) => {
  try {
    const result = await withPageLock(async () => {
      const p = await ensurePage("incoming");
      const currentStatus = await status(null, p);
      if (!currentStatus.isAuthorized) {
        return [];
      }

      await clearSidebarSearch(p);
      await resetSidebarListToTop(p);
      return await extractUpdates(p);
    }, "incoming");
    res.json(result);
  } catch (error) {
    res.status(500).json(errorStatus(error));
  }
});

app.post("/chat/history", async (req, res) => {
  try {
    const externalChatId = String(req.body?.externalChatId || "").trim();
    const chatUrl = normalizeMaxChatUrl(req.body?.chatUrl);
    const result = await withPageLock(async () => {
      const p = await ensurePage("incoming");
      const currentStatus = await status(null, p);
      if (!currentStatus.isAuthorized) {
        return null;
      }

      if (externalChatId) {
        const opened = await ensureDomChatOpen(p, externalChatId, 1000, false, chatUrl);
        if (!opened) {
          return null;
        }
      }

      await scrollOpenChatToLatest(p);
      const update = await extractOpenChatHistory(p, externalChatId);
      return { ...update, chatUrl: await getCurrentChatUrl(p) };
    }, "incoming");

    if (!result) {
      return res.status(409).json({ error: "MAX is not authorized." });
    }

    res.json(result);
  } catch (error) {
    res.status(500).json(errorStatus(error));
  }
});

app.post("/chat/resolve-url", async (req, res) => {
  try {
    const externalChatId = String(req.body?.externalChatId || "").trim();
    if (!externalChatId) {
      return res.status(400).json({ success: false, chatUrl: null, error: "externalChatId is required." });
    }

    const result = await withPageLock(async () => {
      const p = await ensurePage("commands");
      const currentStatus = await status(null, p);
      if (!currentStatus.isAuthorized) {
        return { success: false, chatUrl: null, error: "MAX is not authorized." };
      }

      const chatUrl = await resolveDomChatUrl(p, externalChatId);
      return {
        success: Boolean(chatUrl),
        chatUrl: chatUrl || null,
        error: chatUrl ? null : "MAX chat URL was not found."
      };
    }, "commands");

    res.json(result);
  } catch (error) {
    res.status(500).json(errorStatus(error));
  }
});

app.post("/chat/clear-history", async (req, res) => {
  try {
    const externalChatId = String(req.body?.externalChatId || "").trim();
    const chatUrl = normalizeMaxChatUrl(req.body?.chatUrl);
    if (!externalChatId) {
      return res.json({ success: false, error: "externalChatId is required." });
    }

    const result = await withPageLock(async () => {
      const p = await ensurePage("commands");
      return await clearChatHistoryInMax(p, externalChatId, chatUrl);
    }, "commands");
    res.json(result);
  } catch (error) {
    res.json({ success: false, error: String(error?.message || error) });
  }
});

app.post("/chat/delete", async (req, res) => {
  try {
    const externalChatId = String(req.body?.externalChatId || "").trim();
    const chatUrl = normalizeMaxChatUrl(req.body?.chatUrl);
    if (!externalChatId) {
      return res.json({ success: false, error: "externalChatId is required." });
    }

    const result = await withPageLock(async () => {
      const p = await ensurePage("commands");
      return await deleteChatInMax(p, externalChatId, chatUrl);
    }, "commands");
    res.json(result);
  } catch (error) {
    res.json({ success: false, error: String(error?.message || error) });
  }
});

app.post("/chat/menu-probe", async (req, res) => {
  try {
    const externalChatId = String(req.body?.externalChatId || "").trim();
    const chatUrl = normalizeMaxChatUrl(req.body?.chatUrl);
    const labels = Array.isArray(req.body?.labels) && req.body.labels.length > 0
      ? req.body.labels.map((label) => String(label || ""))
      : ["\u0443\u0434\u0430\u043b\u0438\u0442\u044c \u0447\u0430\u0442", "\u0443\u0434\u0430\u043b\u0438\u0442\u044c", "delete chat", "delete conversation", "remove chat"];
    const probeAction = Boolean(req.body?.probeAction);
    if (!externalChatId) {
      return res.json({ success: false, error: "externalChatId is required.", chatUrl: null });
    }

    const result = await withPageLock(async () => {
      const p = await ensurePage("commands");
      const menuOpened = await openSidebarChatMenu(p, externalChatId, chatUrl, labels);
      const actionClicked = menuOpened && probeAction
        ? await clickActionByTextWithRetry(p, labels, 1500)
        : false;
      if (actionClicked) {
        await p.waitForTimeout(700);
      }
      const visibleActions = actionClicked ? await readVisibleActionTexts(p) : [];
      await p.keyboard.press("Escape").catch(() => {});
      await clearSidebarSearch(p);
      return {
        success: menuOpened,
        error: menuOpened ? null : "MAX chat menu was not opened.",
        chatUrl: await getCurrentChatUrl(p),
        actionClicked,
        visibleActions
      };
    }, "commands");
    res.json(result);
  } catch (error) {
    res.json({ success: false, error: String(error?.message || error), chatUrl: null });
  }
});

app.post("/chat/clear-composer", async (req, res) => {
  try {
    const externalChatId = String(req.body?.externalChatId || "").trim();
    const result = await withPageLock(async () => {
      const p = await ensurePage("outgoing");
      const currentStatus = await status(null, p);
      if (!currentStatus.isAuthorized) {
        return { success: false, error: "MAX is not authorized.", composerText: null };
      }

      if (externalChatId) {
        const opened = await ensureDomChatOpen(p, externalChatId, 2000, true);
        if (!opened) {
          return { success: false, error: "MAX chat was not found or did not open.", composerText: null };
        }
      }

      const success = await clearComposerInput(p);
      return { success, error: success ? null : "MAX composer was not cleared.", composerText: await readComposerText(p) };
    }, "outgoing");

    res.json(result);
  } catch (error) {
    res.status(500).json(errorStatus(error));
  }
});

app.post("/chat/draft-text", async (req, res) => {
  try {
    const externalChatId = String(req.body?.externalChatId || "").trim();
    const text = String(req.body?.text || "");
    if (!text) {
      return res.json({ success: false, error: "Text is empty.", composerText: null });
    }

    const result = await withPageLock(async () => {
      const p = await ensurePage("outgoing");
      const currentStatus = await status(null, p);
      if (!currentStatus.isAuthorized) {
        return { success: false, error: "MAX is not authorized.", composerText: null };
      }

      if (externalChatId) {
        const opened = await ensureDomChatOpen(p, externalChatId, 2000, true);
        if (!opened) {
          return { success: false, error: "MAX chat was not found or did not open.", composerText: null };
        }
      }

      const success = await fillComposerText(p, text, true);
      return { success, error: success ? null : "MAX composer was not filled.", composerText: await readComposerText(p) };
    }, "outgoing");

    res.json(result);
  } catch (error) {
    res.status(500).json(errorStatus(error));
  }
});

app.post("/chat/presence", async (req, res) => {
  try {
    const externalChatId = String(req.body?.externalChatId || "").trim();
    const chatUrl = normalizeMaxChatUrl(req.body?.chatUrl);
    const result = await withPageLock(async () => {
      const p = await ensurePage("incoming");
      const currentStatus = await status(null, p);
      if (!currentStatus.isAuthorized) {
        return { isTyping: false, statusText: null, updatedAt: new Date().toISOString() };
      }

      if (externalChatId) {
        await ensureDomChatOpen(p, externalChatId, 600, false, chatUrl);
      }

      return await extractOpenChatPresence(p);
    }, "incoming");

    res.json(result);
  } catch (error) {
    res.status(500).json(errorStatus(error));
  }
});

app.post("/send/text", async (req, res) => {
  try {
    const externalChatId = String(req.body?.externalChatId || "").trim();
    const chatUrl = normalizeMaxChatUrl(req.body?.chatUrl);
    const text = String(req.body?.text || "");
    if (!text) {
      return res.json({ success: false, externalMessageId: null, error: "Text is empty." });
    }

    const result = await withPageLock(async () => {
      const p = await ensurePage("outgoing");

      if (externalChatId) {
        const opened = await ensureDomChatOpen(p, externalChatId, 8000, true, chatUrl);
        if (!opened) {
          return { success: false, externalMessageId: null, error: "MAX chat was not found or did not open.", chatUrl: null };
        }
      }

      const externalMessageId = await sendTextAndConfirm(p, externalChatId, text);
      if (!externalMessageId) {
        return { success: false, externalMessageId: null, error: "MAX did not confirm the outgoing text message.", chatUrl: await getCurrentChatUrl(p) };
      }
      return { success: true, externalMessageId, error: null, chatUrl: await getCurrentChatUrl(p) };
    }, "outgoing");
    res.json(result);
  } catch (error) {
    res.json({ success: false, externalMessageId: null, error: String(error?.message || error) });
  }
});

app.post("/send/attachment", async (req, res) => {
  try {
    const externalChatId = String(req.body?.externalChatId || "").trim();
    const chatUrl = normalizeMaxChatUrl(req.body?.chatUrl);
    const path = String(req.body?.path || "").trim();
    const caption = String(req.body?.caption || "");
    if (!path) {
      return res.json({ success: false, externalMessageId: null, error: "Attachment path is empty." });
    }

    const result = await withPageLock(async () => {
      const p = await ensurePage("outgoing");
      if (externalChatId) {
        const opened = await ensureDomChatOpen(p, externalChatId, 8000, true, chatUrl);
        if (!opened) {
          return { success: false, externalMessageId: null, error: "MAX chat was not found or did not open.", chatUrl: null };
        }
      }

      const externalMessageId = await sendAttachmentAndConfirm(p, externalChatId, path, caption);
      if (!externalMessageId) {
        return { success: false, externalMessageId: null, error: "MAX did not confirm the outgoing attachment.", chatUrl: await getCurrentChatUrl(p) };
      }

      return { success: true, externalMessageId, error: null, chatUrl: await getCurrentChatUrl(p) };
    }, "outgoing");

    res.json(result);
  } catch (error) {
    res.json({ success: false, externalMessageId: null, error: String(error?.message || error) });
  }
});

app.post("/message/edit", async (req, res) => {
  try {
    const externalChatId = String(req.body?.externalChatId || "").trim();
    const externalMessageId = String(req.body?.externalMessageId || "").trim();
    const currentText = String(req.body?.currentText || "");
    const text = String(req.body?.text || "").trim();
    if (!externalChatId || !externalMessageId || !text) {
      return res.json({ success: false, error: "externalChatId, externalMessageId and text are required." });
    }

    const result = await withPageLock(async () => {
      const p = await ensurePage("outgoing");
      return await editMessageInMax(p, externalChatId, externalMessageId, currentText, text);
    }, "outgoing");
    res.json(result);
  } catch (error) {
    res.json({ success: false, error: String(error?.message || error) });
  }
});

app.post("/message/delete", async (req, res) => {
  try {
    const externalChatId = String(req.body?.externalChatId || "").trim();
    const externalMessageId = String(req.body?.externalMessageId || "").trim();
    const currentText = String(req.body?.currentText || "");
    if (!externalChatId || !externalMessageId) {
      return res.json({ success: false, error: "externalChatId and externalMessageId are required." });
    }

    const result = await withPageLock(async () => {
      const p = await ensurePage("outgoing");
      return await deleteMessageInMax(p, externalChatId, externalMessageId, currentText);
    }, "outgoing");
    res.json(result);
  } catch (error) {
    res.json({ success: false, error: String(error?.message || error) });
  }
});

app.post("/message/reaction", async (req, res) => {
  try {
    const externalChatId = String(req.body?.externalChatId || "").trim();
    const externalMessageId = String(req.body?.externalMessageId || "").trim();
    const currentText = String(req.body?.currentText || "");
    const emoji = String(req.body?.emoji || "").trim();
    if (!externalChatId || !externalMessageId || !emoji) {
      return res.json({ success: false, error: "externalChatId, externalMessageId and emoji are required." });
    }

    const result = await withPageLock(async () => {
      const p = await ensurePage("outgoing");
      return await setMessageReactionInMax(p, externalChatId, externalMessageId, currentText, emoji);
    }, "outgoing");
    res.json(result);
  } catch (error) {
    res.json({ success: false, error: String(error?.message || error) });
  }
});

app.delete("/message/reaction", async (req, res) => {
  try {
    const externalChatId = String(req.body?.externalChatId || "").trim();
    const externalMessageId = String(req.body?.externalMessageId || "").trim();
    const currentText = String(req.body?.currentText || "");
    const emoji = String(req.body?.emoji || "").trim();
    if (!externalChatId || !externalMessageId || !emoji) {
      return res.json({ success: false, error: "externalChatId, externalMessageId and emoji are required." });
    }

    const result = await withPageLock(async () => {
      const p = await ensurePage("outgoing");
      return await clearMessageReactionInMax(p, externalChatId, externalMessageId, currentText, emoji);
    }, "outgoing");
    res.json(result);
  } catch (error) {
    res.json({ success: false, error: String(error?.message || error) });
  }
});

app.listen(port, () => {
  console.log(`QMAX MAX worker listening on ${port}, headless=${headless}`);
});

async function ensurePage(role = "default") {
  const normalizedRole = String(role || "default");
  const existing = pagesByRole.get(normalizedRole);
  if (existing && !existing.isClosed()) {
    await waitForRolePageReady(existing, normalizedRole);
    return existing;
  }

  await ensureContext();

  if (normalizedRole === "default") {
    if (!page || page.isClosed()) {
      page = context.pages().find((candidate) => !candidate.isClosed()) || await context.newPage();
      pagesByRole.set("default", page);
      attachNetworkCapture(page);
      if (!page.url() || page.url() === "about:blank") {
        await page.goto(maxBaseUrl, { waitUntil: "domcontentloaded", timeout: 60000 });
      }
    }

    return page;
  }

  const rolePage = await context.newPage();
  pagesByRole.set(normalizedRole, rolePage);
  attachNetworkCapture(rolePage);
  await rolePage.goto(maxBaseUrl, { waitUntil: "domcontentloaded", timeout: 60000 });
  await waitForRolePageReady(rolePage, normalizedRole);
  return rolePage;
}

async function waitForRolePageReady(rolePage, role) {
  if (role === "default") {
    return;
  }

  await rolePage.waitForLoadState("domcontentloaded", { timeout: 15000 }).catch(() => {});
  await waitForLoginStage(rolePage, "Authorized", 15000).catch(() => false);
}

async function ensureContext() {
  if (context) return;
  if (!contextInitialization) {
    contextInitialization = (async () => {
      await cleanupChromiumProfileLocks(userDataDir);
      context = await chromium.launchPersistentContext(userDataDir, {
        headless,
        acceptDownloads: true,
        locale: "ru-RU",
        timezoneId: process.env.MAX_TIMEZONE_ID || "Europe/Moscow",
        viewport: { width: 1280, height: 900 },
        args: ["--disable-dev-shm-usage", "--no-sandbox"]
      });
      await context.grantPermissions(["clipboard-read", "clipboard-write"], { origin: maxBaseUrl }).catch(() => {});
      page = context.pages()[0] || await context.newPage();
      pagesByRole.set("default", page);
      attachNetworkCapture(page);
      if (!page.url() || page.url() === "about:blank") {
        await page.goto(maxBaseUrl, { waitUntil: "domcontentloaded", timeout: 60000 });
      }
    })().catch((error) => {
      contextInitialization = null;
      throw error;
    });
  }

  await contextInitialization;
}

async function withPageLock(operation, role = "default") {
  const normalizedRole = String(role || "default");
  const previousOperation = pageOperations.get(normalizedRole) || Promise.resolve();
  let release;
  const nextOperation = new Promise((resolve) => {
    release = resolve;
  });
  pageOperations.set(normalizedRole, nextOperation);

  await previousOperation.catch(() => {});
  try {
    return await operation();
  } finally {
    release();
  }
}

async function status(overrideStatus = null, statusPage = null) {
  try {
    const p = statusPage || await ensurePage();
    const title = await safeTitle(p);
    const url = p.url();
    const bodyText = await safeBodyText(p);
    const loginStage = detectLoginStageFromText(url, title, bodyText);
    return {
      mode: "Worker",
      isAuthorized: loginStage === "Authorized",
      loginStage,
      status: overrideStatus || "BrowserReady",
      url,
      title,
      lastError,
      pageRoles: getOpenPageRoles(),
      updatedAt: new Date().toISOString()
    };
  } catch (error) {
    return errorStatus(error);
  }
}

function errorStatus(error) {
  lastError = String(error?.message || error);
  const fallbackPage = firstKnownPage();
  return {
    mode: "Worker",
    isAuthorized: false,
    status: "WorkerError",
    url: fallbackPage?.url?.() || null,
    title: null,
    lastError,
    pageRoles: getOpenPageRoles(),
    updatedAt: new Date().toISOString()
  };
}

function firstKnownPage() {
  return page ||
    pagesByRole.get("default") ||
    pagesByRole.get("incoming") ||
    pagesByRole.get("outgoing") ||
    pagesByRole.get("commands") ||
    null;
}

function getOpenPageRoles() {
  return Array.from(pagesByRole.entries())
    .filter(([, rolePage]) => rolePage && !rolePage.isClosed())
    .map(([roleName]) => roleName)
    .sort();
}

function isAllowedMediaUrl(value) {
  const raw = String(value || "").trim();
  if (!raw) return false;
  if (isDomDownloadUrl(raw) || isDomAudioUrl(raw) || isDomStickerUrl(raw) || isDomEmojiUrl(raw)) return true;
  if (raw.startsWith("blob:")) {
    try {
      const inner = new URL(raw.slice("blob:".length));
      return inner.protocol === "https:" && !isPrivateHost(inner.hostname);
    } catch {
      return false;
    }
  }

  try {
    const parsed = new URL(raw);
    return ["http:", "https:"].includes(parsed.protocol) && !isPrivateHost(parsed.hostname);
  } catch {
    return false;
  }
}

function isDomDownloadUrl(value) {
  return String(value || "").startsWith(domDownloadPrefix);
}

function isDomAudioUrl(value) {
  return String(value || "").startsWith(domAudioPrefix);
}

function isDomStickerUrl(value) {
  return String(value || "").startsWith(domStickerPrefix);
}

function isDomEmojiUrl(value) {
  return String(value || "").startsWith(domEmojiPrefix);
}

function parseDomDownloadUrl(value) {
  const raw = String(value || "");
  if (!isDomDownloadUrl(raw)) {
    return null;
  }

  try {
    return JSON.parse(decodeURIComponent(raw.slice(domDownloadPrefix.length)));
  } catch {
    return null;
  }
}

function parseDomAudioUrl(value) {
  const raw = String(value || "");
  if (!isDomAudioUrl(raw)) {
    return null;
  }

  try {
    return JSON.parse(decodeURIComponent(raw.slice(domAudioPrefix.length)));
  } catch {
    return null;
  }
}

function parseDomStickerUrl(value) {
  const raw = String(value || "");
  if (!isDomStickerUrl(raw)) {
    return null;
  }

  try {
    return JSON.parse(decodeURIComponent(raw.slice(domStickerPrefix.length)));
  } catch {
    return null;
  }
}

function parseDomEmojiUrl(value) {
  const raw = String(value || "");
  if (!isDomEmojiUrl(raw)) {
    return null;
  }

  try {
    return JSON.parse(decodeURIComponent(raw.slice(domEmojiPrefix.length)));
  } catch {
    return null;
  }
}

function domMediaPrefixForUrl(value) {
  const raw = String(value || "");
  if (isDomDownloadUrl(raw)) return domDownloadPrefix;
  if (isDomAudioUrl(raw)) return domAudioPrefix;
  if (isDomStickerUrl(raw)) return domStickerPrefix;
  if (isDomEmojiUrl(raw)) return domEmojiPrefix;
  return null;
}

function parseDomMediaUrl(value) {
  const prefix = domMediaPrefixForUrl(value);
  if (!prefix) {
    return null;
  }

  try {
    return JSON.parse(decodeURIComponent(String(value).slice(prefix.length)));
  } catch {
    return null;
  }
}

function attachDomMediaChatContext(value, externalChatId, chatUrl) {
  const prefix = domMediaPrefixForUrl(value);
  if (!prefix) {
    return value;
  }

  const parsed = parseDomMediaUrl(value);
  if (!parsed) {
    return value;
  }

  const next = {
    ...parsed,
    externalChatId: parsed.externalChatId || externalChatId || null,
    chatUrl: normalizeMaxChatUrl(parsed.chatUrl) || normalizeMaxChatUrl(chatUrl) || null
  };
  return `${prefix}${encodeURIComponent(JSON.stringify(next))}`;
}

async function ensureDomMediaChatContext(p, request) {
  const externalChatId = String(request?.externalChatId || "").trim();
  const chatUrl = normalizeMaxChatUrl(request?.chatUrl);
  if (!externalChatId && !chatUrl) {
    return;
  }

  await ensureDomChatOpen(p, externalChatId, 5000, false, chatUrl);
}

function isPrivateHost(hostname) {
  const host = String(hostname || "").toLowerCase();
  if (!host || host === "localhost" || host.endsWith(".localhost")) return true;
  if (/^(127|10)\./.test(host)) return true;
  if (/^192\.168\./.test(host)) return true;
  if (/^172\.(1[6-9]|2\d|3[0-1])\./.test(host)) return true;
  if (/^(0|169\.254)\./.test(host)) return true;
  if (host === "::1" || host.startsWith("fc") || host.startsWith("fd")) return true;
  return false;
}

async function fetchMediaThroughMaxSession(p, mediaUrl) {
  if (isDomDownloadUrl(mediaUrl)) {
    const request = parseDomDownloadUrl(mediaUrl);
    await ensureDomMediaChatContext(p, request);
    return await downloadDomAttachmentThroughClick(p, request);
  }

  if (isDomAudioUrl(mediaUrl)) {
    const request = parseDomAudioUrl(mediaUrl);
    await ensureDomMediaChatContext(p, request);
    return await downloadDomAudioThroughPlay(p, request);
  }

  if (isDomStickerUrl(mediaUrl)) {
    const request = parseDomStickerUrl(mediaUrl);
    await ensureDomMediaChatContext(p, request);
    return await downloadDomStickerThroughScreenshot(p, request);
  }

  if (isDomEmojiUrl(mediaUrl)) {
    const request = parseDomEmojiUrl(mediaUrl);
    await ensureDomMediaChatContext(p, request);
    return await downloadDomStickerThroughScreenshot(p, {
      ...request,
      selector: "[data-testid*='emoji' i], [class*='emoji' i], [class*='lottie' i], [class*='emoticon' i], canvas, svg",
      kindLabel: "MAX emoji canvas",
      acceptSmall: true,
      maxClipSize: 256,
      requireTimeMatch: true
    });
  }

  if (mediaUrl.startsWith("blob:")) {
    const result = await p.evaluate(async (url) => {
      const response = await fetch(url);
      if (!response.ok) {
        throw new Error(`Blob fetch failed: ${response.status}`);
      }
      const arrayBuffer = await response.arrayBuffer();
      const bytes = Array.from(new Uint8Array(arrayBuffer));
      return {
        contentType: response.headers.get("content-type") || "application/octet-stream",
        bytes
      };
    }, mediaUrl);

    return {
      contentType: result.contentType,
      buffer: Buffer.from(result.bytes)
    };
  }

  const response = await context.request.get(mediaUrl, { timeout: 60000 });
  if (!response.ok()) {
    throw new Error(`Media fetch failed: ${response.status()} ${response.statusText()}`);
  }

  const headers = response.headers();
  return {
    contentType: String(headers["content-type"] || "application/octet-stream").split(";")[0],
    buffer: await response.body()
  };
}

async function downloadDomAttachmentThroughClick(p, request) {
  const fileName = String(request?.fileName || "").trim();
  const label = String(request?.label || fileName).trim();
  if (!fileName && !label) {
    throw new Error("DOM download request does not include a file label.");
  }

  const downloadPromise = p.waitForEvent("download", { timeout: 20000 });
  const clicked = await p.evaluate(({ fileName, label }) => {
    const cleanText = (value, limit = 500) => String(value || "")
      .replace(/\u00a0/g, " ")
      .replace(/\s+/g, " ")
      .trim()
      .slice(0, limit);
    const isVisible = (element) => {
      const style = window.getComputedStyle(element);
      const rect = element.getBoundingClientRect();
      return style.visibility !== "hidden" &&
        style.display !== "none" &&
        rect.width > 0 &&
        rect.height > 0 &&
        rect.bottom >= 0 &&
        rect.right >= 0 &&
        rect.top <= window.innerHeight &&
        rect.left <= window.innerWidth;
    };
    const expectedFile = cleanText(fileName, 160).toLowerCase();
    const expectedLabel = cleanText(label, 300).toLowerCase();
    const buttons = Array.from(document.querySelectorAll("button,[role='button']"))
      .filter((node) => node instanceof HTMLElement && isVisible(node));
    const match = buttons.find((button) => {
      const text = cleanText(button.innerText || button.textContent || button.getAttribute("aria-label"), 300).toLowerCase();
      if (!text) return false;
      if (expectedFile && text.includes(expectedFile)) return true;
      return expectedLabel && (text === expectedLabel || text.includes(expectedLabel));
    });
    if (!match) {
      return false;
    }

    match.click();
    return true;
  }, { fileName, label }).catch(() => false);

  if (!clicked) {
    downloadPromise.catch(() => null);
    throw new Error(`MAX file download button was not found for ${fileName || label}.`);
  }

  const download = await downloadPromise;
  const path = await download.path();
  if (!path) {
    throw new Error("MAX file download did not produce a local file.");
  }

  const buffer = await fs.readFile(path);
  await download.delete().catch(() => {});
  return {
    contentType: contentTypeFromFileName(download.suggestedFilename() || fileName),
    buffer
  };
}

async function downloadDomAudioThroughPlay(p, request) {
  const duration = String(request?.duration || "").trim();
  const timeText = String(request?.timeText || "").trim();
  const label = String(request?.label || duration || timeText || "voice").trim();
  const point = await p.evaluate(({ duration, timeText, label }) => {
    const cleanText = (value, limit = 500) => String(value || "")
      .replace(/\u00a0/g, " ")
      .replace(/\s+/g, " ")
      .trim()
      .slice(0, limit);
    const isVisible = (element) => {
      if (!(element instanceof HTMLElement)) return false;
      const style = window.getComputedStyle(element);
      const rect = element.getBoundingClientRect();
      return style.visibility !== "hidden" &&
        style.display !== "none" &&
        rect.width > 0 &&
        rect.height > 0 &&
        rect.bottom >= 0 &&
        rect.right >= 0 &&
        rect.top <= window.innerHeight &&
        rect.left <= window.innerWidth;
    };
    const roots = Array.from(document.querySelectorAll("[class*='attachAudio' i], [class*='voice' i], [class*='audio' i]"))
      .filter((node) => node instanceof HTMLElement && isVisible(node))
      .map((root) => {
        const wrapper = root.closest("[class*='messageWrapper' i], [role='listitem'], [class*='item' i]") || root;
        const text = cleanText(`${root.innerText || root.textContent || ""} ${wrapper.innerText || wrapper.textContent || ""}`, 1000);
        const semantic = [
          root.className,
          root.getAttribute("aria-label"),
          root.getAttribute("title"),
          text
        ].filter(Boolean).join(" ").toLowerCase();
        let score = /attachaudio|audio|voice|\u0433\u043e\u043b\u043e\u0441|\u0430\u0443\u0434\u0438\u043e/i.test(semantic) ? 4 : 0;
        if (duration && text.includes(duration)) score += 8;
        if (timeText && text.includes(timeText)) score += 3;
        if (label && text.toLowerCase().includes(label.toLowerCase())) score += 1;
        const rect = root.getBoundingClientRect();
        return { root, score, bottom: rect.bottom };
      })
      .filter((item) => item.score > 0)
      .sort((a, b) => b.score - a.score || b.bottom - a.bottom);

    const root = roots[0]?.root;
    if (!root) {
      return null;
    }

    const clickable = root.querySelector("button,[role='button']") || root;
    const rect = clickable.getBoundingClientRect();
    if (rect.width <= 0 || rect.height <= 0) {
      return null;
    }

    const rootRect = root.getBoundingClientRect();
    const leftPlayX = rootRect.left + Math.min(28, Math.max(12, rootRect.width * 0.12));
    return {
      x: Math.round(clickable === root ? leftPlayX : rect.left + rect.width / 2),
      y: Math.round(rect.top + rect.height / 2)
    };
  }, { duration, timeText, label }).catch(() => null);

  if (!point) {
    throw new Error(`MAX voice player was not found for ${label}.`);
  }

  const waitForVoiceResponse = () => p.waitForResponse((response) => {
    try {
      const status = response.status();
      if (status !== 200 && status !== 206) {
        return false;
      }

      const url = response.url();
      if (/\/_app\/immutable\/assets\//i.test(url)) {
        return false;
      }

      const request = response.request();
      const resourceType = request.resourceType();
      const headers = response.headers();
      const contentType = String(headers["content-type"] || "").split(";")[0].toLowerCase();
      if (contentType.startsWith("audio/")) {
        return true;
      }

      return resourceType === "media" &&
        /\.(ogg|opus|m4a|aac|mp3|wav|flac|oga)(\?|#|$)/i.test(url);
    } catch {
      return false;
    }
  }, { timeout: 8000 }).catch(() => null);

  for (let attempt = 0; attempt < 3; attempt++) {
    const responsePromise = waitForVoiceResponse();
    await p.mouse.click(point.x, point.y);
    const response = await responsePromise;
    if (response) {
      const headers = response.headers();
      const buffer = await response.body();
      if (buffer.length > 0) {
        return {
          contentType: String(headers["content-type"] || "audio/ogg").split(";")[0],
          buffer
        };
      }
    }

    await p.waitForTimeout(600);
  }

  const embedded = await p.evaluate(async ({ duration, timeText }) => {
    const cleanText = (value, limit = 500) => String(value || "")
      .replace(/\u00a0/g, " ")
      .replace(/\s+/g, " ")
      .trim()
      .slice(0, limit);
    const candidates = Array.from(document.querySelectorAll("audio, video"))
      .map((media) => {
        const wrapper = media.closest("[class*='messageWrapper' i], [role='listitem'], [class*='item' i]") || media;
        const text = cleanText(wrapper.innerText || wrapper.textContent || "", 1000);
        const src = media.currentSrc || media.src || media.querySelector?.("source")?.src || "";
        let score = src ? 1 : 0;
        if (duration && text.includes(duration)) score += 8;
        if (timeText && text.includes(timeText)) score += 3;
        return { src, score };
      })
      .filter((item) => item.src && item.score > 0)
      .sort((a, b) => b.score - a.score);
    const src = candidates[0]?.src;
    if (!src || !src.startsWith("blob:")) {
      return null;
    }

    const response = await fetch(src);
    if (!response.ok) {
      return null;
    }

    const arrayBuffer = await response.arrayBuffer();
    return {
      contentType: response.headers.get("content-type") || "audio/ogg",
      bytes: Array.from(new Uint8Array(arrayBuffer))
    };
  }, { duration, timeText }).catch(() => null);

  if (embedded?.bytes?.length) {
    return {
      contentType: embedded.contentType || "audio/ogg",
      buffer: Buffer.from(embedded.bytes)
    };
  }

  throw new Error(`MAX voice media response was not captured for ${label}.`);
}

async function downloadDomStickerThroughScreenshot(p, request) {
  const testId = String(request?.testId || "").trim();
  const timeText = String(request?.timeText || "").trim();
  const fallbackSelector = String(request?.selector || "[data-testid^='sticker-'], button[class*='sticker' i], [class*='sticker' i]");
  const kindLabel = String(request?.kindLabel || "MAX sticker canvas");
  const selectorForTestId = (value) => `[data-testid="${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"]`;
  const visualHandleFor = async (handle) => {
    const visual = await handle.evaluateHandle((node) => {
      const element = node instanceof Element ? node : node?.parentElement;
      if (!element) return null;

      const candidates = [
        ...(element.matches("canvas,img,image,svg") ? [element] : []),
        ...Array.from(element.querySelectorAll("canvas,img,image,svg,[style*='background' i]"))
      ];
      const scored = candidates
        .map((candidate) => {
          const rect = candidate.getBoundingClientRect();
          const style = window.getComputedStyle(candidate);
          if (style.visibility === "hidden" ||
            style.display === "none" ||
            rect.width <= 0 ||
            rect.height <= 0) {
            return null;
          }

          const semantic = [
            candidate.getAttribute?.("data-testid"),
            candidate.getAttribute?.("aria-label"),
            candidate.getAttribute?.("title"),
            candidate.className?.baseVal || candidate.className,
            candidate.tagName
          ].filter(Boolean).join(" ").toLowerCase();
          let score = rect.width * rect.height;
          if (candidate.matches("canvas,img,image,svg")) score += 100000;
          if (/sticker|emoji|lottie|emoticon|\u0441\u0442\u0438\u043a\u0435\u0440|\u044d\u043c\u043e\u0434\u0437\u0438/.test(semantic)) score += 50000;
          return { candidate, score };
        })
        .filter(Boolean)
        .sort((a, b) => b.score - a.score);

      return scored[0]?.candidate || element;
    }).catch(() => null);

    const element = visual?.asElement?.();
    if (element) {
      return element;
    }

    await visual?.dispose?.().catch(() => {});
    return handle;
  };
  const resolveVisualHandles = async (handles) => {
    const resolved = [];
    for (const handle of handles) {
      const visual = await visualHandleFor(handle);
      resolved.push(visual);
      if (visual !== handle) {
        resolved.push(handle);
      }
    }
    return resolved;
  };
  const captureCanvasPng = async (handle) => {
    const result = await handle.evaluate(async (node) => {
      const element = node instanceof Element ? node : node?.parentElement;
      const canvas = element?.matches?.("canvas")
        ? element
        : element?.querySelector?.("canvas");
      if (!(canvas instanceof HTMLCanvasElement)) {
        return { hasCanvas: false, blocked: false, dataUrl: null };
      }

      const sleep = (ms) => new Promise((resolve) => window.setTimeout(resolve, ms));
      const hasPaintedPixels = () => {
        const width = canvas.width;
        const height = canvas.height;
        if (width <= 0 || height <= 0) return false;

        let data;
        try {
          const context = canvas.getContext("2d", { willReadFrequently: true });
          if (!context) return true;
          data = context.getImageData(0, 0, width, height).data;
        } catch (_error) {
          return null;
        }

        const totalPixels = width * height;
        const step = Math.max(1, Math.floor(totalPixels / 12000));
        let painted = 0;
        for (let pixel = 0; pixel < totalPixels; pixel += step) {
          if (data[pixel * 4 + 3] > 8) {
            painted++;
          }
        }

        return painted >= Math.max(6, Math.ceil(totalPixels / step * 0.01));
      };

      for (let attempt = 0; attempt < 10; attempt++) {
        const painted = hasPaintedPixels();
        if (painted === true) {
          try {
            return { hasCanvas: true, blocked: false, dataUrl: canvas.toDataURL("image/png") };
          } catch (_error) {
            return { hasCanvas: true, blocked: true, dataUrl: null };
          }
        }

        if (painted === null) {
          try {
            return { hasCanvas: true, blocked: true, dataUrl: canvas.toDataURL("image/png") };
          } catch (_error) {
            return { hasCanvas: true, blocked: true, dataUrl: null };
          }
        }

        await sleep(200);
      }

      return { hasCanvas: true, blocked: false, dataUrl: null };
    }).catch(() => ({ hasCanvas: false, blocked: false, dataUrl: null }));

    const dataUrl = String(result?.dataUrl || "");
    const prefix = "data:image/png;base64,";
    return {
      hasCanvas: Boolean(result?.hasCanvas),
      blocked: Boolean(result?.blocked),
      buffer: dataUrl.startsWith(prefix) ? Buffer.from(dataUrl.slice(prefix.length), "base64") : null
    };
  };
  const inspectStickerPng = async (buffer) => {
    const base64 = buffer.toString("base64");
    return await p.evaluate(async (dataUrl) => {
      const image = new Image();
      image.src = dataUrl;
      await image.decode();

      const canvas = document.createElement("canvas");
      canvas.width = image.naturalWidth;
      canvas.height = image.naturalHeight;
      const context = canvas.getContext("2d", { willReadFrequently: true });
      if (!context || canvas.width <= 0 || canvas.height <= 0) {
        return null;
      }

      context.drawImage(image, 0, 0);
      const data = context.getImageData(0, 0, canvas.width, canvas.height).data;
      const totalPixels = canvas.width * canvas.height;
      const step = Math.max(1, Math.floor(totalPixels / 20000));
      let sampled = 0;
      let opaque = 0;
      let dark = 0;
      let white = 0;
      let cyan = 0;
      let sumR = 0;
      let sumG = 0;
      let sumB = 0;

      for (let pixel = 0; pixel < totalPixels; pixel += step) {
        const offset = pixel * 4;
        const r = data[offset];
        const g = data[offset + 1];
        const b = data[offset + 2];
        const a = data[offset + 3];
        sampled++;
        if (a <= 8) {
          continue;
        }

        opaque++;
        sumR += r;
        sumG += g;
        sumB += b;
        if (Math.max(r, g, b) < 95) dark++;
        if (Math.min(r, g, b) > 230) white++;
        if (b > r + 25 && g > r + 20 && b > 150 && g > 130) cyan++;
      }

      return {
        width: canvas.width,
        height: canvas.height,
        sampled,
        opaqueRatio: sampled ? opaque / sampled : 0,
        darkRatio: opaque ? dark / opaque : 0,
        whiteRatio: opaque ? white / opaque : 0,
        cyanRatio: opaque ? cyan / opaque : 0,
        avgR: opaque ? sumR / opaque : 0,
        avgG: opaque ? sumG / opaque : 0,
        avgB: opaque ? sumB / opaque : 0
      };
    }, `data:image/png;base64,${base64}`).catch(() => null);
  };
  const isMaxWallpaperCapture = (metrics) => {
    if (!metrics) {
      return false;
    }

    return metrics.opaqueRatio > 0.98 &&
      metrics.cyanRatio > 0.72 &&
      metrics.darkRatio < 0.03 &&
      metrics.whiteRatio < 0.08 &&
      metrics.avgB > metrics.avgR + 45 &&
      metrics.avgG > metrics.avgR + 30;
  };
  const stripMaxWallpaperFromStickerPng = async (buffer) => {
    const base64 = buffer.toString("base64");
    const strippedDataUrl = await p.evaluate(async (dataUrl) => {
      const image = new Image();
      image.src = dataUrl;
      await image.decode();

      const canvas = document.createElement("canvas");
      canvas.width = image.naturalWidth;
      canvas.height = image.naturalHeight;
      const context = canvas.getContext("2d", { willReadFrequently: true });
      if (!context || canvas.width <= 0 || canvas.height <= 0) {
        return null;
      }

      context.drawImage(image, 0, 0);
      const imageData = context.getImageData(0, 0, canvas.width, canvas.height);
      const data = imageData.data;
      let kept = 0;

      for (let offset = 0; offset < data.length; offset += 4) {
        const r = data[offset];
        const g = data[offset + 1];
        const b = data[offset + 2];
        const a = data[offset + 3];
        if (a <= 8) {
          continue;
        }

        const looksLikeMaxWallpaper = b > r + 25 &&
          g > r + 20 &&
          b > 150 &&
          g > 130;
        if (looksLikeMaxWallpaper) {
          data[offset + 3] = 0;
          continue;
        }

        kept++;
      }

      if (kept < Math.max(80, Math.floor(canvas.width * canvas.height * 0.01))) {
        return null;
      }

      context.putImageData(imageData, 0, 0);
      return canvas.toDataURL("image/png");
    }, `data:image/png;base64,${base64}`).catch(() => null);

    const prefix = "data:image/png;base64,";
    return typeof strippedDataUrl === "string" && strippedDataUrl.startsWith(prefix)
      ? Buffer.from(strippedDataUrl.slice(prefix.length), "base64")
      : null;
  };
  const hasMeaningfulStickerContent = (metrics) => {
    if (!metrics) {
      return false;
    }

    return metrics.opaqueRatio > 0.01 &&
      (metrics.darkRatio > 0.01 ||
        metrics.whiteRatio > 0.03 ||
        metrics.cyanRatio < 0.5);
  };
  const stickerCaptureResult = async (buffer) => {
    const metrics = await inspectStickerPng(buffer);
    if (isMaxWallpaperCapture(metrics)) {
      const stripped = await stripMaxWallpaperFromStickerPng(buffer);
      if (stripped) {
        const strippedMetrics = await inspectStickerPng(stripped);
        if (!isMaxWallpaperCapture(strippedMetrics) && hasMeaningfulStickerContent(strippedMetrics)) {
          return { contentType: "image/png", buffer: stripped };
        }
      }

      throw new Error(`${kindLabel} capture matched MAX chat wallpaper instead of sticker.`);
    }

    return { contentType: "image/png", buffer };
  };
  const screenshotCandidate = async (handles, requestedIndex) => {
    const candidates = [];
    for (const handle of handles) {
      const meta = await handle.evaluate((node, options) => {
        const requestedTimeText = String(options?.timeText || "");
        const acceptSmall = Boolean(options?.acceptSmall);
        const element = node instanceof Element ? node : node.parentElement;
        if (!element) {
          return null;
        }

        const style = window.getComputedStyle(element);
        const rect = element.getBoundingClientRect();
        if (style.visibility === "hidden" ||
          style.display === "none" ||
          rect.width <= 0 ||
          rect.height <= 0 ||
          rect.bottom < 0 ||
          rect.right < 0 ||
          rect.top > window.innerHeight ||
          rect.left > window.innerWidth) {
          return null;
        }

        const wrapper = element.closest("[class*='messageWrapper' i], [role='listitem'], [class*='item' i], [class*='bubbleContent' i], [class*='bordersWrapper' i]") || element;
        const cleanText = (value) => String(value || "")
          .replace(/\u00a0/g, " ")
          .replace(/\s+/g, " ")
          .trim();
        const wrapperText = cleanText(wrapper.innerText || wrapper.textContent);
        const metaText = Array.from(wrapper.querySelectorAll("[class*='meta' i], time"))
          .map((item) => cleanText(
            item.getAttribute?.("datetime") ||
            item.getAttribute?.("aria-label") ||
            item.getAttribute?.("title") ||
            item.innerText ||
            item.textContent))
          .filter(Boolean)
          .join(" ");
        const timeMatches = requestedTimeText &&
          (wrapperText.includes(requestedTimeText) || metaText.includes(requestedTimeText));
        const semanticRoot = element.closest("[data-testid^='sticker-'], [data-testid*='emoji' i], [class*='sticker' i], [class*='emoji' i], [class*='lottie' i]") || element;
        const semantic = [
          element.getAttribute("data-testid"),
          element.getAttribute("aria-label"),
          element.getAttribute("title"),
          element.className,
          semanticRoot.getAttribute?.("data-testid"),
          semanticRoot.getAttribute?.("aria-label"),
          semanticRoot.getAttribute?.("title"),
          semanticRoot.className,
          wrapper.className,
          wrapperText
        ].filter(Boolean).join(" ").toLowerCase();
        const looksLikeSticker = /sticker|\u0441\u0442\u0438\u043a\u0435\u0440|emoji|\u044d\u043c\u043e\u0434\u0437\u0438|lottie|emoticon/.test(semantic) ||
          Boolean(element.querySelector("canvas,img,svg")) ||
          element.matches("canvas,img,svg");
        const area = rect.width * rect.height;
        let score = 0;
        if (looksLikeSticker) score += 4;
        if (timeMatches) score += 40;
        if (acceptSmall && element.matches("canvas,img,svg")) score += 8;
        if (rect.width >= (acceptSmall ? 20 : 72) && rect.height >= (acceptSmall ? 20 : 72)) score += 16;
        if (rect.width >= 120 && rect.height >= 120) score += 8;
        score += Math.min(12, area / 2500);
        if (rect.width < (acceptSmall ? 12 : 40) || rect.height < (acceptSmall ? 12 : 40)) score -= 30;
        if (area < (acceptSmall ? 256 : 4096)) score -= 20;
        return {
          score,
          x: rect.x,
          width: rect.width,
          height: rect.height,
          y: rect.y,
          area,
          timeMatches: Boolean(timeMatches)
        };
      }, { timeText, acceptSmall: Boolean(request?.acceptSmall) }).catch(() => null);

      if (!meta || meta.score <= 0) {
        await handle.dispose().catch(() => {});
        continue;
      }

      candidates.push({ handle, meta });
    }

    const strict = timeText
      ? candidates.filter((candidate) => candidate.meta.timeMatches)
      : candidates;
    if (timeText && request?.requireTimeMatch && strict.length === 0) {
      for (const item of candidates) {
        await item.handle.dispose().catch(() => {});
      }
      return null;
    }
    const sorted = (strict.length ? strict : candidates)
      .sort((a, b) => b.meta.score - a.meta.score || b.meta.area - a.meta.area || b.meta.y - a.meta.y);
    if (sorted.length === 0) {
      return null;
    }
    const selectedIndex = Math.max(0, Math.min(requestedIndex, sorted.length - 1));
    const orderedTargets = [
      ...sorted.slice(selectedIndex),
      ...sorted.slice(0, selectedIndex)
    ];

    const screenshotClip = async (box) => {
      if (!Number.isFinite(box?.x) ||
        !Number.isFinite(box?.y) ||
        !Number.isFinite(box?.width) ||
        !Number.isFinite(box?.height)) {
        return null;
      }

      const viewport = p.viewportSize() || { width: 1280, height: 720 };
      const x = Math.max(0, Math.floor(box.x));
      const y = Math.max(0, Math.floor(box.y));
      const width = Math.min(Math.ceil(box.width), Math.max(1, viewport.width - x));
      const height = Math.min(Math.ceil(box.height), Math.max(1, viewport.height - y));
      if (width <= 0 || height <= 0) {
        return null;
      }
      const maxClipSize = Number(request?.maxClipSize || 0);
      if (maxClipSize > 0 && (width > maxClipSize || height > maxClipSize)) {
        return null;
      }

      return await p.screenshot({
        type: "png",
        clip: { x, y, width, height },
        timeout: 10000
      });
    };

    const captureErrors = [];
    try {
      for (const target of orderedTargets) {
        const metaBox = {
          x: target.meta.x,
          y: target.meta.y,
          width: target.meta.width,
          height: target.meta.height
        };
        const currentBoxOrMeta = async () => {
          const box = await target.handle.boundingBox().catch(() => null);
          return box && box.width > 0 && box.height > 0 ? box : metaBox;
        };

        try {
          await target.handle.scrollIntoViewIfNeeded({ timeout: 3000 }).catch(() => {});
          const canvasCapture = await captureCanvasPng(target.handle);
          if (canvasCapture.buffer) {
            return await stickerCaptureResult(canvasCapture.buffer);
          }

          let buffer;
          if (request?.acceptSmall) {
            buffer = await screenshotClip(await currentBoxOrMeta());
            if (!buffer) {
              throw new Error(`${kindLabel} clip was not visible.`);
            }
          } else {
            try {
              buffer = await target.handle.screenshot({ type: "png", timeout: 5000 });
            } catch (error) {
              buffer = await screenshotClip(await currentBoxOrMeta());
              if (!buffer) {
                throw error;
              }
            }
          }
          if (!buffer) {
            buffer = await target.handle.screenshot({ type: "png", timeout: 5000 });
          }
          return await stickerCaptureResult(buffer);
        } catch (error) {
          captureErrors.push(error?.message || String(error));
        }
      }

      if (captureErrors.length > 0) {
        throw new Error(`${kindLabel} was not captured: ${captureErrors.slice(0, 5).join("; ")}`);
      }

      return null;
    } finally {
      for (const item of candidates) {
        await item.handle.dispose().catch(() => {});
      }
    }
  };

  const index = Number.isFinite(Number(request?.index)) ? Number(request.index) : 0;
  let testIdCaptureError = null;
  if (testId) {
    const handles = await p.$$(selectorForTestId(testId));
    try {
      const result = await screenshotCandidate(await resolveVisualHandles(handles), 0);
      if (result) {
        return result;
      }
    } catch (error) {
      testIdCaptureError = error;
    }
  }

  const handles = await p.$$(fallbackSelector);
  const result = await screenshotCandidate(await resolveVisualHandles(handles), index);
  if (!result) {
    if (testIdCaptureError) {
      throw testIdCaptureError;
    }

    throw new Error(`${kindLabel} was not found.`);
  }

  return result;
}

function contentTypeFromFileName(fileName) {
  const ext = String(fileName || "").toLowerCase().split(".").pop();
  switch (ext) {
    case "txt": return "text/plain";
    case "csv": return "text/csv";
    case "vcf": return "text/vcard";
    case "pdf": return "application/pdf";
    case "zip": return "application/zip";
    case "rar": return "application/vnd.rar";
    case "7z": return "application/x-7z-compressed";
    case "doc": return "application/msword";
    case "docx": return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
    case "xls": return "application/vnd.ms-excel";
    case "xlsx": return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
    case "ppt": return "application/vnd.ms-powerpoint";
    case "pptx": return "application/vnd.openxmlformats-officedocument.presentationml.presentation";
    default: return "application/octet-stream";
  }
}

function attachNetworkCapture(p) {
  if (p.__qmaxNetworkCaptureAttached) {
    return;
  }

  p.__qmaxNetworkCaptureAttached = true;
  p.on("response", async (response) => {
    try {
      const request = response.request();
      const url = response.url();
      if (!url.includes("max.ru")) {
        return;
      }

      const headers = response.headers();
      networkLog.push({
        at: new Date().toISOString(),
        method: request.method(),
        url: redactUrl(url),
        status: response.status(),
        resourceType: request.resourceType(),
        contentType: String(headers["content-type"] || "").split(";")[0]
      });
      if (networkLog.length > 500) {
        networkLog.splice(0, networkLog.length - 500);
      }
    } catch {
      // Network inspection is best-effort and must never break the bridge.
    }
  });
}

function redactUrl(value) {
  try {
    const url = new URL(value);
    for (const key of Array.from(url.searchParams.keys())) {
      if (/token|auth|code|session|secret|key|hash/i.test(key)) {
        url.searchParams.set(key, "[redacted]");
      }
    }
    return url.toString();
  } catch {
    return String(value || "");
  }
}

async function inspectDom(p) {
  return await p.evaluate(() => {
    const cleanText = (value, limit = 500) => String(value || "").replace(/\s+/g, " ").trim().slice(0, limit);
    const isVisible = (element) => {
      const style = window.getComputedStyle(element);
      const rect = element.getBoundingClientRect();
      return style.visibility !== "hidden" &&
        style.display !== "none" &&
        rect.width > 0 &&
        rect.height > 0 &&
        rect.bottom >= 0 &&
        rect.right >= 0 &&
        rect.top <= window.innerHeight &&
        rect.left <= window.innerWidth;
    };

    const cssImageUrl = (element) => {
      const style = window.getComputedStyle(element);
      const value = [
        style.backgroundImage,
        style.maskImage,
        style.webkitMaskImage
      ].find((item) => item && item !== "none") || "";
      const match = value.match(/url\(["']?(.+?)["']?\)/i);
      if (!match) return null;
      try {
        return new URL(match[1], location.href).href;
      } catch {
        return match[1];
      }
    };

    const elements = Array.from(document.querySelectorAll("a,button,input,textarea,img,picture,video,audio,canvas,svg,[role],[data-testid],[class]"))
      .filter(isVisible)
      .map((element) => {
        const rect = element.getBoundingClientRect();
        const tag = element.tagName.toLowerCase();
        const mediaSrc = element.currentSrc ||
          element.src ||
          element.poster ||
          element.href?.baseVal ||
          element.getAttribute("src") ||
          element.getAttribute("href") ||
          element.getAttribute("xlink:href") ||
          element.getAttribute("data-url") ||
          element.getAttribute("data-src") ||
          cssImageUrl(element);
        return {
          tag,
          role: element.getAttribute("role"),
          id: element.id || null,
          className: cleanText(element.className, 180),
          testId: element.getAttribute("data-testid"),
          ariaLabel: element.getAttribute("aria-label"),
          href: element.getAttribute("href"),
          mediaSrc,
          text: cleanText(element.innerText || element.value || element.getAttribute("aria-label")),
          rect: {
            x: Math.round(rect.x),
            y: Math.round(rect.y),
            width: Math.round(rect.width),
            height: Math.round(rect.height)
          }
        };
      })
      .filter((element) => {
        const haystack = `${element.tag} ${element.className} ${element.mediaSrc || ""}`.toLowerCase();
        return element.text ||
          element.ariaLabel ||
          element.testId ||
          element.role ||
          element.mediaSrc ||
          /message|bubble|sticker|emoji|attach|media|image|picture|canvas|svg/.test(haystack);
      })
      .slice(0, 400);

    return {
      url: location.href,
      title: document.title,
      bodyText: cleanText(document.body?.innerText, 2000),
      capturedAt: new Date().toISOString(),
      viewport: { width: window.innerWidth, height: window.innerHeight },
      elements
    };
  });
}

async function inspectStorage(p) {
  return await p.evaluate(async () => {
    const storageKeys = (storage) => {
      const keys = [];
      for (let index = 0; index < storage.length; index++) {
        const key = storage.key(index);
        const value = key ? storage.getItem(key) : null;
        keys.push({
          key,
          valueLength: value ? value.length : 0
        });
      }
      return keys;
    };

    const indexedDbDatabases = [];
    if (indexedDB.databases) {
      for (const dbInfo of await indexedDB.databases()) {
        const entry = {
          name: dbInfo.name,
          version: dbInfo.version,
          objectStores: []
        };
        if (dbInfo.name) {
          try {
            const opened = await new Promise((resolve, reject) => {
              const request = indexedDB.open(dbInfo.name);
              request.onerror = () => reject(request.error);
              request.onsuccess = () => resolve(request.result);
            });
            for (const storeName of Array.from(opened.objectStoreNames)) {
              const transaction = opened.transaction(storeName, "readonly");
              const store = transaction.objectStore(storeName);
              const count = await new Promise((resolve) => {
                const request = store.count();
                request.onerror = () => resolve(null);
                request.onsuccess = () => resolve(request.result);
              });
              entry.objectStores.push({ name: storeName, count });
            }
            opened.close();
          } catch {
            entry.error = "open failed";
          }
        }
        indexedDbDatabases.push(entry);
      }
    }

    return {
      url: location.href,
      capturedAt: new Date().toISOString(),
      localStorage: storageKeys(localStorage),
      sessionStorage: storageKeys(sessionStorage),
      indexedDbDatabases
    };
  });
}

async function inspectIndexedDbSamples(p, options) {
  return await p.evaluate(async (opts) => {
    const sensitiveKeyPattern = /(token|auth|session|secret|cookie|password|phone|email|jwt|bearer|refresh|access|credential|csrf|hash|salt|signature)/i;

    const truncate = (value, limit) => {
      const text = String(value ?? "");
      return text.length > limit
        ? `${text.slice(0, limit)}...`
        : text;
    };

    const summarize = (value, keyHint = "", depth = 0) => {
      const type = Array.isArray(value) ? "array" : typeof value;
      if (value === null || value === undefined) {
        return { type: String(value) };
      }

      if (sensitiveKeyPattern.test(keyHint)) {
        return { type, redacted: true };
      }

      if (type === "string") {
        return {
          type,
          length: value.length,
          preview: truncate(value, opts.stringLimit)
        };
      }

      if (type === "number" || type === "boolean") {
        return { type, value };
      }

      if (value instanceof Date) {
        return { type: "date", value: value.toISOString() };
      }

      if (value instanceof ArrayBuffer) {
        return { type: "arrayBuffer", byteLength: value.byteLength };
      }

      if (ArrayBuffer.isView(value)) {
        return { type: value.constructor.name, byteLength: value.byteLength };
      }

      if (Array.isArray(value)) {
        return {
          type,
          length: value.length,
          items: depth >= 2
            ? []
            : value.slice(0, 5).map((item, index) => summarize(item, `${keyHint}[${index}]`, depth + 1))
        };
      }

      if (type === "object") {
        const entries = Object.entries(value).slice(0, 40);
        return {
          type,
          keys: Object.keys(value).slice(0, 80),
          fields: depth >= 3
            ? {}
            : Object.fromEntries(entries.map(([key, fieldValue]) => [key, summarize(fieldValue, key, depth + 1)]))
        };
      }

      return { type };
    };

    const requestAsPromise = (request) => new Promise((resolve, reject) => {
      request.onerror = () => reject(request.error);
      request.onsuccess = () => resolve(request.result);
    });

    const openDatabase = (name) => new Promise((resolve, reject) => {
      const request = indexedDB.open(name);
      request.onerror = () => reject(request.error);
      request.onsuccess = () => resolve(request.result);
    });

    const databases = indexedDB.databases
      ? (await indexedDB.databases()).filter((db) => db.name).slice(0, opts.dbLimit)
      : [];

    const result = [];
    for (const dbInfo of databases) {
      const database = {
        name: dbInfo.name,
        version: dbInfo.version,
        stores: []
      };

      try {
        const opened = await openDatabase(dbInfo.name);
        const storeNames = Array.from(opened.objectStoreNames).slice(0, opts.storeLimit);
        for (const storeName of storeNames) {
          const transaction = opened.transaction(storeName, "readonly");
          const store = transaction.objectStore(storeName);
          const count = await requestAsPromise(store.count()).catch(() => null);
          const records = await requestAsPromise(store.getAll(undefined, opts.sampleLimit)).catch(() => []);
          database.stores.push({
            name: storeName,
            keyPath: store.keyPath,
            autoIncrement: store.autoIncrement,
            count,
            samples: records.map((record) => summarize(record))
          });
        }
        opened.close();
      } catch (error) {
        database.error = String(error?.message || error);
      }

      result.push(database);
    }

    return {
      url: location.href,
      capturedAt: new Date().toISOString(),
      limits: opts,
      databases: result
    };
  }, options);
}

function cleanComparableText(value, limit = 500) {
  return String(value || "")
    .replace(/\u00a0/g, " ")
    .replace(/\s+/g, " ")
    .trim()
    .slice(0, limit);
}

function isGenericMediaText(value) {
  return /^(\u0444\u043e\u0442\u043e|photo|image|gif|\u0432\u0438\u0434\u0435\u043e|video|\u0430\u0443\u0434\u0438\u043e|audio|\u0433\u043e\u043b\u043e\u0441\u043e\u0432\u043e\u0435|voice|\u0441\u0442\u0438\u043a\u0435\u0440|sticker|\u044d\u043c\u043e\u0434\u0437\u0438|emoji|\u043f\u0440\u0438\u043a\u0440\u0435\u043f\u043b[\u0435\u0451]\u043d(?:\u043d\u044b\u0435|\u043d\u043e\u0435)?\s+\u0444\u043e\u0442\u043e)$/i
    .test(cleanComparableText(value, 120));
}

async function extractUpdates(p) {
  const raw = await p.evaluate(async () => {
    const cleanText = (value, limit = 500) => String(value || "")
      .replace(/\u00a0/g, " ")
      .replace(/\s+/g, " ")
      .trim()
      .slice(0, limit);
    const linesFrom = (value) => String(value || "")
      .split(/\n+/)
      .map((line) => cleanText(line, 160))
      .filter(Boolean);
    const isVisible = (element) => {
      const style = window.getComputedStyle(element);
      const rect = element.getBoundingClientRect();
      return style.visibility !== "hidden" &&
        style.display !== "none" &&
        rect.width > 20 &&
        rect.height > 12 &&
        rect.bottom >= 0 &&
        rect.right >= 0 &&
        rect.top <= window.innerHeight &&
        rect.left <= window.innerWidth;
    };
    const isChatRowVisibleEnough = (element) => {
      const style = window.getComputedStyle(element);
      const rect = element.getBoundingClientRect();
      return style.visibility !== "hidden" &&
        style.display !== "none" &&
        rect.width > 20 &&
        rect.height > 12 &&
        rect.bottom >= -140 &&
        rect.right >= 0 &&
        rect.top <= window.innerHeight &&
        rect.left <= window.innerWidth;
    };
    const badText = /(\u0432\u043e\u0439\u0442\u0438|qr|\u043d\u0435 \u0440\u043e\u0431\u043e\u0442|\u043d\u043e\u043c\u0435\u0440 \u0442\u0435\u043b\u0435\u0444\u043e\u043d\u0430|\u043f\u043e\u043b\u0438\u0442\u0438\u043a|\u0441\u043e\u0433\u043b\u0430\u0448\u0435\u043d|\u043f\u043e\u043b\u0443\u0447\u0438\u0442\u044c \u043d\u043e\u0432\u044b\u0439 \u043a\u043e\u0434|\u0432\u0432\u0435\u0434\u0438\u0442\u0435 \u043a\u043e\u0434|\u043a\u043e\u0434 max|\u0441\u043c\u0441|sms)/i;
    const isGenericMediaText = (value) => /^(\u0444\u043e\u0442\u043e|photo|image|gif|\u0432\u0438\u0434\u0435\u043e|video|\u0430\u0443\u0434\u0438\u043e|audio|\u0433\u043e\u043b\u043e\u0441\u043e\u0432\u043e\u0435|voice|\u0441\u0442\u0438\u043a\u0435\u0440|sticker|\u044d\u043c\u043e\u0434\u0437\u0438|emoji|\u043f\u0440\u0438\u043a\u0440\u0435\u043f\u043b[\u0435\u0451]\u043d(?:\u043d\u044b\u0435|\u043d\u043e\u0435)?\s+\u0444\u043e\u0442\u043e)$/i.test(cleanText(value, 120));
    const absoluteUrl = (value) => {
      const raw = String(value || "").trim();
      if (!raw || raw.startsWith("data:")) return null;
      try {
        return new URL(raw, location.href).href;
      } catch {
        return null;
      }
    };
    const cssBackgroundUrl = (element) => {
      const image = window.getComputedStyle(element).backgroundImage || "";
      const match = image.match(/url\(["']?(.+?)["']?\)/i);
      return match ? absoluteUrl(match[1]) : null;
    };
    const extractAvatarUrl = (element) => {
      const rowRect = element.getBoundingClientRect();
      const candidates = Array.from(element.querySelectorAll("img, image, [style*='background' i], [class*='avatar' i], [class*='photo' i]"));
      for (const node of candidates) {
        if (!(node instanceof Element)) continue;
        const rect = node.getBoundingClientRect();
        if (rect.width < 24 || rect.height < 24 || rect.width > 96 || rect.height > 96) continue;
        if (rect.left > rowRect.left + rowRect.width * 0.45) continue;
        const source = node.currentSrc ||
          node.src ||
          node.href?.baseVal ||
          node.getAttribute("src") ||
          node.getAttribute("href") ||
          cssBackgroundUrl(node);
        const url = absoluteUrl(source);
        if (url && !/pattern|sprite|emoji|sticker|logo/i.test(url)) {
          return url;
        }
      }
      return null;
    };
    const extractChatUrl = (element) => {
      const candidates = [
        element.getAttribute("href"),
        element.closest("a")?.getAttribute("href"),
        element.getAttribute("data-url"),
        element.getAttribute("data-href"),
        element.getAttribute("data-link"),
        element.getAttribute("data-path")
      ];
      for (const attr of Array.from(element.attributes || [])) {
        if (/url|href|link|path/i.test(attr.name)) {
          candidates.push(attr.value);
        }
      }

      for (const candidate of candidates) {
        const url = absoluteUrl(candidate);
        if (url) {
          return url;
        }
      }

      return null;
    };
    const extractTitle = (element, lines) => {
      const titleNode = element.querySelector("h3, [class*='title' i] [class*='name' i], [class*='name' i]");
      const title = cleanText(titleNode?.innerText || titleNode?.textContent, 120);
      return title || lines.find((line) => line && !/^\d{1,3}$/.test(line)) || "";
    };
    const extractPreview = (element, title, lines) => {
      const timeText = cleanText(element.querySelector("[class*='time' i], [class*='meta' i]")?.innerText);
      const ignored = new Set([
        title,
        timeText,
        cleanText(element.querySelector("[class*='badge' i], [class*='indicator' i], [class*='counter' i]")?.innerText)
      ].filter(Boolean));
      const candidates = Array.from(element.querySelectorAll("span[class*='text' i], div[class*='text' i], p, [class*='subtitle' i]"))
        .map((node) => cleanText(node.innerText || node.textContent, 240))
        .filter((text) => text && !ignored.has(text))
        .filter((text) => !/^\d{1,3}$/.test(text));
      return candidates.find((text) => text !== title) ||
        lines.find((line) => line !== title && !ignored.has(line) && !/^\d{1,3}$/.test(line)) ||
        null;
    };
    const extractTimeText = (element, lines) => {
      const direct = cleanText(element.querySelector("[class*='time' i], [class*='meta' i]")?.innerText, 80);
      if (direct) return direct;
      return lines.find((line) =>
        /^\d{1,2}:\d{2}$/.test(line) ||
        /^(\u0432\u0447\u0435\u0440\u0430|\u0441\u0435\u0433\u043e\u0434\u043d\u044f)$/i.test(line) ||
        /^\d{1,2}\s+[^\s.]+\.?$/i.test(line) ||
        /^(mon|tue|wed|thu|fri|sat|sun|\u043f\u043d|\u0432\u0442|\u0441\u0440|\u0447\u0442|\u043f\u0442|\u0441\u0431|\u0432\u0441)$/i.test(line)
      ) || null;
    };
    const chatSelector = [
      "aside button.cell",
      "aside button[class*='cell' i]",
      "aside [role='presentation'] button",
      "aside [class*='wrapper' i] button",
      "[data-testid*='chat' i]",
      "[data-testid*='dialog' i]",
      "[data-testid*='conversation' i]",
      "a[href*='chat' i]",
      "a[href*='dialog' i]"
    ].join(",");
    const seen = new Set();
    const chats = [];
    const collectVisibleChats = () => {
      for (const element of Array.from(document.querySelectorAll(chatSelector))) {
        if (!isChatRowVisibleEnough(element)) continue;
        const rect = element.getBoundingClientRect();
        const text = cleanText(element.innerText || element.textContent, 400);
        if (!text || text.length < 2 || text.length > 380 || badText.test(text)) continue;
        const lines = linesFrom(element.innerText || element.textContent);
        if (lines.length === 0) continue;
        const title = extractTitle(element, lines);
        if (!title || title.length < 2 || badText.test(title)) continue;
        const semantic = [
          element.getAttribute("role"),
          element.getAttribute("data-testid"),
          element.className,
          element.getAttribute("href")
        ].join(" ");
        const looksLikeChat = element.matches("button.cell, button[class*='cell' i]") ||
          lines.length >= 2 ||
          /chat|dialog|conversation|listitem|cell/i.test(semantic) ||
          (rect.left > 60 && rect.left < window.innerWidth * 0.55);
        if (!looksLikeChat) continue;
        const avatarUrl = extractAvatarUrl(element);
        const href = extractChatUrl(element);
        const key = `${title}|${avatarUrl || href || text}`;
        if (seen.has(key)) continue;
        seen.add(key);
        chats.push({
          title,
          text,
          preview: extractPreview(element, title, lines),
          timeText: extractTimeText(element, lines),
          avatarUrl,
          href,
          rect: {
            x: Math.round(rect.x),
            y: Math.round(rect.y),
            width: Math.round(rect.width),
            height: Math.round(rect.height)
          }
        });
        if (chats.length >= 600) break;
      }
    };

    const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
    const scrollRoot = Array.from(document.querySelectorAll("aside, aside *"))
      .filter((element) => element instanceof HTMLElement)
      .filter((element) => {
        const style = window.getComputedStyle(element);
        const rect = element.getBoundingClientRect();
        return style.display !== "none" &&
          style.visibility !== "hidden" &&
          rect.width > 180 &&
          rect.height > 160 &&
          element.scrollHeight > element.clientHeight + 80;
      })
      .sort((a, b) => (b.scrollHeight - b.clientHeight) - (a.scrollHeight - a.clientHeight))[0] || null;

    if (scrollRoot) {
      const maxTop = () => Math.max(0, scrollRoot.scrollHeight - scrollRoot.clientHeight);
      scrollRoot.scrollTop = 0;
      scrollRoot.dispatchEvent(new Event("scroll", { bubbles: true }));
      await delay(120);

      let previousTop = -1;
      for (let page = 0; page < 180 && chats.length < 600; page++) {
        collectVisibleChats();
        const bottom = maxTop();
        if (scrollRoot.scrollTop >= bottom - 4) break;
        const nextTop = Math.min(bottom, scrollRoot.scrollTop + Math.max(220, Math.floor(scrollRoot.clientHeight * 0.8)));
        if (nextTop === previousTop || nextTop === scrollRoot.scrollTop) break;
        previousTop = scrollRoot.scrollTop;
        scrollRoot.scrollTop = nextTop;
        scrollRoot.dispatchEvent(new Event("scroll", { bubbles: true }));
        await delay(120);
      }

      scrollRoot.scrollTop = 0;
      scrollRoot.dispatchEvent(new Event("scroll", { bubbles: true }));
    } else {
      collectVisibleChats();
    }

    return {
      url: location.href,
      title: document.title,
      chats
    };
  });

  const now = new Date().toISOString();
  const seenExternalIds = new Set();
  return raw.chats.flatMap((chat, index) => {
    const externalId = makeDomChatExternalId(chat.title, chat.text, chat.href, index, chat.avatarUrl);
    if (seenExternalIds.has(externalId)) {
      return [];
    }

    seenExternalIds.add(externalId);
    const outgoing = /^\s*(\u0432\u044b|you)\s*:/i.test(chat.preview || "");
    const messageText = (chat.preview || "").replace(/^(\u0432\u044b|you)\s*:\s*/i, "").trim();
    return [{
      externalId,
      title: chat.title,
      avatarUrl: chat.avatarUrl || null,
      chatUrl: chat.href || null,
      updatedAt: now,
      lastMessagePreview: messageText || null,
      lastMessageIsOutgoing: outgoing,
      lastMessageAt: messageText ? now : null,
      lastMessageTimeText: chat.timeText || null,
      messages: []
    }];
  });
}

async function extractOpenChatHistory(p, requestedExternalChatId) {
  const requestedTitle = decodeDomChatTitle(requestedExternalChatId);
  const raw = await p.evaluate((fallbackTitle) => {
    const cleanText = (value, limit = 4000) => String(value || "")
      .replace(/\u00a0/g, " ")
      .replace(/\s+\n/g, "\n")
      .replace(/\n\s+/g, "\n")
      .replace(/[ \t]+/g, " ")
      .trim()
      .slice(0, limit);
    const isGenericMediaText = (value) => /^(\u0444\u043e\u0442\u043e|photo|image|gif|\u0432\u0438\u0434\u0435\u043e|video|\u0430\u0443\u0434\u0438\u043e|audio|\u0433\u043e\u043b\u043e\u0441\u043e\u0432\u043e\u0435|voice|\u0441\u0442\u0438\u043a\u0435\u0440|sticker|\u044d\u043c\u043e\u0434\u0437\u0438|emoji|\u043f\u0440\u0438\u043a\u0440\u0435\u043f\u043b[\u0435\u0451]\u043d(?:\u043d\u044b\u0435|\u043d\u043e\u0435)?\s+\u0444\u043e\u0442\u043e)$/i.test(cleanText(value, 120));
    const isVisible = (element) => {
      if (!(element instanceof HTMLElement)) return false;
      const style = window.getComputedStyle(element);
      const rect = element.getBoundingClientRect();
      return style.visibility !== "hidden" &&
        style.display !== "none" &&
        rect.width > 0 &&
        rect.height > 0 &&
        rect.bottom >= 0 &&
        rect.right >= 0 &&
        rect.top <= window.innerHeight &&
        rect.left <= window.innerWidth;
    };
    const opened = document.querySelector("[class*='openedChat' i]") ||
      document.querySelector("main") ||
      document.body;
    const openedRect = opened.getBoundingClientRect();
    const stripChatWindowPrefix = (value) => cleanText(value, 160)
      .replace(/^\u041e\u043a\u043d\u043e\s+\u0447\u0430\u0442\u0430\s+\u0441\s+/i, "")
      .trim();
    const selectedTitle = cleanText(document.querySelector("aside button[class*='selected' i] h3")?.innerText, 160);
    const header = opened.querySelector("[class*='header' i]");
    const headerTitle = cleanText(
      header?.querySelector("h1,h2,h3,[class*='title' i],[class*='name' i]")?.innerText ||
      header?.querySelector("button[aria-label]")?.innerText,
      160);
    const title = stripChatWindowPrefix(selectedTitle) ||
      stripChatWindowPrefix(headerTitle) ||
      stripChatWindowPrefix(fallbackTitle) ||
      "\u0427\u0430\u0442 MAX";

    const parseDate = (dateLabel, timeText) => {
      const now = new Date();
      const timeMatch = String(timeText || "").match(/(\d{1,2}):(\d{2})/);
      const hour = timeMatch ? Number(timeMatch[1]) : 12;
      const minute = timeMatch ? Number(timeMatch[2]) : 0;
      const text = cleanText(dateLabel, 80).toLowerCase();
      const futureToleranceMs = 10 * 60 * 1000;
      const setDayOffset = (days) => {
        const result = new Date(now);
        result.setHours(hour, minute, 0, 0);
        result.setDate(result.getDate() - days);
        if (days === 0 && result.getTime() - now.getTime() > futureToleranceMs) {
          result.setDate(result.getDate() - 1);
        }
        return result.toISOString();
      };

      if (!text || text.includes("\u0441\u0435\u0433\u043e\u0434\u043d\u044f")) {
        return setDayOffset(0);
      }
      if (text.includes("\u043f\u043e\u0437\u0430\u0432\u0447\u0435\u0440\u0430")) {
        return setDayOffset(2);
      }
      if (text.includes("\u0432\u0447\u0435\u0440\u0430")) {
        return setDayOffset(1);
      }

      const months = {
        "\u044f\u043d\u0432\u0430\u0440\u044f": 0,
        "\u0444\u0435\u0432\u0440\u0430\u043b\u044f": 1,
        "\u043c\u0430\u0440\u0442\u0430": 2,
        "\u0430\u043f\u0440\u0435\u043b\u044f": 3,
        "\u043c\u0430\u044f": 4,
        "\u0438\u044e\u043d\u044f": 5,
        "\u0438\u044e\u043b\u044f": 6,
        "\u0430\u0432\u0433\u0443\u0441\u0442\u0430": 7,
        "\u0441\u0435\u043d\u0442\u044f\u0431\u0440\u044f": 8,
        "\u043e\u043a\u0442\u044f\u0431\u0440\u044f": 9,
        "\u043d\u043e\u044f\u0431\u0440\u044f": 10,
        "\u0434\u0435\u043a\u0430\u0431\u0440\u044f": 11
      };
      const match = text.match(/(\d{1,2})\s+([^\s.]+)\.?\s*(\d{4})?/i);
      if (match) {
        const day = Number(match[1]);
        const month = months[match[2]];
        const year = match[3] ? Number(match[3]) : now.getFullYear();
        if (Number.isFinite(day) && month !== undefined && Number.isFinite(year)) {
          const parsed = new Date(year, month, day, hour, minute, 0, 0);
          if (!match[3] && parsed.getTime() - now.getTime() > futureToleranceMs) {
            parsed.setFullYear(year - 1);
          }
          return parsed.toISOString();
        }
      }

      return setDayOffset(0);
    };
    const absoluteUrl = (value) => {
      const raw = String(value || "").trim();
      if (!raw || raw.startsWith("data:")) return null;
      try {
        return new URL(raw, location.href).href;
      } catch {
        return null;
      }
    };
    const extensionFromUrl = (url) => {
      try {
        const pathname = new URL(url).pathname;
        const match = pathname.match(/\.([a-z0-9]{2,8})$/i);
        return match ? match[1].toLowerCase() : "";
      } catch {
        return "";
      }
    };
    const srcFromSrcset = (value) => {
      const items = String(value || "")
        .split(",")
        .map((part) => part.trim().split(/\s+/)[0])
        .filter(Boolean);
      return items.at(-1) || null;
    };
    const isStickerUrl = (url) => /(^|\/)(stickers?|sticker-packs?)(\/|$)|st\.max\.ru\/stickers?/i.test(url || "");
    const isEmojiUrl = (url) => /(^|\/)emojis?(\/|$)|st\.max\.ru\/emojis?/i.test(url || "");
    const phoneFromText = (value) => {
      const match = cleanText(value, 500).match(/(?:\+?\d[\d\s().-]{6,}\d)/);
      if (!match) return null;
      const phone = match[0]
        .replace(/[^\d+]/g, "")
        .replace(/(?!^)\+/g, "");
      return phone.length >= 7 ? phone : null;
    };
    const isDownloadText = (value) => /^(download|\u0441\u043a\u0430\u0447\u0430\u0442\u044c|\u0437\u0430\u0433\u0440\u0443\u0437\u0438\u0442\u044c|\u043e\u0442\u043a\u0440\u044b\u0442\u044c|open)$/i.test(cleanText(value, 80));
    const vcardEscape = (value) => cleanText(value, 200)
      .replace(/\\/g, "\\\\")
      .replace(/\n/g, "\\n")
      .replace(/;/g, "\\;")
      .replace(/,/g, "\\,");
    const safeContactFileName = (value) => {
      const clean = cleanText(value || "\u041a\u043e\u043d\u0442\u0430\u043a\u0442", 80)
        .replace(/[\\/:*?"<>|]+/g, " ")
        .trim() || "\u041a\u043e\u043d\u0442\u0430\u043a\u0442";
      return `${clean.slice(0, 70)}.vcf`;
    };
    const domDownloadUrlFromFile = (label, fileName) => `qmax-dom-download:${encodeURIComponent(JSON.stringify({
      label: cleanText(label, 300),
      fileName: cleanText(fileName, 160)
    }))}`;
    const domAudioUrlFromVoice = (label, duration, timeText) => `qmax-dom-audio:${encodeURIComponent(JSON.stringify({
      label: cleanText(label, 300),
      duration: cleanText(duration, 40),
      timeText: cleanText(timeText, 40)
    }))}`;
    const domStickerUrlFromCanvas = (testId, timeText, index) => `qmax-dom-sticker:${encodeURIComponent(JSON.stringify({
      testId: cleanText(testId, 120),
      timeText: cleanText(timeText, 40),
      index
    }))}`;
    const domEmojiUrlFromCanvas = (testId, timeText, index) => `qmax-dom-emoji:${encodeURIComponent(JSON.stringify({
      testId: cleanText(testId, 120),
      timeText: cleanText(timeText, 40),
      index
    }))}`;
    const durationFromText = (value) => cleanText(value, 120).match(/\b\d{1,2}:\d{2}(?::\d{2})?\b/)?.[0] || "";
    const messageTimeTextFromWrapper = (wrapper) => {
      const metaNodes = Array.from(wrapper.querySelectorAll("[class*='meta' i], time"))
        .filter((node) => !node.closest("[class*='attach' i], [class*='audio' i], [class*='voice' i], [class*='duration' i]"));
      for (const node of metaNodes) {
        const text = cleanText(
          node.getAttribute?.("datetime") ||
          node.getAttribute?.("aria-label") ||
          node.getAttribute?.("title") ||
          node.innerText ||
          node.textContent,
          80);
        const match = text.match(/\b\d{1,2}:\d{2}\b/);
        if (match) {
          return match[0];
        }
      }

      const ownText = cleanText(wrapper.innerText || wrapper.textContent, 500);
      const matches = ownText.match(/\b\d{1,2}:\d{2}\b/g) || [];
      return matches.at(-1) || "";
    };
    const safeVoiceFileName = (duration, index) => {
      const suffix = cleanText(duration, 40).replace(/[^0-9]+/g, "-").replace(/^-+|-+$/g, "");
      return `max-voice-${suffix || index + 1}.ogg`;
    };
    const safeStickerFileName = (testId, index) => {
      const suffix = cleanText(testId, 80).replace(/[^a-z0-9_-]+/gi, "-").replace(/^-+|-+$/g, "");
      return `max-sticker-${suffix || index + 1}.png`;
    };
    const safeEmojiFileName = (testId, index) => {
      const suffix = cleanText(testId, 80).replace(/[^a-z0-9_-]+/gi, "-").replace(/^-+|-+$/g, "");
      return `max-emoji-${suffix || index + 1}.png`;
    };
    const fileSizeBytesFromLabel = (label) => {
      const match = cleanText(label, 300).match(/(\d+(?:[.,]\d+)?)\s*(b|kb|mb|gb|\u0431|\u043a\u0431|\u043c\u0431|\u0433\u0431)\b/i);
      if (!match) return null;
      const value = Number(match[1].replace(",", "."));
      if (!Number.isFinite(value) || value < 0) return null;
      const unit = match[2].toLowerCase();
      const factor = unit === "gb" || unit === "\u0433\u0431"
        ? 1024 * 1024 * 1024
        : unit === "mb" || unit === "\u043c\u0431"
          ? 1024 * 1024
          : unit === "kb" || unit === "\u043a\u0431"
            ? 1024
            : 1;
      return Math.round(value * factor);
    };
    const kindFromMedia = (tagName, url, label) => {
      const ext = extensionFromUrl(url);
      const text = `${tagName || ""} ${url || ""} ${label || ""}`.toLowerCase();
      if (ext === "vcf" || /vcard|text\/vcard/i.test(text)) return "Contact";
      if (isStickerUrl(url) || /sticker|\u0441\u0442\u0438\u043a\u0435\u0440/i.test(text)) return "Sticker";
      if (tagName === "video" || /\.(mp4|mov|webm|mkv|m4v|3gp)(\?|#|$)/i.test(url || "")) return "Video";
      if (tagName === "audio" || /\.(ogg|opus|m4a|aac|mp3|wav|flac|oga)(\?|#|$)/i.test(url || "") || /voice|audio|голос|аудио/i.test(text)) return "VoiceNote";
      if (ext === "gif" || /gif/i.test(text)) return "Gif";
      if (tagName === "img" || tagName === "image" || isEmojiUrl(url) || /\.(jpg|jpeg|png|webp|gif|bmp|heic|heif|avif)(\?|#|$)/i.test(url || "")) return "Image";
      return "File";
    };
    const contentTypeFromKind = (kind, url) => {
      const ext = extensionFromUrl(url);
      if (kind === "Gif") return "image/gif";
      if (kind === "Image") return ext ? `image/${ext === "jpg" ? "jpeg" : ext}` : "image/*";
      if (kind === "Video") return ext ? `video/${ext === "mov" ? "quicktime" : ext}` : "video/*";
      if (kind === "VoiceNote") return ext ? `audio/${ext === "m4a" ? "mp4" : ext}` : "audio/*";
      if (kind === "Sticker") return ext ? `image/${ext === "jpg" ? "jpeg" : ext}` : "image/webp";
      if (kind === "Contact") return "text/vcard; charset=utf-8";
      return "application/octet-stream";
    };
    const fileNameFromMedia = (label, kind, url, index) => {
      const labelLines = String(label || "")
        .split(/\n+| {2,}/)
        .map((line) => cleanText(line, 160))
        .filter(Boolean);
      const hasKnownExtension = (value) => /\.(jpg|jpeg|png|webp|gif|bmp|heic|heif|avif|mp4|mov|webm|mkv|m4v|3gp|ogg|opus|m4a|aac|mp3|wav|flac|oga|pdf|docx?|xlsx?|pptx?|zip|rar|7z|txt|rtf|csv|html?|apk|vcf)$/i.test(value);
      const preferredLine = labelLines.find((line) => hasKnownExtension(line) && !isDownloadText(line)) ||
        labelLines.find((line) => !isDownloadText(line) && !/^\d{1,2}:\d{2}$/.test(line) && !/^\d+(?:[.,]\d+)?\s*(?:b|kb|mb|gb|\u0431|\u043a\u0431|\u043c\u0431|\u0433\u0431)$/i.test(line)) ||
        label;
      const clean = cleanText(preferredLine, 120).replace(/[\\/:*?"<>|]+/g, " ").trim();
      const hasExtension = hasKnownExtension(clean);
      const isFallback = /^((photo|image|video|audio|voice|gif)|(\u0444\u043e\u0442\u043e|\u0432\u0438\u0434\u0435\u043e|\u0430\u0443\u0434\u0438\u043e|\u0433\u043e\u043b\u043e\u0441))/i.test(clean) ||
        isDownloadText(clean) ||
        /(\u0431\u0440\u0430\u0443\u0437\u0435\u0440.*\u043d\u0435\s+\u043f\u043e\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u0435\u0442|your browser.*support|not supported|\[object object\])/i.test(clean);
      const embeddedFileName = clean.match(/(?:^|\s)([^\s\\/:*?"<>|]+\.[a-z0-9]{2,8})(?=\s|$)/i)?.[1];
      if (kind === "File" && embeddedFileName) {
        return embeddedFileName.slice(0, 100);
      }
      if (clean && !isFallback && (kind === "File" || hasExtension)) {
        return clean.slice(0, 100);
      }
      const ext = extensionFromUrl(url) || (kind === "Video" ? "mp4" : kind === "VoiceNote" ? "ogg" : kind === "Gif" ? "gif" : kind === "Sticker" ? "webp" : kind === "Contact" ? "vcf" : kind === "Image" ? "jpg" : "bin");
      return `max-${kind.toLowerCase()}-${index + 1}.${ext}`;
    };
    const cssBackgroundUrl = (element) => {
      const image = window.getComputedStyle(element).backgroundImage || "";
      const match = image.match(/url\(["']?(.+?)["']?\)/i);
      return match ? absoluteUrl(match[1]) : null;
    };
    const extractAvatarUrl = (root) => {
      const candidates = Array.from(root.querySelectorAll("img, image, [style*='background' i], [class*='avatar' i], [class*='photo' i]"));
      for (const node of candidates) {
        if (!(node instanceof Element)) continue;
        const rect = node.getBoundingClientRect();
        if (rect.width < 24 || rect.height < 24 || rect.width > 112 || rect.height > 112) continue;
        const source = node.currentSrc ||
          node.src ||
          node.href?.baseVal ||
          node.getAttribute("src") ||
          node.getAttribute("href") ||
          cssBackgroundUrl(node);
        const url = absoluteUrl(source);
        if (url && !/pattern|sprite|emoji|sticker|logo/i.test(url)) {
          return url;
        }
      }
      return null;
    };
    const deliveryStateFromMessage = (wrapper, bubble, isOutgoing) => {
      if (!isOutgoing) return null;
      const statusNodes = Array.from(wrapper.querySelectorAll("[aria-label], [title], [class*='mark' i], [class*='check' i], [class*='status' i], [class*='delivery' i], [class*='read' i], svg"));
      const statusText = statusNodes.map((node) => [
        node.getAttribute?.("aria-label"),
        node.getAttribute?.("title"),
        node.getAttribute?.("data-testid"),
        node.className?.baseVal || node.className,
        node.textContent
      ].filter(Boolean).join(" ")).join(" ").toLowerCase();
      const wrapperText = [
        wrapper.className,
        bubble.className,
        statusText
      ].join(" ").toLowerCase();

      if (/\u043f\u0440\u043e\u0447\u0438\u0442\u0430\u043d|\u043f\u0440\u043e\u0441\u043c\u043e\u0442\u0440|read|seen|viewed/.test(wrapperText)) {
        return "Read";
      }
      if (/\u0434\u043e\u0441\u0442\u0430\u0432|delivered|doneall|done_all|double|checks|check-double/.test(wrapperText)) {
        return "Delivered";
      }

      if (/прочитан|прочитано|просмотр|read|seen|viewed/.test(wrapperText)) {
        return "Read";
      }
      if (/достав|delivered|doneall|done_all|double|checks|check-double/.test(wrapperText)) {
        return "Delivered";
      }
      return "Sent";
    };
    const collectAttachments = (bubble) => {
      const candidates = [];
      const contactRoots = [];
      const contactNodes = Array.from(bubble.querySelectorAll("[class*='contact' i], [data-testid*='contact' i], [aria-label*='contact' i], [class*='phone' i], [data-testid*='phone' i], [href^='tel:']"));
      const bubbleText = cleanText(bubble.innerText || bubble.textContent, 800);
      const bubblePhone = phoneFromText(bubbleText);
      const smallAvatar = Array.from(bubble.querySelectorAll("img, image, [style*='background' i], [class*='avatar' i]"))
        .some((node) => {
          const rect = node.getBoundingClientRect?.();
          if (!rect) return false;
          const ratio = rect.height > 0 ? rect.width / rect.height : 0;
          return rect.width >= 24 && rect.height >= 24 && rect.width <= 112 && rect.height <= 112 && ratio > 0.75 && ratio < 1.35;
        });
      const bubbleLooksLikeContact = /contact|\u043a\u043e\u043d\u0442\u0430\u043a\u0442|\u0442\u0435\u043b\u0435\u0444\u043e\u043d|phone|mobile/i.test(bubbleText) ||
        (smallAvatar && bubblePhone);
      if (bubbleLooksLikeContact) {
        contactRoots.push(bubble);
      }
      for (const node of contactNodes) {
        const root = node.closest("[class*='bubbleContent' i], [class*='message' i], [class*='contact' i], [role='button'], button, a") || node;
        if (!contactRoots.includes(root)) {
          contactRoots.push(root);
        }
      }
      for (const root of contactRoots) {
        const rootText = cleanText(root.innerText || root.textContent || root.getAttribute?.("aria-label"), 800);
        const semantic = [
          root.getAttribute?.("aria-label"),
          root.getAttribute?.("title"),
          root.getAttribute?.("href"),
          root.className?.baseVal || root.className
        ].filter(Boolean).join(" ");
        const phone = phoneFromText(root.getAttribute?.("href")) || phoneFromText(rootText);
        if (!phone && !/contact|\u043a\u043e\u043d\u0442\u0430\u043a\u0442|\u0442\u0435\u043b\u0435\u0444\u043e\u043d|phone|mobile/i.test(`${rootText} ${semantic}`)) {
          continue;
        }
        const lines = String(rootText || "")
          .split(/\n+| {2,}/)
          .map((line) => cleanText(line, 120))
          .filter(Boolean);
        const name = lines.find((line) =>
          !phoneFromText(line) &&
          !isDownloadText(line) &&
          !/^(contact|\u043a\u043e\u043d\u0442\u0430\u043a\u0442|\u0442\u0435\u043b\u0435\u0444\u043e\u043d|phone|mobile)$/i.test(line) &&
          !/^\d{1,2}:\d{2}$/.test(line)
        ) || "\u041a\u043e\u043d\u0442\u0430\u043a\u0442";
        const vcard = `BEGIN:VCARD\nVERSION:3.0\nFN:${vcardEscape(name)}\n${phone ? `TEL;TYPE=CELL:${phone}\n` : ""}END:VCARD\n`;
        candidates.push({
          url: null,
          label: name,
          kind: "Contact",
          fileName: safeContactFileName(name),
          contentType: "text/vcard; charset=utf-8",
          textContent: vcard
        });
      }

      const voiceRoots = Array.from(bubble.querySelectorAll("[class*='attachAudio' i], [class*='voice' i], [class*='audio' i]"));
      for (const root of voiceRoots) {
        if (!(root instanceof HTMLElement)) continue;
        if (contactRoots.some((contactRoot) => contactRoot !== root && contactRoot.contains?.(root))) continue;
        const rootText = cleanText(
          root.innerText ||
          root.textContent ||
          root.getAttribute?.("aria-label") ||
          root.getAttribute?.("title"),
          300);
        const semantic = [
          root.className?.baseVal || root.className,
          root.getAttribute?.("aria-label"),
          root.getAttribute?.("title"),
          rootText
        ].filter(Boolean).join(" ");
        if (!/attachaudio|voice|audio|\u0433\u043e\u043b\u043e\u0441|\u0430\u0443\u0434\u0438\u043e/i.test(semantic)) {
          continue;
        }

        const duration = durationFromText(rootText);
        const wrapper = bubble.closest("[class*='messageWrapper' i]") || bubble;
        const messageTimeText = messageTimeTextFromWrapper(wrapper);
        const label = cleanText(`\u0413\u043e\u043b\u043e\u0441\u043e\u0432\u043e\u0435 \u0441\u043e\u043e\u0431\u0449\u0435\u043d\u0438\u0435 ${duration}`.trim(), 120);
        candidates.push({
          url: domAudioUrlFromVoice(label, duration, messageTimeText),
          label,
          kind: "VoiceNote",
          fileName: safeVoiceFileName(duration, candidates.length),
          contentType: "audio/ogg",
          fileSizeBytes: null
        });
      }

      const emojiSelector = "[data-testid*='emoji' i], [class*='emoji' i], [class*='lottie' i], [class*='emoticon' i], canvas";
      const emojiRoots = [
        ...(bubble.matches?.(emojiSelector) ? [bubble] : []),
        ...Array.from(bubble.querySelectorAll(emojiSelector))
      ];
      const seenEmojiKeys = new Set();
      for (const root of emojiRoots) {
        if (!(root instanceof HTMLElement)) continue;
        if (contactRoots.some((contactRoot) => contactRoot !== root && contactRoot.contains?.(root))) continue;
        if (root.closest?.("[data-testid^='sticker-'], [class*='sticker' i]")) continue;

        const rootText = cleanText(
          root.innerText ||
          root.textContent ||
          root.getAttribute?.("aria-label") ||
          root.getAttribute?.("title"),
          300);
        const semantic = [
          root.getAttribute?.("data-testid"),
          root.getAttribute?.("aria-label"),
          root.getAttribute?.("title"),
          root.className?.baseVal || root.className,
          rootText,
          bubbleText
        ].filter(Boolean).join(" ");
        const hasVisual = root.matches("canvas,svg,img,image") || Boolean(root.querySelector("canvas,svg,img,image"));
        const looksLikeEmoji = /emoji|\u044d\u043c\u043e\u0434\u0437\u0438|lottie|emoticon/i.test(semantic);
        if (!looksLikeEmoji || !hasVisual) {
          continue;
        }

        const directNode = root.matches("img,image,source")
          ? root
          : root.querySelector("img,image,source");
        const directSource = directNode?.currentSrc ||
          directNode?.src ||
          directNode?.href?.baseVal ||
          directNode?.getAttribute?.("src") ||
          directNode?.getAttribute?.("href") ||
          directNode?.getAttribute?.("xlink:href") ||
          srcFromSrcset(directNode?.getAttribute?.("srcset")) ||
          cssBackgroundUrl(root);
        const directUrl = absoluteUrl(directSource);
        if (directUrl && !directUrl.startsWith("blob:")) {
          continue;
        }

        const wrapper = bubble.closest("[class*='messageWrapper' i]") || bubble;
        const messageTimeText = messageTimeTextFromWrapper(wrapper);
        const testId = root.getAttribute("data-testid") ||
          root.querySelector("[data-testid*='emoji' i], [data-testid*='lottie' i]")?.getAttribute("data-testid") ||
          "";
        const rect = root.getBoundingClientRect();
        if (rect.width < 12 || rect.height < 12) {
          continue;
        }
        const emojiKey = testId || `${Math.round(rect.x)}:${Math.round(rect.y)}:${Math.round(rect.width)}:${Math.round(rect.height)}`;
        if (seenEmojiKeys.has(emojiKey)) {
          continue;
        }
        seenEmojiKeys.add(emojiKey);
        const label = cleanText(root.getAttribute("aria-label") || rootText || "\u042d\u043c\u043e\u0434\u0437\u0438", 120);
        candidates.push({
          url: domEmojiUrlFromCanvas(testId, messageTimeText, candidates.length),
          label,
          kind: "Sticker",
          fileName: safeEmojiFileName(testId, candidates.length),
          contentType: "image/png",
          fileSizeBytes: null
        });
      }

      const stickerRoots = [
        ...(bubble.matches?.("[data-testid^='sticker-'], button[class*='sticker' i], [class*='sticker' i]") ? [bubble] : []),
        ...Array.from(bubble.querySelectorAll("[data-testid^='sticker-'], button[class*='sticker' i], [class*='sticker' i]"))
      ];
      const seenStickerKeys = new Set();
      for (const root of stickerRoots) {
        if (!(root instanceof HTMLElement)) continue;
        if (contactRoots.some((contactRoot) => contactRoot !== root && contactRoot.contains?.(root))) continue;
        const semantic = [
          root.getAttribute("data-testid"),
          root.getAttribute("aria-label"),
          root.getAttribute("title"),
          root.className,
          root.innerText || root.textContent
        ].filter(Boolean).join(" ");
        const hasCanvas = root.matches("canvas") || Boolean(root.querySelector("canvas"));
        if (!hasCanvas && !/sticker|\u0441\u0442\u0438\u043a\u0435\u0440/i.test(semantic)) {
          continue;
        }

        const wrapper = bubble.closest("[class*='messageWrapper' i]") || bubble;
        const messageTimeText = messageTimeTextFromWrapper(wrapper);
        const testId = root.getAttribute("data-testid") ||
          root.querySelector("[data-testid^='sticker-']")?.getAttribute("data-testid") ||
          "";
        const rect = root.getBoundingClientRect();
        const stickerKey = testId || `${Math.round(rect.x)}:${Math.round(rect.y)}:${Math.round(rect.width)}:${Math.round(rect.height)}`;
        if (seenStickerKeys.has(stickerKey)) {
          continue;
        }
        seenStickerKeys.add(stickerKey);
        const label = cleanText(root.getAttribute("aria-label") || root.innerText || root.textContent || "\u0421\u0442\u0438\u043a\u0435\u0440", 120);
        candidates.push({
          url: domStickerUrlFromCanvas(testId, messageTimeText, candidates.length),
          label,
          kind: "Sticker",
          fileName: safeStickerFileName(testId, candidates.length),
          contentType: "image/png",
          fileSizeBytes: null
        });
      }

      const fileButtons = Array.from(bubble.querySelectorAll("button,[role='button']"));
      for (const node of fileButtons) {
        if (!(node instanceof HTMLElement)) continue;
        if (contactRoots.some((root) => root !== node && root.contains?.(node))) continue;
        const label = cleanText(
          node.innerText ||
          node.textContent ||
          node.getAttribute("aria-label") ||
          node.getAttribute("title"),
          300);
        const looksLikeFile = /\.[a-z0-9]{2,8}\b/i.test(label) &&
          /download|\u0441\u043a\u0430\u0447\u0430\u0442\u044c|\u0444\u0430\u0439\u043b|\u0434\u043e\u043a\u0443\u043c\u0435\u043d\u0442|\d+(?:[.,]\d+)?\s*(?:b|kb|mb|gb|\u0431|\u043a\u0431|\u043c\u0431|\u0433\u0431)\b/i.test(label);
        if (!looksLikeFile) continue;
        const fileName = fileNameFromMedia(label, "File", "", candidates.length);
        if (!/\.[a-z0-9]{2,8}$/i.test(fileName)) continue;
        candidates.push({
          url: domDownloadUrlFromFile(label, fileName),
          label,
          kind: "File",
          fileName,
          contentType: contentTypeFromKind("File", fileName),
          fileSizeBytes: fileSizeBytesFromLabel(label)
        });
      }

      const mediaSelector = "img, image, picture, video, audio, source, a[href], button, [role='button'], [download], [style*='background' i], [class*='sticker' i], [class*='emoji' i], [class*='media' i], [class*='photo' i], [class*='image' i], [class*='file' i], [class*='document' i], [class*='attachment' i], [class*='download' i]";
      const nodes = [
        ...(bubble.matches?.(mediaSelector) ? [bubble] : []),
        ...Array.from(bubble.querySelectorAll(mediaSelector))
      ];
      for (const node of nodes) {
        if (contactRoots.some((root) => root !== node && root.contains?.(node))) continue;
        const tagName = String(node.tagName || "").toLowerCase();
        const closestLink = node.closest?.("a[href]");
        const nestedLink = node.querySelector?.("a[href]");
        let rawUrl = node.currentSrc ||
          node.src ||
          node.poster ||
          node.href?.baseVal ||
          node.href ||
          node.dataset?.url ||
          node.dataset?.href ||
          node.dataset?.downloadUrl ||
          node.dataset?.fileUrl ||
          node.getAttribute("src") ||
          node.getAttribute("href") ||
          node.getAttribute("xlink:href") ||
          node.getAttribute("data-url") ||
          node.getAttribute("data-href") ||
          node.getAttribute("data-download-url") ||
          node.getAttribute("data-file-url") ||
          node.getAttribute("download-url") ||
          nestedLink?.href ||
          closestLink?.href ||
          srcFromSrcset(node.getAttribute("srcset"));
        if (!rawUrl && tagName === "picture") {
          const source = node.querySelector("source,img");
          rawUrl = source?.currentSrc ||
            source?.src ||
            source?.getAttribute("src") ||
            srcFromSrcset(source?.getAttribute("srcset"));
        }
        let url = absoluteUrl(rawUrl);
        if (!url) {
          url = cssBackgroundUrl(node);
        }
        if (!url) continue;
        const rect = node.getBoundingClientRect?.();
        const importantSmallMedia = isEmojiUrl(url) || isStickerUrl(url);
        if (rect && !importantSmallMedia && (rect.width < 18 || rect.height < 18)) continue;
        if (rect && importantSmallMedia && (rect.width < 8 || rect.height < 8)) continue;
        const labelRoot = node.closest?.("[class*='file' i], [class*='document' i], [class*='attachment' i], [class*='download' i], [role='button'], button, a") || node;
        const label = cleanText(
          labelRoot.getAttribute?.("aria-label") ||
          labelRoot.getAttribute?.("alt") ||
          labelRoot.getAttribute?.("title") ||
          labelRoot.getAttribute?.("download") ||
          labelRoot.innerText ||
          node.getAttribute("aria-label") ||
          node.getAttribute("alt") ||
          node.getAttribute("title") ||
          node.getAttribute("download") ||
          node.textContent,
          160);
        if (/profile|avatar|\u0430\u0432\u0430\u0442\u0430\u0440/i.test(label)) continue;
        const semantic = [
          tagName,
          node.getAttribute?.("role"),
          node.getAttribute?.("aria-label"),
          node.getAttribute?.("title"),
          node.className?.baseVal || node.className,
          label
        ].filter(Boolean).join(" ");
        const mediaTag = tagName === "source" ? String(node.parentElement?.tagName || "").toLowerCase() : tagName;
        const kind = kindFromMedia(mediaTag, url, `${label} ${semantic}`);
        const fileLike = tagName === "a" ||
          tagName === "button" ||
          /file|document|attachment|download|\u0444\u0430\u0439\u043b|\u0434\u043e\u043a\u0443\u043c\u0435\u043d\u0442|\u0441\u043a\u0430\u0447\u0430\u0442\u044c/i.test(semantic);
        if (kind === "File" && !fileLike) continue;
        candidates.push({ url, label, kind });
      }

      const seenUrls = new Set();
      return candidates
        .filter((candidate) => {
          const identity = candidate.url || `${candidate.kind}:${candidate.fileName || candidate.label}:${candidate.textContent || ""}`;
          if (seenUrls.has(identity)) return false;
          seenUrls.add(identity);
          return true;
        })
        .slice(0, 8)
        .map((candidate, index) => ({
          externalId: `${candidate.kind}:${index}:${candidate.url || candidate.fileName || candidate.label}`,
          fileName: candidate.fileName || fileNameFromMedia(candidate.label, candidate.kind, candidate.url, index),
          contentType: candidate.contentType || contentTypeFromKind(candidate.kind, candidate.url),
          fileSizeBytes: candidate.textContent ? new Blob([candidate.textContent]).size : candidate.fileSizeBytes ?? null,
          remoteUrl: candidate.url,
          kind: candidate.kind,
          sortOrder: index,
          textContent: candidate.textContent || null
        }));
    };

    const existingWrappers = Array.from(opened.querySelectorAll("[class*='messageWrapper' i]"))
      .filter(isVisible);
    const standaloneMediaRoots = Array.from(opened.querySelectorAll("img, image, picture, video, canvas, svg, [class*='sticker' i], [class*='emoji' i], [class*='lottie' i]"))
      .filter(isVisible)
      .map((node) => node.closest?.("[class*='messageWrapper' i], [class*='item' i], [class*='bubbleContent' i], [class*='bordersWrapper' i], [class*='attach' i], [class*='sticker' i], [class*='emoji' i]") || node)
      .filter((node) => node instanceof HTMLElement)
      .filter((node) => {
        if (existingWrappers.some((wrapper) => wrapper === node || wrapper.contains(node) || node.contains(wrapper))) {
          return false;
        }
        if (node.closest?.("aside, header, [class*='header' i], [class*='composer' i], [class*='toolbar' i]")) {
          return false;
        }
        const rect = node.getBoundingClientRect();
        return rect.width >= 24 &&
          rect.height >= 24 &&
          rect.left > openedRect.left + 8 &&
          rect.top > openedRect.top + 48 &&
          rect.bottom < window.innerHeight - 24;
      });
    const wrappers = [...existingWrappers, ...standaloneMediaRoots]
      .filter((wrapper, index, all) => all.findIndex((other) => other === wrapper || other.contains?.(wrapper)) === index)
      .sort((a, b) => a.getBoundingClientRect().top - b.getBoundingClientRect().top);
    const messages = [];
    const seen = new Set();
    for (const wrapper of wrappers) {
      const bubble = wrapper.querySelector("[class*='bubbleContent' i]") || wrapper;
      const item = wrapper.closest("[class*='item' i]");
      const dateLabel = cleanText(item?.querySelector("[class*='capsule' i]")?.innerText, 80);
      const timeText = messageTimeTextFromWrapper(wrapper);
      const textParts = Array.from(bubble.querySelectorAll("span[class*='text' i], div[class*='text' i]"))
        .filter((node) => !node.closest("[class*='meta' i]"))
        .filter((node) => !node.closest("[class*='mark' i]"))
        .filter((node) => !node.closest("[class*='link' i]"))
        .filter((node) => !node.closest("button[class*='author' i]"))
        .filter((node) => !String(node.className || "").toLowerCase().includes("placeholder"))
        .map((node) => cleanText(node.innerText || node.textContent, 2000))
        .filter((text) => text && !/^\d{1,2}:\d{2}$/.test(text));
      let text = Array.from(new Set(textParts)).join("\n").trim();
      if (!text) {
        const media = bubble.querySelector("[aria-label]");
        const mediaLabel = cleanText(media?.getAttribute("aria-label"), 120);
        if (mediaLabel && !/profile/i.test(mediaLabel)) {
          text = mediaLabel;
        }
      }
      const attachments = collectAttachments(bubble);
      if (isGenericMediaText(text)) {
        if (attachments.length > 0) {
          text = "";
        } else {
          continue;
        }
      }
      if ((!text || /^\d{1,2}:\d{2}$/.test(text)) && attachments.length === 0) {
        continue;
      }
      if (/^\d{1,2}:\d{2}$/.test(text)) {
        text = "";
      }

      const rect = bubble.getBoundingClientRect();
      const classText = [
        wrapper.className,
        bubble.className,
        wrapper.querySelector("[class*='bordersWrapper' i]")?.className
      ].join(" ");
      const isOutgoing = /--right|outgoing|own|self/i.test(classText) ||
        rect.left > openedRect.left + openedRect.width * 0.45;
      const deliveryState = deliveryStateFromMessage(wrapper, bubble, isOutgoing);
      const attachmentKey = attachments.map((attachment) => attachment.externalId).join(",");
      const key = `${text}|${attachmentKey}|${timeText}|${dateLabel}|${isOutgoing}|${Math.round(rect.y)}`;
      if (seen.has(key)) {
        continue;
      }
      seen.add(key);
      messages.push({
        text,
        timeText,
        dateLabel,
        isOutgoing,
        deliveryState,
        sentAt: parseDate(dateLabel, timeText),
        rect: {
          x: Math.round(rect.x),
          y: Math.round(rect.y),
          width: Math.round(rect.width),
          height: Math.round(rect.height)
        },
        attachments
      });
    }

    return {
      url: location.href,
      title,
      avatarUrl: extractAvatarUrl(header || opened),
      messages
    };
  }, requestedTitle);

  const externalId = requestedExternalChatId || makeDomChatExternalId(raw.title, "", null, 0);
  const now = new Date().toISOString();
  const externalIdOrdinals = new Map();
  const sentAtOffsets = new Map();
  const orderedSentAt = (sentAt) => {
    const base = sentAt || now;
    const offset = sentAtOffsets.get(base) || 0;
    sentAtOffsets.set(base, offset + 1);
    if (offset === 0) {
      return base;
    }

    const date = new Date(base);
    if (Number.isNaN(date.getTime())) {
      return base;
    }

    date.setMilliseconds(date.getMilliseconds() + offset);
    return date.toISOString();
  };
  return {
    externalId,
    title: raw.title || requestedTitle || "MAX chat",
    avatarUrl: raw.avatarUrl || null,
    updatedAt: now,
    messages: raw.messages.map((message) => {
      const baseExternalId = stableHash(externalId, message.text, message.timeText, message.sentAt, message.isOutgoing);
      const ordinal = externalIdOrdinals.get(baseExternalId) || 0;
      externalIdOrdinals.set(baseExternalId, ordinal + 1);
      const messageExternalId = ordinal === 0 ? `domhist:${baseExternalId}` : `domhist:${baseExternalId}:${ordinal}`;
      return {
        externalId: messageExternalId,
        senderExternalId: message.isOutgoing ? "self" : externalId,
        senderName: message.isOutgoing ? null : (raw.title || requestedTitle || null),
        isOutgoing: message.isOutgoing,
        text: message.text,
        sentAt: orderedSentAt(message.sentAt),
        deliveryState: message.deliveryState || null,
        rect: message.rect || null,
        attachments: (message.attachments || []).map((attachment, index) => {
          const remoteUrl = attachDomMediaChatContext(attachment.remoteUrl, externalId, raw.url);
          return {
            ...attachment,
            remoteUrl,
            externalId: `dommedia:${stableHash(externalId, messageExternalId, remoteUrl || attachment.externalId || "", String(index))}`
          };
        })
      };
    })
  };
}

async function extractOpenChatPresence(p) {
  return await p.evaluate(() => {
    const cleanText = (value, limit = 500) => String(value || "")
      .replace(/\u00a0/g, " ")
      .replace(/\s+/g, " ")
      .trim()
      .slice(0, limit);
    const opened = document.querySelector("[class*='openedChat' i]") ||
      document.querySelector("main") ||
      document.body;
    const header = opened.querySelector("[class*='header' i]") || opened;
    const candidates = Array.from(header.querySelectorAll("[class*='subtitle' i], [class*='status' i], [class*='typing' i], span, div"))
      .map((node) => cleanText(node.innerText || node.textContent, 160))
      .filter(Boolean);
    const bodyCandidates = Array.from(opened.querySelectorAll("[class*='typing' i], [aria-label*='typing' i], [aria-label*='\u043f\u0435\u0447\u0430\u0442' i]"))
      .map((node) => cleanText(
        node.innerText ||
        node.textContent ||
        node.getAttribute("aria-label") ||
        node.getAttribute("title"),
        160))
      .filter(Boolean);
    const all = [...candidates, ...bodyCandidates];
    const statusText = all.find((text) =>
      /(\u043f\u0435\u0447\u0430\u0442|\u043d\u0430\u0431\u0438\u0440\u0430|\u0437\u0430\u043f\u0438\u0441\u044b\u0432\u0430|typing|recording)/i.test(text)
    ) || null;

    return {
      isTyping: Boolean(statusText),
      statusText,
      updatedAt: new Date().toISOString()
    };
  });
}

async function clearSidebarSearch(p) {
  await p.evaluate(() => {
    const isVisible = (element) => {
      if (!(element instanceof HTMLElement)) return false;
      const style = window.getComputedStyle(element);
      const rect = element.getBoundingClientRect();
      return style.visibility !== "hidden" &&
        style.display !== "none" &&
        rect.width > 0 &&
        rect.height > 0 &&
        rect.bottom >= 0 &&
        rect.right >= 0 &&
        rect.top <= window.innerHeight &&
        rect.left <= window.innerWidth;
    };
    const setNativeValue = (element, value) => {
      const descriptor = Object.getOwnPropertyDescriptor(element.constructor.prototype, "value");
      if (descriptor?.set) {
        descriptor.set.call(element, value);
      } else {
        element.value = value;
      }
    };
    const inputs = Array.from(document.querySelectorAll("input, textarea, [contenteditable='true'], [role='textbox']"))
      .filter(isVisible)
      .filter((element) => {
        const rect = element.getBoundingClientRect();
        const text = [
          element.getAttribute("aria-label"),
          element.getAttribute("placeholder"),
          element.getAttribute("title"),
          element.getAttribute("data-testid"),
          element.className,
          element.id,
          element.getAttribute("name"),
          element.value
        ].join(" ").toLowerCase();
        const isSearchLike = /search|\u043f\u043e\u0438\u0441\u043a/.test(text);
        const isTopSidebarInput = rect.left < window.innerWidth * 0.42 &&
          rect.top < window.innerHeight * 0.34;
        return rect.left < window.innerWidth * 0.42 &&
          rect.top < window.innerHeight * 0.32 &&
          (isSearchLike || isTopSidebarInput);
      });

    for (const input of inputs) {
      if ("value" in input) {
        if (!input.value) continue;
        setNativeValue(input, "");
      } else {
        if (!input.textContent) continue;
        input.textContent = "";
      }
      input.dispatchEvent(new InputEvent("input", { bubbles: true, inputType: "deleteContentBackward", data: null }));
      input.dispatchEvent(new Event("change", { bubbles: true }));
    }
  }).catch(() => {});
  await p.waitForTimeout(150);
}

async function resetSidebarListToTop(p) {
  await p.evaluate(() => {
    const aside = document.querySelector("aside");
    if (!aside) return;

    const candidates = [
      aside,
      ...Array.from(aside.querySelectorAll("[class*='scroll' i], [class*='contentOverflow' i], [class*='cropped' i], [class*='list' i]"))
    ].filter((element) => element instanceof HTMLElement);

    for (const element of candidates) {
      if (element.scrollHeight <= element.clientHeight + 2) continue;
      element.scrollTop = 0;
      element.dispatchEvent(new Event("scroll", { bubbles: true }));
    }
  }).catch(() => {});
  await p.waitForTimeout(250);
}

async function focusSidebarSearch(p) {
  const focused = await p.evaluate(async () => {
    const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
    const isVisible = (element) => {
      if (!(element instanceof HTMLElement)) return false;
      const style = window.getComputedStyle(element);
      const rect = element.getBoundingClientRect();
      return style.visibility !== "hidden" &&
        style.display !== "none" &&
        rect.width > 0 &&
        rect.height > 0 &&
        rect.bottom >= 0 &&
        rect.right >= 0 &&
        rect.top <= window.innerHeight &&
        rect.left <= window.innerWidth;
    };
    const textMeta = (element) => [
      element.getAttribute("aria-label"),
      element.getAttribute("placeholder"),
      element.getAttribute("title"),
      element.getAttribute("data-testid"),
      element.className,
      element.id,
      element.getAttribute("name"),
      element.innerText,
      element.textContent
    ].join(" ").toLowerCase();
    const setNativeValue = (element, value) => {
      const descriptor = Object.getOwnPropertyDescriptor(element.constructor.prototype, "value");
      if (descriptor?.set) {
        descriptor.set.call(element, value);
      } else {
        element.value = value;
      }
    };
    const findInput = () => {
      const aside = document.querySelector("aside") || document.body;
      return Array.from(aside.querySelectorAll("input, textarea, [contenteditable='true'], [role='textbox']"))
        .filter(isVisible)
        .filter((element) => {
          const rect = element.getBoundingClientRect();
          const text = textMeta(element);
          const isSearchLike = /search|\u043f\u043e\u0438\u0441\u043a/.test(text);
          const isTopSidebarInput = rect.left < window.innerWidth * 0.42 &&
            rect.top < window.innerHeight * 0.34;
          return isSearchLike || isTopSidebarInput;
        })
        .sort((a, b) => {
          const aSearch = /search|\u043f\u043e\u0438\u0441\u043a/.test(textMeta(a)) ? 0 : 1;
          const bSearch = /search|\u043f\u043e\u0438\u0441\u043a/.test(textMeta(b)) ? 0 : 1;
          if (aSearch !== bSearch) return aSearch - bSearch;
          return a.getBoundingClientRect().top - b.getBoundingClientRect().top;
        })[0] || null;
    };
    let input = findInput();
    if (!input) {
      const aside = document.querySelector("aside") || document.body;
      const button = Array.from(aside.querySelectorAll("button, [role='button']"))
        .filter(isVisible)
        .find((element) => /search|\u043f\u043e\u0438\u0441\u043a/.test(textMeta(element)));
      if (button) {
        button.click();
        await delay(200);
        input = findInput();
      }
    }
    if (!input) return false;

    input.focus();
    if ("value" in input) {
      setNativeValue(input, "");
    } else {
      input.textContent = "";
    }
    input.dispatchEvent(new InputEvent("input", { bubbles: true, inputType: "deleteContentBackward", data: null }));
    input.dispatchEvent(new Event("change", { bubbles: true }));
    return true;
  }).catch(() => false);

  if (focused) {
    await p.waitForTimeout(100);
  }
  return Boolean(focused);
}

async function searchSidebarChat(p, title) {
  await clearSidebarSearch(p);
  const focused = await focusSidebarSearch(p);
  if (!focused) {
    return false;
  }

  await p.keyboard.insertText(title);
  await p.waitForTimeout(700);
  return true;
}

async function waitForMaxChatListReady(p, timeoutMs = 15000) {
  const deadline = Date.now() + timeoutMs;
  while (Date.now() < deadline) {
    const ready = await p.evaluate(() => {
      const isVisible = (element) => {
        if (!(element instanceof HTMLElement)) return false;
        const style = window.getComputedStyle(element);
        const rect = element.getBoundingClientRect();
        return style.visibility !== "hidden" &&
          style.display !== "none" &&
          rect.width > 20 &&
          rect.height > 12 &&
          rect.bottom >= 0 &&
          rect.right >= 0 &&
          rect.top <= window.innerHeight &&
          rect.left <= window.innerWidth;
      };

      return Array.from(document.querySelectorAll("aside button.cell, aside button[class*='cell' i], aside button.item, aside button[class*='item' i]"))
        .some(isVisible);
    }).catch(() => false);

    if (ready) {
      return true;
    }

    await p.waitForTimeout(250);
  }

  return false;
}

async function readVisibleSidebarChatRows(p) {
  return await p.evaluate(() => {
    const cleanText = (value, limit = 500) => String(value || "")
      .replace(/\u00a0/g, " ")
      .replace(/\s+/g, " ")
      .trim()
      .slice(0, limit);
    const linesFrom = (value) => String(value || "")
      .split(/\n+/)
      .map((line) => cleanText(line, 180))
      .filter(Boolean);
    const isVisible = (element) => {
      if (!(element instanceof HTMLElement)) return false;
      const style = window.getComputedStyle(element);
      const rect = element.getBoundingClientRect();
      return style.visibility !== "hidden" &&
        style.display !== "none" &&
        rect.width > 20 &&
        rect.height > 12 &&
        rect.bottom >= 0 &&
        rect.right >= 0 &&
        rect.top <= window.innerHeight &&
        rect.left <= window.innerWidth;
    };
    const absoluteUrl = (value) => {
      const raw = String(value || "").trim();
      if (!raw || raw.startsWith("data:")) return null;
      try {
        return new URL(raw, location.href).href;
      } catch {
        return null;
      }
    };
    const cssBackgroundUrl = (element) => {
      const image = window.getComputedStyle(element).backgroundImage || "";
      const match = image.match(/url\(["']?(.+?)["']?\)/i);
      return match ? absoluteUrl(match[1]) : null;
    };
    const extractAvatarUrl = (element) => {
      const rowRect = element.getBoundingClientRect();
      const candidates = Array.from(element.querySelectorAll("img, image, [style*='background' i], [class*='avatar' i], [class*='photo' i]"));
      for (const node of candidates) {
        if (!(node instanceof Element)) continue;
        const rect = node.getBoundingClientRect();
        if (rect.width < 24 || rect.height < 24 || rect.width > 96 || rect.height > 96) continue;
        if (rect.left > rowRect.left + rowRect.width * 0.45) continue;
        const source = node.currentSrc ||
          node.src ||
          node.href?.baseVal ||
          node.getAttribute("src") ||
          node.getAttribute("href") ||
          cssBackgroundUrl(node);
        const url = absoluteUrl(source);
        if (url && !/pattern|sprite|emoji|sticker|logo/i.test(url)) {
          return url;
        }
      }
      return null;
    };
    const extractTitle = (element, lines) => {
      const titleNode = element.querySelector("h3, [class*='title' i] [class*='name' i], [class*='name' i]");
      const title = cleanText(titleNode?.innerText || titleNode?.textContent, 160);
      return title || lines.find((line) => line && !/^\d{1,3}$/.test(line)) || "";
    };
    const extractPreview = (element, title, lines) => {
      const timeText = cleanText(element.querySelector("[class*='time' i], [class*='meta' i]")?.innerText, 80);
      const ignored = new Set([
        title,
        timeText,
        cleanText(element.querySelector("[class*='badge' i], [class*='indicator' i], [class*='counter' i]")?.innerText, 80)
      ].filter(Boolean));
      return lines.find((line) => line !== title && !ignored.has(line) && !/^\d{1,3}$/.test(line)) || null;
    };
    const extractTimeText = (element, lines) => {
      const direct = cleanText(element.querySelector("[class*='time' i], [class*='meta' i]")?.innerText, 80);
      if (direct) return direct;
      return lines.find((line) =>
        /^\d{1,2}:\d{2}$/.test(line) ||
        /^(\u0432\u0447\u0435\u0440\u0430|\u0441\u0435\u0433\u043e\u0434\u043d\u044f)$/i.test(line) ||
        /^\d{1,2}\s+[^\s.]+\.?$/i.test(line) ||
        /^(mon|tue|wed|thu|fri|sat|sun|\u043f\u043d|\u0432\u0442|\u0441\u0440|\u0447\u0442|\u043f\u0442|\u0441\u0431|\u0432\u0441)$/i.test(line)
      ) || null;
    };
    const textOf = (element) => String(
      element.innerText ||
      element.textContent ||
      element.getAttribute("aria-label") ||
      element.getAttribute("title") ||
      ""
    ).trim().toLowerCase();
    const isMenuButton = (element) => {
      const text = textOf(element);
      const cls = String(element.className || "").toLowerCase();
      return text.includes("\u0435\u0449") ||
        text.includes("more") ||
        text.includes("menu") ||
        text.includes("actions") ||
        text.includes("\u0434\u0435\u0439\u0441\u0442\u0432") ||
        cls.includes("more") ||
        cls.includes("menu") ||
        text === "\u22ef" ||
        text === "\u2026";
    };
    const menuPoint = (element) => {
      const buttons = Array.from(element.querySelectorAll("button,[role='button']"))
        .filter((button) => button instanceof HTMLElement && isVisible(button));
      const match = buttons.find(isMenuButton) ||
        buttons.sort((a, b) => b.getBoundingClientRect().right - a.getBoundingClientRect().right)[0] ||
        null;
      if (!match) return null;
      const rect = match.getBoundingClientRect();
      return {
        x: Math.round(rect.left + rect.width / 2),
        y: Math.round(rect.top + rect.height / 2)
      };
    };
    const selector = [
      "aside [role='presentation']",
      "aside [class*='wrapper' i]",
      "aside button.cell",
      "aside button[class*='cell' i]",
      "aside button.item",
      "aside button[class*='item' i]",
      "aside [role='presentation'] button",
      "aside [class*='wrapper' i] button",
      "aside [data-testid*='chat' i]",
      "aside [data-testid*='dialog' i]",
      "aside [data-testid*='conversation' i]"
    ].join(",");

    return Array.from(document.querySelectorAll(selector))
      .filter(isVisible)
      .map((element) => {
        const rect = element.getBoundingClientRect();
        const text = cleanText(element.innerText || element.textContent, 500);
        const lines = linesFrom(element.innerText || element.textContent);
        const title = extractTitle(element, lines);
        const avatarUrl = extractAvatarUrl(element);
        const menu = menuPoint(element);
        return {
          title,
          text,
          preview: extractPreview(element, title, lines),
          timeText: extractTimeText(element, lines),
          avatarUrl,
          left: Math.round(rect.left),
          right: Math.round(rect.right),
          x: Math.round(rect.left + Math.min(rect.width - 8, Math.max(8, rect.width * 0.50))),
          y: Math.round(rect.top + rect.height / 2),
          menuX: menu?.x || null,
          menuY: menu?.y || null,
          top: Math.round(rect.top)
        };
      })
      .filter((row) => row.title && row.text)
      .filter((row, index, rows) =>
        rows.findIndex((candidate) => candidate.title === row.title && Math.abs(candidate.top - row.top) <= 2) === index)
      .sort((a, b) => a.top - b.top);
  }).catch(() => []);
}

async function scrollSidebarForward(p) {
  return await p.evaluate(() => {
    const scrollRoot = Array.from(document.querySelectorAll("aside, aside *"))
      .filter((element) => element instanceof HTMLElement)
      .filter((element) => {
        const style = window.getComputedStyle(element);
        const rect = element.getBoundingClientRect();
        return style.display !== "none" &&
          style.visibility !== "hidden" &&
          rect.width > 180 &&
          rect.height > 160 &&
          element.scrollHeight > element.clientHeight + 80;
      })
      .sort((a, b) => (b.scrollHeight - b.clientHeight) - (a.scrollHeight - a.clientHeight))[0] || null;

    if (!scrollRoot) return false;
    const bottom = Math.max(0, scrollRoot.scrollHeight - scrollRoot.clientHeight);
    if (scrollRoot.scrollTop >= bottom - 4) return false;
    const nextTop = Math.min(bottom, scrollRoot.scrollTop + Math.max(220, Math.floor(scrollRoot.clientHeight * 0.85)));
    if (nextTop === scrollRoot.scrollTop) return false;
    scrollRoot.scrollTop = nextTop;
    scrollRoot.dispatchEvent(new Event("scroll", { bubbles: true }));
    return true;
  }).catch(() => false);
}

function normalizeDomTitle(value) {
  return cleanComparableText(value, 160).toLowerCase();
}

function rowMatchesDomChatDescriptor(row, descriptor) {
  const wanted = normalizeDomTitle(descriptor?.title);
  const current = normalizeDomTitle(row?.title);
  return Boolean(wanted && current && (
    current === wanted ||
    current.includes(wanted) ||
    wanted.includes(current)
  ));
}

function chooseDomChatRow(rows, descriptor) {
  const matches = rows.filter((row) => rowMatchesDomChatDescriptor(row, descriptor));
  if (matches.length === 0) {
    return null;
  }

  const expectedAvatar = normalizeDomChatFingerprint(descriptor?.avatarUrl);
  if (expectedAvatar) {
    const strict = matches.filter((row) => normalizeDomChatFingerprint(row.avatarUrl) === expectedAvatar);
    if (strict.length > 0) {
      return strict[0];
    }
  }

  return matches.length === 1 ? matches[0] : null;
}

async function clickMatchingSidebarRowAndReadUrl(p, descriptor) {
  const row = chooseDomChatRow(await readVisibleSidebarChatRows(p), descriptor);
  if (!row) {
    return null;
  }

  await p.mouse.click(row.x, row.y);
  await waitForDomChatReady(p, descriptor.title, 5000, false);
  await p.waitForTimeout(150);
  return await getCurrentChatUrl(p);
}

async function openSidebarChatMenu(p, externalChatId, chatUrl, expectedLabels) {
  const descriptor = decodeDomChatDescriptor(externalChatId);
  if (!descriptor?.title) {
    return false;
  }

  const targetUrl = normalizeMaxChatUrl(chatUrl);
  const sameChatUrl = (value) => {
    const current = normalizeMaxChatUrl(value);
    return Boolean(targetUrl && current && current === targetUrl);
  };

  const chooseVisibleRow = async () => {
    const rows = await readVisibleSidebarChatRows(p);
    const matches = rows.filter((row) => rowMatchesDomChatDescriptor(row, descriptor));
    if (matches.length === 0) {
      return { row: null, rows };
    }

    if (targetUrl) {
      for (const candidate of matches) {
        await p.mouse.click(candidate.x, candidate.y);
        await waitForDomChatReady(p, candidate.title, 5000, false);
        await p.waitForTimeout(150);
        if (sameChatUrl(await getCurrentChatUrl(p))) {
          return { row: candidate, rows };
        }
      }

      return { row: null, rows };
    }

    return { row: chooseDomChatRow(rows, descriptor), rows };
  };

  const clickVisibleRowMenu = async () => {
    const { row, rows } = await chooseVisibleRow();
    if (!row) {
      return false;
    }

    const x = row.menuX || (row.right ? row.right - 32 : row.x);
    const y = row.menuY || row.y;
    console.info(`[chat/menu] matched sidebar row title=${row.title} menu=(${x},${y}) avatar=${row.avatarUrl || ""} visibleRows=${rows.length}`);
    await p.mouse.move(x, y);
    await p.waitForTimeout(150);
    await p.mouse.click(x, y);
    await p.waitForTimeout(600);
    const opened = await hasMenuActionSurface(p, expectedLabels);
    if (!opened) {
      const menuTexts = await readVisibleActionTexts(p);
      console.warn(`[chat/menu] expected action labels not found; labels=${expectedLabels.join("|")} visible=${menuTexts.slice(0, 20).join("|")}`);
      await p.keyboard.press("Escape").catch(() => {});
      await p.waitForTimeout(150);
    }
    return opened;
  };

  await clearSidebarSearch(p);
  await resetSidebarListToTop(p);
  await waitForMaxChatListReady(p, 15000);
  if (await clickVisibleRowMenu()) {
    return true;
  }

  const searched = await searchSidebarChat(p, descriptor.title);
  if (searched && await clickVisibleRowMenu()) {
    return true;
  }

  await clearSidebarSearch(p);
  await resetSidebarListToTop(p);
  await waitForMaxChatListReady(p, 15000);

  for (let pageIndex = 0; pageIndex < 220; pageIndex++) {
    if (await clickVisibleRowMenu()) {
      return true;
    }

    const moved = await scrollSidebarForward(p);
    if (!moved) break;
    await p.waitForTimeout(250);
  }

  await clearSidebarSearch(p);
  return false;
}

async function resolveDomChatUrl(p, externalChatId) {
  const descriptor = decodeDomChatDescriptor(externalChatId);
  if (!descriptor?.title) {
    return null;
  }

  const embeddedUrl = normalizeMaxChatUrl(descriptor.href);
  if (embeddedUrl) {
    return embeddedUrl;
  }

  const opened = await ensureDomChatOpen(p, externalChatId, 5000, false, null);
  if (opened) {
    const currentUrl = await getCurrentChatUrl(p);
    if (currentUrl) {
      return currentUrl;
    }
  }

  await clearSidebarSearch(p);
  await resetSidebarListToTop(p);
  await waitForMaxChatListReady(p, 15000);

  let chatUrl = await clickMatchingSidebarRowAndReadUrl(p, descriptor);
  if (chatUrl) {
    await clearSidebarSearch(p);
    return chatUrl;
  }

  const searched = await searchSidebarChat(p, descriptor.title);
  if (searched) {
    chatUrl = await clickMatchingSidebarRowAndReadUrl(p, descriptor);
    if (chatUrl) {
      await clearSidebarSearch(p);
      return chatUrl;
    }
  }

  await clearSidebarSearch(p);
  await resetSidebarListToTop(p);
  await waitForMaxChatListReady(p, 15000);

  let stagnantPages = 0;
  for (let pageIndex = 0; pageIndex < 220; pageIndex++) {
    chatUrl = await clickMatchingSidebarRowAndReadUrl(p, descriptor);
    if (chatUrl) {
      await clearSidebarSearch(p);
      return chatUrl;
    }

    const moved = await scrollSidebarForward(p);
    if (!moved) break;
    await p.waitForTimeout(250);

    const rows = await readVisibleSidebarChatRows(p);
    stagnantPages = rows.length === 0 ? stagnantPages + 1 : 0;
    if (stagnantPages >= 4) break;
  }

  await clearSidebarSearch(p);
  return null;
}

async function collectSidebarChatUrls(p, limit = 600) {
  await clearSidebarSearch(p);
  await resetSidebarListToTop(p);
  await waitForMaxChatListReady(p, 15000);

  const results = [];
  const seen = new Set();
  let stagnantPages = 0;

  for (let pageIndex = 0; pageIndex < 220 && results.length < limit; pageIndex++) {
    const rows = await readVisibleSidebarChatRows(p);
    let addedOnPage = 0;

    for (const row of rows) {
      if (results.length >= limit) break;
      const key = `${row.title}|${row.avatarUrl || ""}|${row.text}`;
      if (seen.has(key)) continue;
      seen.add(key);
      addedOnPage++;

      await p.mouse.click(row.x, row.y);
      const ready = await waitForDomChatReady(p, row.title, 5000, false);
      await p.waitForTimeout(150);
      const chatUrl = await getCurrentChatUrl(p);
      results.push({
        externalId: makeDomChatExternalId(row.title, row.text, "", results.length, row.avatarUrl),
        title: row.title,
        preview: row.preview,
        timeText: row.timeText,
        avatarUrl: row.avatarUrl || null,
        chatUrl,
        ready,
        rowText: row.text
      });
    }

    const moved = await scrollSidebarForward(p);
    if (!moved) break;
    await p.waitForTimeout(250);

    stagnantPages = addedOnPage === 0 ? stagnantPages + 1 : 0;
    if (stagnantPages >= 4) break;
  }

  return results;
}

async function openDomChatByUrl(p, chatUrl) {
  const targetUrl = normalizeMaxChatUrl(chatUrl);
  if (!targetUrl) {
    return false;
  }

  const currentUrl = normalizeMaxChatUrl(p.url());
  if (currentUrl === targetUrl) {
    return true;
  }

  try {
    await p.goto(targetUrl, { waitUntil: "domcontentloaded", timeout: 30000 });
    await p.waitForTimeout(900);
    return true;
  } catch {
    return false;
  }
}

async function scrollOpenChatToLatest(p) {
  for (let attempt = 0; attempt < 2; attempt++) {
    await p.evaluate(() => {
      const root = document.querySelector("[class*='openedChat' i]") ||
        document.querySelector("main") ||
        document.body;
      if (!(root instanceof HTMLElement)) return;

      const rootRect = root.getBoundingClientRect();
      const candidates = [
        root,
        ...Array.from(root.querySelectorAll("[class*='scroll' i], [class*='contentOverflow' i], [class*='cropped' i], [class*='messages' i], [class*='messageList' i], [class*='list' i]"))
      ].filter((element) => {
        if (!(element instanceof HTMLElement)) return false;
        const rect = element.getBoundingClientRect();
        return rect.width > 120 &&
          rect.height > 120 &&
          rect.right >= rootRect.left &&
          rect.left <= rootRect.right &&
          element.scrollHeight > element.clientHeight + 2;
      });

      for (const element of candidates) {
        element.scrollTop = element.scrollHeight;
        element.dispatchEvent(new Event("scroll", { bubbles: true }));
      }
    }).catch(() => {});
    await p.waitForTimeout(250);
  }
}

async function openDomChatByExternalId(p, externalChatId, options = {}) {
  const descriptor = decodeDomChatDescriptor(externalChatId);
  const title = descriptor?.title || externalChatId;
  if (!title) {
    return false;
  }

  if (!options.preserveSidebarSearch) {
    await clearSidebarSearch(p);
    await resetSidebarListToTop(p);
    await waitForMaxChatListReady(p, 15000);
  }

  const point = await p.evaluate(async (requested) => {
    const cleanText = (value) => String(value || "")
      .replace(/\u00a0/g, " ")
      .replace(/\s+/g, " ")
      .trim();
    const absoluteUrl = (value) => {
      const raw = String(value || "").trim();
      if (!raw || raw.startsWith("data:")) return "";
      try {
        return new URL(raw, location.href).href;
      } catch {
        return raw;
      }
    };
    const fingerprintUrl = (value) => {
      const raw = absoluteUrl(value);
      if (!raw) return "";
      try {
        const url = new URL(raw, location.href);
        const mediaKey = url.searchParams.get("r");
        if (mediaKey) return `r:${mediaKey}`;
        ["fn", "size", "width", "height"].forEach((key) => url.searchParams.delete(key));
        return url.href;
      } catch {
        return raw;
      }
    };
    const cssBackgroundUrl = (element) => {
      const image = window.getComputedStyle(element).backgroundImage || "";
      const match = image.match(/url\(["']?(.+?)["']?\)/i);
      return match ? absoluteUrl(match[1]) : "";
    };
    const extractAvatarUrl = (element) => {
      const rowRect = element.getBoundingClientRect();
      const candidates = Array.from(element.querySelectorAll("img, image, [style*='background' i], [class*='avatar' i], [class*='photo' i]"));
      for (const node of candidates) {
        if (!(node instanceof Element)) continue;
        const rect = node.getBoundingClientRect();
        if (rect.width < 24 || rect.height < 24 || rect.width > 96 || rect.height > 96) continue;
        if (rect.left > rowRect.left + rowRect.width * 0.45) continue;
        const source = node.currentSrc ||
          node.src ||
          node.href?.baseVal ||
          node.getAttribute("src") ||
          node.getAttribute("href") ||
          cssBackgroundUrl(node);
        const url = absoluteUrl(source);
        if (url && !/pattern|sprite|emoji|sticker|logo/i.test(url)) {
          return url;
        }
      }
      return "";
    };
    const normalize = (value) => cleanText(value).toLowerCase();
    const wanted = normalize(requested?.title);
    const expectedAvatar = fingerprintUrl(requested?.avatarUrl);
    const expectedHref = fingerprintUrl(requested?.href);
    if (!wanted) {
      return false;
    }

    const opened = document.querySelector("[class*='openedChat' i]") ||
      document.querySelector("main") ||
      document.body;
    const header = opened.querySelector("[class*='header' i]");
    const headerTitle = normalize(
      header?.querySelector("h1,h2,h3,[class*='title' i],[class*='name' i]")?.innerText ||
      header?.querySelector("button[aria-label]")?.innerText);
    const selectedTitle = normalize(document.querySelector("aside button[class*='selected' i] h3")?.innerText);
    const hasVisibleMessages = Array.from(document.querySelectorAll("[class*='messageWrapper' i]"))
      .some((node) => {
        const rect = node.getBoundingClientRect?.();
        return rect && rect.width > 40 && rect.height > 20 && rect.right > window.innerWidth * 0.35;
      });
    const currentTitles = [selectedTitle, headerTitle].filter(Boolean);
    if (!expectedAvatar && !expectedHref &&
      hasVisibleMessages &&
      currentTitles.some((current) => current === wanted || current.includes(wanted) || wanted.includes(current))) {
      return { opened: true };
    }

    const findMatch = () => {
      const chatSelector = [
        "aside button.cell",
        "aside button[class*='cell' i]",
        "aside [role='presentation'] button",
        "aside [class*='wrapper' i] button",
        "aside [data-testid*='chat' i]",
        "aside [data-testid*='dialog' i]",
        "aside [data-testid*='conversation' i]",
        "aside a[href*='chat' i]",
        "aside a[href*='dialog' i]"
      ].join(",");
      const rows = Array.from(document.querySelectorAll(chatSelector));
      const candidates = rows.map((button) => {
        const titleNode = button.querySelector("h3, [class*='title' i], [class*='name' i]");
        const title = normalize(titleNode?.innerText || titleNode?.textContent);
        const text = normalize(button.innerText || button.textContent);
        const titleMatches = title === wanted ||
          title.includes(wanted) ||
          wanted.includes(title) ||
          text.startsWith(wanted);
        if (!titleMatches) {
          return null;
        }

        const avatar = fingerprintUrl(extractAvatarUrl(button));
        const href = fingerprintUrl(button.getAttribute("href") || button.closest("a")?.getAttribute("href"));
        let score = title === wanted ? 8 : 4;
        if (expectedAvatar && avatar === expectedAvatar) score += 20;
        if (expectedHref && href === expectedHref) score += 20;
        return { button, avatar, href, score };
      }).filter(Boolean);

      const strict = candidates
        .filter((candidate) => !expectedAvatar || candidate.avatar === expectedAvatar)
        .filter((candidate) => !expectedHref || candidate.href === expectedHref)
        .sort((a, b) => b.score - a.score);
      return strict[0] || (candidates.length === 1 ? candidates[0] : null);
    };

    const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
    let match = findMatch();
    if (!match) {
      const scrollRoot = Array.from(document.querySelectorAll("aside, aside *"))
        .filter((element) => element instanceof HTMLElement)
        .filter((element) => {
          const style = window.getComputedStyle(element);
          const rect = element.getBoundingClientRect();
          return style.display !== "none" &&
            style.visibility !== "hidden" &&
            rect.width > 180 &&
            rect.height > 160 &&
            element.scrollHeight > element.clientHeight + 80;
        })
        .sort((a, b) => (b.scrollHeight - b.clientHeight) - (a.scrollHeight - a.clientHeight))[0] || null;

      if (scrollRoot) {
        const maxTop = () => Math.max(0, scrollRoot.scrollHeight - scrollRoot.clientHeight);
        scrollRoot.scrollTop = 0;
        scrollRoot.dispatchEvent(new Event("scroll", { bubbles: true }));
        await delay(100);

        let previousTop = -1;
        for (let page = 0; page < 100 && !match; page++) {
          match = findMatch();
          if (match) break;
          const bottom = maxTop();
          if (scrollRoot.scrollTop >= bottom - 4) break;
          const nextTop = Math.min(bottom, scrollRoot.scrollTop + Math.max(220, Math.floor(scrollRoot.clientHeight * 0.8)));
          if (nextTop === previousTop || nextTop === scrollRoot.scrollTop) break;
          previousTop = scrollRoot.scrollTop;
          scrollRoot.scrollTop = nextTop;
          scrollRoot.dispatchEvent(new Event("scroll", { bubbles: true }));
          await delay(100);
        }
      }
    }

    if (!match) {
      return null;
    }

    match.button.scrollIntoView({ block: "center", inline: "nearest" });
    const rect = match.button.getBoundingClientRect();
    return {
      opened: false,
      x: Math.round(rect.left + Math.min(rect.width - 8, Math.max(8, rect.width * 0.50))),
      y: Math.round(rect.top + rect.height / 2)
    };
  }, {
    title,
    avatarUrl: descriptor?.avatarUrl || "",
    href: descriptor?.href || ""
  }).catch(() => false);

  if (!point) {
    return false;
  }

  if (point.opened) {
    return true;
  }

  await p.mouse.click(point.x, point.y);
  return true;
}

async function ensureDomChatOpen(p, externalChatId, waitMs = 600, requireComposer = false, chatUrl = null) {
  const descriptor = decodeDomChatDescriptor(externalChatId);
  const title = descriptor?.title || externalChatId;
  if (!title) {
    return true;
  }

  const directUrl = normalizeMaxChatUrl(chatUrl) || normalizeMaxChatUrl(descriptor?.href);
  for (let attempt = 0; attempt < 2; attempt++) {
    if (directUrl) {
      const openedByUrl = await openDomChatByUrl(p, directUrl);
      if (openedByUrl) {
        const readyByUrl = await waitForDomChatReady(
          p,
          title,
          Math.max(waitMs, requireComposer ? 8000 : 2500),
          requireComposer);
        if (readyByUrl) {
          await clearSidebarSearch(p);
          return true;
        }
      }
    }

    let opened = await openDomChatByExternalId(p, externalChatId);
    if (!opened) {
      const searched = await searchSidebarChat(p, title);
      if (searched) {
        opened = await openDomChatByExternalId(p, externalChatId, { preserveSidebarSearch: true });
      }
    }
    if (!opened) {
      await clearSidebarSearch(p);
      return false;
    }

    const ready = await waitForDomChatReady(
      p,
      title,
      Math.max(waitMs, requireComposer ? 8000 : 2500),
      requireComposer);
    if (ready) {
      await clearSidebarSearch(p);
      return true;
    }

    await clearSidebarSearch(p);
  }

  return false;
}

async function waitForDomChatReady(p, title, timeoutMs = 5000, requireComposer = false) {
  const deadline = Date.now() + timeoutMs;
  while (Date.now() < deadline) {
    const state = await p.evaluate(({ requestedTitle, needsComposer }) => {
      const cleanText = (value) => String(value || "")
        .replace(/\u00a0/g, " ")
        .replace(/\s+/g, " ")
        .trim();
      const normalize = (value) => cleanText(value).toLowerCase();
      const wanted = normalize(requestedTitle);
      const isVisible = (element) => {
        if (!(element instanceof HTMLElement)) return false;
        const style = window.getComputedStyle(element);
        const rect = element.getBoundingClientRect();
        return style.visibility !== "hidden" &&
          style.display !== "none" &&
          rect.width > 0 &&
          rect.height > 0 &&
          rect.bottom >= 0 &&
          rect.right >= 0 &&
          rect.top <= window.innerHeight &&
          rect.left <= window.innerWidth;
      };
      const normalizeClassName = (value) => typeof value === "string" ? value : String(value?.baseVal || "");
      const opened = document.querySelector("[class*='openedChat' i]") ||
        document.querySelector("main") ||
        document.body;
      const rightPaneLeft = window.innerWidth * 0.32;
      const headerCandidates = Array.from(opened.querySelectorAll("[class*='header' i], header"))
        .filter((node) => isVisible(node))
        .filter((node) => node.getBoundingClientRect().left > rightPaneLeft);
      const header = headerCandidates[0] || null;
      const headerTitle = cleanText(
        header?.querySelector("h1,h2,h3,[class*='title' i],[class*='name' i]")?.innerText ||
        header?.querySelector("button[aria-label]")?.innerText ||
        header?.innerText,
        160);
      const selectedTitle = cleanText(document.querySelector("aside button[class*='selected' i] h3")?.innerText, 160);
      const composerSelectors = [
        "[data-testid='composer'] [role='textbox']",
        "[data-testid='composer'] [contenteditable='true']",
        "[class*='composer' i] [role='textbox']",
        "[class*='composer' i] [contenteditable='true']",
        "[class*='composer' i] [class*='contenteditable' i]",
        "[role='textbox'][class*='contenteditable' i]",
        "textarea"
      ];
      const hasComposer = composerSelectors
        .flatMap((selector) => Array.from(document.querySelectorAll(selector)))
        .some((node) => {
          if (!isVisible(node)) return false;
          const rect = node.getBoundingClientRect();
          const text = normalize([
            node.getAttribute("aria-label"),
            node.getAttribute("placeholder"),
            node.getAttribute("title"),
            node.getAttribute("data-testid"),
            normalizeClassName(node.className),
            node.id,
            node.getAttribute("name")
          ].join(" "));
          const searchLike = /search|\u043f\u043e\u0438\u0441\u043a/.test(text) ||
            (rect.left < window.innerWidth * 0.42 && rect.top < window.innerHeight * 0.32);
          return !searchLike &&
            rect.left > rightPaneLeft &&
            rect.top > window.innerHeight * 0.45;
        });
      const current = normalize(headerTitle || (hasComposer ? selectedTitle : ""));
      const titleMatches = !wanted ||
        (current && (current === wanted || current.includes(wanted) || wanted.includes(current)));
      const ready = Boolean(titleMatches && header && (!needsComposer || hasComposer));
      return { ready, headerTitle, selectedTitle, hasHeader: Boolean(header), hasComposer };
    }, { requestedTitle: title, needsComposer: requireComposer }).catch(() => null);

    if (state?.ready) {
      return true;
    }

    await p.waitForTimeout(250);
  }

  return false;
}

async function sendTextAndConfirm(p, externalChatId, text) {
  const wanted = cleanComparableText(text, 1000);
  if (!wanted) {
    return null;
  }

  const initialOutgoingMessages = await getOutgoingMessages(p, externalChatId);
  const initialOutgoingIds = new Set(initialOutgoingMessages.map((message) => message.externalId).filter(Boolean));
  const initialMatches = initialOutgoingMessages
    .filter((message) => messageTextMatches(message.text, wanted))
    .length;
  const attempts = [
    { name: "send button", action: () => clickSendButton(p) },
    { name: "composer fallback button", action: () => clickComposerRightmostButton(p) },
    { name: "Enter", action: async () => { await p.keyboard.press("Enter"); return true; } },
    { name: "Control+Enter", action: async () => { await p.keyboard.press("Control+Enter"); return true; } }
  ];

  for (const attempt of attempts) {
    if (!(await fillComposerText(p, text, true))) {
      console.warn(`[send/text] composer fill failed; chat=${externalChatId || "current"} textLength=${String(text || "").length}`);
      return null;
    }

    const composerState = await readComposerState(p);
    if (!composerStateMatchesText(composerState, text)) {
      console.warn(`[send/text] composer mismatch after fill; attempt=${attempt.name} composerLength=${composerState?.text?.length ?? -1} richCount=${composerState?.richContentCount ?? -1} wantedLength=${wanted.length}`);
      continue;
    }

    const triggered = await attempt.action().catch(() => false);
    if (!triggered) {
      console.warn(`[send/text] send trigger was not found; attempt=${attempt.name}`);
      continue;
    }

    await scrollOpenChatToBottom(p);
    const externalId = await findSentOutgoingExternalId(
      p,
      externalChatId,
      text,
      initialMatches,
      initialOutgoingIds,
      10000);
    if (externalId) {
      console.info(`[send/text] confirmed outgoing message; attempt=${attempt.name} externalId=${externalId}`);
      return externalId;
    }

    const currentComposerState = await readComposerState(p);
    if (composerStateIsEmpty(currentComposerState)) {
      console.warn(`[send/text] MAX cleared composer but no outgoing message appeared; attempt=${attempt.name}`);
      return null;
    }
  }

  return null;
}

async function sendAttachmentAndConfirm(p, externalChatId, path, caption) {
  const initialOutgoingMessages = await getOutgoingMessages(p, externalChatId);
  const initialOutgoingIds = new Set(initialOutgoingMessages.map((message) => message.externalId).filter(Boolean));
  const wantedCaption = cleanComparableText(caption, 1000);
  const initialMatches = wantedCaption
    ? initialOutgoingMessages.filter((message) => messageTextMatches(message.text, wantedCaption)).length
    : 0;

  console.info(`[send/attachment] starting upload; chat=${externalChatId || "current"} captionLength=${String(caption || "").trim().length} path=${path}`);
  const triggered = await uploadAttachmentFile(p, path, caption);
  if (!triggered) {
    console.warn(`[send/attachment] upload/send trigger failed; chat=${externalChatId || "current"} path=${path}`);
    return null;
  }

  await scrollOpenChatToBottom(p);
  const externalId = await findSentOutgoingExternalId(
    p,
    externalChatId,
    caption || "",
    initialMatches,
    initialOutgoingIds,
    20000);
  if (externalId) {
    console.info(`[send/attachment] confirmed outgoing attachment; externalId=${externalId}`);
    return externalId;
  }

  console.warn(`[send/attachment] MAX did not expose a new outgoing attachment; chat=${externalChatId || "current"} path=${path}`);
  return null;
}

async function fillComposerText(p, text, clearFirst) {
  if (clearFirst && !(await clearComposerInput(p))) {
    console.warn("[send/text] composer did not report empty after clear; continuing with input fallback");
  }

  if (await fillComposerViaClipboard(p, text, false)) {
    return true;
  }

  if (clearFirst) {
    await clearComposerInput(p);
  }
  if (await fillComposerViaKeyboard(p, text, false)) {
    return true;
  }

  if (clearFirst) {
    await clearComposerInput(p);
  }
  if (await insertComposerTextViaDom(p, text, false)) {
    await p.waitForTimeout(300);
    if (composerStateMatchesText(await readComposerState(p), text)) {
      return true;
    }
  }

  if (clearFirst && await fillComposerViaLocator(p, text)) {
    return true;
  }

  for (let attempt = 0; attempt < 2; attempt++) {
    if (!(await focusComposer(p))) {
      break;
    }

    if (clearFirst) {
      await p.keyboard.press(process.platform === "darwin" ? "Meta+A" : "Control+A");
      await p.keyboard.press("Backspace");
    }
    await p.keyboard.insertText(text);
    await p.waitForTimeout(300);

    const state = await readComposerState(p);
    if (composerStateMatchesText(state, text)) {
      return true;
    }
  }

  const selectors = [
    "[data-testid='composer'] [role='textbox']",
    "[data-testid='composer'] [contenteditable='true']",
    "[class*='composer' i] [role='textbox']",
    "[class*='composer' i] [contenteditable='true']",
    "[class*='composer' i] [class*='contenteditable' i]"
  ];

  for (const selector of selectors) {
    try {
      const composer = p.locator(selector).last();
      if ((await composer.count()) === 0) {
        continue;
      }

      await composer.click({ timeout: 3000 });
      if (clearFirst) {
        await p.keyboard.press(process.platform === "darwin" ? "Meta+A" : "Control+A");
        await p.keyboard.press("Backspace");
      }
      await p.keyboard.insertText(text);
      await p.waitForTimeout(250);
      const state = await readComposerState(p);
      if (composerStateMatchesText(state, text)) {
        return true;
      }
    } catch {
      // Try the next composer shape.
    }
  }

  return false;
}

async function clearComposerInput(p) {
  if (!(await focusComposer(p))) {
    return false;
  }

  for (let attempt = 0; attempt < 2; attempt++) {
    await p.keyboard.press(process.platform === "darwin" ? "Meta+A" : "Control+A");
    await p.keyboard.press("Backspace");
    await p.waitForTimeout(120);
    if (composerStateIsEmpty(await readComposerState(p))) {
      return true;
    }
  }

  await insertComposerTextViaDom(p, "", true);
  await p.waitForTimeout(150);
  return composerStateIsEmpty(await readComposerState(p));
}

async function fillComposerViaClipboard(p, text, clearFirst) {
  if (!(await focusComposer(p))) {
    return false;
  }

  if (clearFirst) {
    await p.keyboard.press(process.platform === "darwin" ? "Meta+A" : "Control+A");
    await p.keyboard.press("Backspace");
  }

  const wroteClipboard = await p.evaluate(async (value) => {
    try {
      await navigator.clipboard.writeText(value);
      return true;
    } catch {
      return false;
    }
  }, text).catch(() => false);

  if (wroteClipboard) {
    await p.keyboard.press(process.platform === "darwin" ? "Meta+V" : "Control+V");
    await p.waitForTimeout(300);
    if (composerStateMatchesText(await readComposerState(p), text)) {
      return true;
    }
  }

  return false;
}

async function fillComposerViaKeyboard(p, text, clearFirst) {
  if (!(await focusComposer(p))) {
    return false;
  }

  if (clearFirst) {
    await p.keyboard.press(process.platform === "darwin" ? "Meta+A" : "Control+A");
    await p.keyboard.press("Backspace");
    await p.waitForTimeout(80);
  }

  await p.keyboard.insertText(text);
  await p.waitForTimeout(300);
  return composerStateMatchesText(await readComposerState(p), text);
}

async function insertComposerTextViaDom(p, text, clearFirst = false) {
  return await p.evaluate(({ value, clear }) => {
    const cleanText = (textValue) => String(textValue || "")
      .replace(/\u00a0/g, " ")
      .replace(/[\u200b\u200c\u200d\ufeff]/g, "")
      .replace(/\s+/g, " ")
      .trim();
    const isVisible = (element) => {
      if (!(element instanceof HTMLElement)) return false;
      const style = window.getComputedStyle(element);
      const rect = element.getBoundingClientRect();
      return style.visibility !== "hidden" &&
        style.display !== "none" &&
        rect.width > 0 &&
        rect.height > 0 &&
        rect.bottom >= 0 &&
        rect.right >= 0 &&
        rect.top <= window.innerHeight &&
        rect.left <= window.innerWidth;
    };
    const isSearchLike = (element, rect) => {
      const textValue = cleanText([
        element.getAttribute("aria-label"),
        element.getAttribute("placeholder"),
        element.getAttribute("title"),
        element.getAttribute("data-testid"),
        element.className,
        element.id,
        element.getAttribute("name")
      ].join(" ")).toLowerCase();
      return /search|\u043f\u043e\u0438\u0441\u043a/.test(textValue) ||
        (rect.left < window.innerWidth * 0.42 && rect.top < window.innerHeight * 0.32);
    };
    const selectors = [
      "[data-testid='composer'] [role='textbox']",
      "[data-testid='composer'] [contenteditable='true']",
      "[class*='composer' i] [role='textbox']",
      "[class*='composer' i] [contenteditable='true']",
      "[class*='composer' i] [class*='contenteditable' i]",
      "[role='textbox'][class*='contenteditable' i]",
      "[role='textbox']",
      "[contenteditable='true']",
      "textarea"
    ];
    const candidates = selectors
      .flatMap((selector) => Array.from(document.querySelectorAll(selector)))
      .filter((element) => isVisible(element))
      .filter((element) => {
        const rect = element.getBoundingClientRect();
        return !isSearchLike(element, rect) &&
          rect.left > window.innerWidth * 0.32 &&
          rect.top > window.innerHeight * 0.50;
      })
      .sort((a, b) => {
        const ar = a.getBoundingClientRect();
        const br = b.getBoundingClientRect();
        return br.bottom - ar.bottom || (br.width * br.height) - (ar.width * ar.height);
      });
    const composer = candidates[0];
    if (!(composer instanceof HTMLElement)) {
      return false;
    }

    composer.focus({ preventScroll: true });
    if (clear) {
      if ("value" in composer) {
        composer.value = "";
      } else {
        composer.replaceChildren();
      }
      composer.dispatchEvent(new InputEvent("input", { bubbles: true, inputType: "deleteContentBackward", data: null }));
    }

    if (!value) {
      composer.dispatchEvent(new Event("change", { bubbles: true }));
      return true;
    }

    const beforeInput = new InputEvent("beforeinput", {
      bubbles: true,
      cancelable: true,
      inputType: "insertText",
      data: value
    });
    composer.dispatchEvent(beforeInput);
    if ("value" in composer) {
      composer.value = `${composer.value || ""}${value}`;
    } else if (!document.execCommand("insertText", false, value)) {
      composer.textContent = `${composer.textContent || ""}${value}`;
    }
    composer.dispatchEvent(new InputEvent("input", { bubbles: true, inputType: "insertText", data: value }));
    composer.dispatchEvent(new Event("change", { bubbles: true }));
    return true;
  }, { value: text, clear: clearFirst }).catch(() => false);
}

async function fillComposerViaLocator(p, text) {
  const selectors = [
    "[data-testid='composer'] [role='textbox']",
    "[data-testid='composer'] [contenteditable='true']",
    "[class*='composer' i] [role='textbox']",
    "[class*='composer' i] [contenteditable='true']",
    "[class*='composer' i] [class*='contenteditable' i]",
    "[role='textbox'][class*='contenteditable' i]"
  ];

  for (const selector of selectors) {
    try {
      const composer = p.locator(selector).last();
      if ((await composer.count()) === 0) {
        continue;
      }

      await composer.scrollIntoViewIfNeeded({ timeout: 2000 }).catch(() => {});
      await composer.click({ timeout: 3000 });
      await composer.fill("", { timeout: 3000 });
      await composer.fill(text, { timeout: 3000 });
      await p.waitForTimeout(200);
      if (composerStateMatchesText(await readComposerState(p), text)) {
        return true;
      }
    } catch {
      // Try the next composer shape.
    }
  }

  return false;
}

async function focusComposer(p) {
  const point = await p.evaluate(() => {
    const cleanText = (value) => String(value || "")
      .replace(/\u00a0/g, " ")
      .replace(/\s+/g, " ")
      .trim()
      .toLowerCase();
    const isVisible = (element) => {
      if (!(element instanceof HTMLElement)) return false;
      const style = window.getComputedStyle(element);
      const rect = element.getBoundingClientRect();
      return style.visibility !== "hidden" &&
        style.display !== "none" &&
        rect.width > 0 &&
        rect.height > 0 &&
        rect.bottom >= 0 &&
        rect.right >= 0 &&
        rect.top <= window.innerHeight &&
        rect.left <= window.innerWidth;
    };
    const isSearchLike = (element, rect) => {
      const text = cleanText([
        element.getAttribute("aria-label"),
        element.getAttribute("placeholder"),
        element.getAttribute("title"),
        element.getAttribute("data-testid"),
        element.className,
        element.id,
        element.getAttribute("name")
      ].join(" "));
      return /search|\u043f\u043e\u0438\u0441\u043a/.test(text) ||
        (rect.left < window.innerWidth * 0.42 && rect.top < window.innerHeight * 0.32);
    };
    const selectors = [
      "[data-testid='composer'] [role='textbox']",
      "[data-testid='composer'] [contenteditable='true']",
      "[class*='composer' i] [role='textbox']",
      "[class*='composer' i] [contenteditable='true']",
      "[class*='composer' i] [class*='contenteditable' i]",
      "[role='textbox'][class*='contenteditable' i]",
      "[contenteditable='true']",
      "textarea"
    ];
    const candidates = selectors
      .flatMap((selector) => Array.from(document.querySelectorAll(selector)))
      .filter(isVisible)
      .filter((element) => {
        const rect = element.getBoundingClientRect();
        return !isSearchLike(element, rect) &&
          rect.left > window.innerWidth * 0.32 &&
          rect.top > window.innerHeight * 0.50;
      })
      .map((element) => {
        const rect = element.getBoundingClientRect();
        return {
          element,
          x: Math.round(rect.left + rect.width / 2),
          y: Math.round(rect.top + rect.height / 2),
          bottom: Math.round(rect.bottom),
          area: Math.round(rect.width * rect.height)
        };
      })
      .sort((a, b) => b.bottom - a.bottom || b.area - a.area);
    const candidate = candidates[0];
    if (candidate?.element instanceof HTMLElement) {
      candidate.element.scrollIntoView({ block: "center", inline: "nearest" });
      candidate.element.focus({ preventScroll: true });
      const rect = candidate.element.getBoundingClientRect();
      return {
        x: Math.round(rect.left + rect.width / 2),
        y: Math.round(rect.top + rect.height / 2)
      };
    }

    return {
      x: Math.round(window.innerWidth * 0.55),
      y: Math.round(window.innerHeight - 40)
    };
  }).catch(() => null);

  if (!point) {
    return false;
  }

  await p.mouse.click(point.x, point.y);
  await p.waitForTimeout(150);
  return true;
}

async function waitForComposerToClear(p, timeoutMs = 4000) {
  const deadline = Date.now() + timeoutMs;
  while (Date.now() < deadline) {
    if (composerStateIsEmpty(await readComposerState(p))) {
      return true;
    }

    await p.waitForTimeout(250);
  }

  return false;
}

async function readComposerText(p) {
  const state = await readComposerState(p);
  return state?.text ?? null;
}

async function readComposerState(p) {
  return await p.evaluate(() => {
    const cleanText = (value) => String(value || "")
      .replace(/\u00a0/g, " ")
      .replace(/[\u200b\u200c\u200d\ufeff]/g, "")
      .replace(/\s+/g, " ")
      .trim();
    const isVisible = (element) => {
      if (!(element instanceof Element)) return false;
      const style = window.getComputedStyle(element);
      const rect = element.getBoundingClientRect();
      return style.visibility !== "hidden" &&
        style.display !== "none" &&
        rect.width > 0 &&
        rect.height > 0 &&
        rect.bottom >= 0 &&
        rect.right >= 0 &&
        rect.top <= window.innerHeight &&
        rect.left <= window.innerWidth;
    };
    const isSearchLike = (element, rect) => {
      const text = cleanText([
        element.getAttribute("aria-label"),
        element.getAttribute("placeholder"),
        element.getAttribute("title"),
        element.getAttribute("data-testid"),
        element.className,
        element.id,
        element.getAttribute("name")
      ].join(" ")).toLowerCase();
      return /search|\u043f\u043e\u0438\u0441\u043a/.test(text) ||
        (rect.left < window.innerWidth * 0.42 && rect.top < window.innerHeight * 0.32);
    };
    const selectors = [
      "[data-testid='composer'] [role='textbox']",
      "[data-testid='composer'] [contenteditable='true']",
      "[class*='composer' i] [role='textbox']",
      "[class*='composer' i] [contenteditable='true']",
      "[class*='composer' i] [class*='contenteditable' i]",
      "[role='textbox']",
      "[contenteditable='true']",
      "textarea"
    ];
    const candidates = selectors
      .flatMap((selector) => Array.from(document.querySelectorAll(selector)))
      .filter((element) => element instanceof HTMLElement && isVisible(element))
      .filter((element) => {
        const rect = element.getBoundingClientRect();
        return !isSearchLike(element, rect) &&
          rect.left > window.innerWidth * 0.32 &&
          rect.top > window.innerHeight * 0.50;
      })
      .sort((a, b) => {
        const ar = a.getBoundingClientRect();
        const br = b.getBoundingClientRect();
        return br.bottom - ar.bottom || (br.width * br.height) - (ar.width * ar.height);
      });
    const composer = candidates[0];
    if (!composer) {
      return null;
    }

    const value = "value" in composer ? composer.value : "";
    const text = cleanText(value || composer.innerText || composer.textContent);
    const richContentCount = Array.from(composer.querySelectorAll([
      "img",
      "canvas",
      "svg",
      "[class*='emoji' i]",
      "[class*='sticker' i]",
      "[class*='lottie' i]",
      "[class*='emoticon' i]",
      "[data-testid*='emoji' i]",
      "[data-testid*='sticker' i]",
      "[data-testid*='lottie' i]"
    ].join(",")))
      .filter((element) => isVisible(element))
      .filter((element) => !/placeholder/i.test(String(element.className || "")))
      .length;
    return { text, richContentCount };
  }).catch(() => null);
}

function composerStateIsEmpty(state) {
  return Boolean(state && !state.text && (state.richContentCount || 0) === 0);
}

function composerStateMatchesText(state, wantedText) {
  if (!state) {
    return false;
  }

  if (messageTextMatches(state.text, wantedText)) {
    return true;
  }

  if ((state.richContentCount || 0) === 0 || !containsEmojiSyntax(wantedText)) {
    return false;
  }

  if (isEmojiOnlyText(wantedText)) {
    return true;
  }

  const composerText = stripEmojiForComparison(state.text);
  const wanted = stripEmojiForComparison(wantedText);
  return Boolean(composerText && wanted && (
    composerText === wanted ||
    composerText.endsWith(wanted) ||
    wanted.endsWith(composerText)
  ));
}

function containsEmojiSyntax(value) {
  return /[\p{Extended_Pictographic}\u200d\ufe0f\ufe0e]/u.test(String(value || ""));
}

function isEmojiOnlyText(value) {
  const text = cleanComparableText(value, 1000);
  return Boolean(text && containsEmojiSyntax(text) && !stripEmojiForComparison(text));
}

function stripEmojiForComparison(value) {
  return cleanComparableText(value, 1000)
    .replace(/[\p{Extended_Pictographic}\u200d\ufe0f\ufe0e]/gu, "")
    .replace(/\s+/g, " ")
    .trim()
    .toLowerCase();
}

function messageTextMatches(value, wantedText) {
  const text = cleanComparableText(value, 1000).toLowerCase();
  const wanted = cleanComparableText(wantedText, 1000).toLowerCase();
  return Boolean(text && wanted && (
    text === wanted ||
    text.endsWith(`: ${wanted}`) ||
    text.endsWith(wanted) ||
    text.includes(wanted)
  ));
}

async function getOutgoingMessages(p, externalChatId) {
  const history = await extractOpenChatHistory(p, externalChatId).catch(() => null);
  return (history?.messages || []).filter((message) => message.isOutgoing);
}

async function getOutgoingTextMatches(p, externalChatId, text) {
  const wanted = cleanComparableText(text, 1000);
  if (!wanted) {
    return [];
  }

  return (await getOutgoingMessages(p, externalChatId))
    .filter((message) => messageTextMatches(message.text, wanted));
}

async function countOutgoingTextMatches(p, externalChatId, text) {
  return (await getOutgoingTextMatches(p, externalChatId, text)).length;
}

async function findSentOutgoingExternalId(
  p,
  externalChatId,
  text,
  previousMatchCount = 0,
  initialOutgoingIds = new Set(),
  timeoutMs = 15000) {
  const knownIds = initialOutgoingIds instanceof Set
    ? initialOutgoingIds
    : new Set(Array.from(initialOutgoingIds || []).filter(Boolean));
  const deadline = Date.now() + timeoutMs;
  while (Date.now() < deadline) {
    await p.waitForTimeout(500);
    const outgoingMessages = await getOutgoingMessages(p, externalChatId);
    const matches = outgoingMessages.filter((message) => messageTextMatches(message.text, text));
    if (matches.length > previousMatchCount) {
      const latest = matches[matches.length - 1];
      if (latest?.externalId) {
        return latest.externalId;
      }
    }

    const newOutgoing = outgoingMessages.filter((message) =>
      message.externalId &&
      !knownIds.has(message.externalId));
    if (newOutgoing.length > 0) {
      return newOutgoing[newOutgoing.length - 1].externalId;
    }
  }

  return null;
}

async function uploadAttachmentFile(p, path, caption) {
  try {
    const fileStat = await fs.stat(path);
    if (!fileStat.isFile()) {
      console.warn(`[send/attachment] file is not a regular file; path=${path}`);
      return false;
    }
  } catch {
    console.warn(`[send/attachment] file does not exist or is not readable; path=${path}`);
    return false;
  }

  let attached = await attachFileViaUploadButton(p, path);

  if (!attached) {
    try {
      const input = p.locator("input[type='file']").last();
      if ((await input.count()) > 0) {
        await input.setInputFiles(path);
        attached = true;
      }
    } catch {
      attached = false;
    }
  }

  if (!attached) {
    console.warn(`[send/attachment] no usable upload control was found; path=${path}`);
    return false;
  }

  await p.waitForTimeout(2000);
  const previewReady = await waitForAttachmentPreview(p, 10000);
  console.info(`[send/attachment] file selected; previewReady=${previewReady} url=${p.url()}`);
  if (!previewReady) {
    return false;
  }

  if (caption.trim()) {
    await fillComposerText(p, caption.trim(), false);
    await p.waitForTimeout(300);
  }

  const sent = await clickSendButton(p) || await clickComposerRightmostButton(p);
  if (!sent) {
    console.warn(`[send/attachment] send button was not found after file selection; path=${path}`);
    return false;
  }

  await p.waitForTimeout(1500);
  return true;
}

async function attachFileViaUploadButton(p, filePath) {
  const point = await p.evaluate(() => {
    const isVisible = (element) => {
      if (!(element instanceof HTMLElement)) return false;
      const style = window.getComputedStyle(element);
      const rect = element.getBoundingClientRect();
      return style.visibility !== "hidden" &&
        style.display !== "none" &&
        rect.width > 0 &&
        rect.height > 0 &&
        rect.bottom >= 0 &&
        rect.right >= 0 &&
        rect.top <= window.innerHeight &&
        rect.left <= window.innerWidth;
    };

    const buttons = Array.from(document.querySelectorAll("button, [role='button']"))
      .filter((button) => !button.disabled && isVisible(button));
    const candidates = buttons
      .map((button) => {
        const rect = button.getBoundingClientRect();
        const text = [
          button.getAttribute("aria-label"),
          button.getAttribute("title"),
          button.getAttribute("data-testid"),
          button.getAttribute("name"),
          button.className,
          button.innerText,
          button.textContent
        ].join(" ").trim().toLowerCase();
        const explicit = /attach|attachment|upload|file|paperclip|\u043f\u0440\u0438\u043a\u0440\u0435\u043f|\u0437\u0430\u0433\u0440\u0443\u0437|\u0444\u0430\u0439\u043b|\u0441\u043a\u0440\u0435\u043f/.test(text);
        const composerLike = rect.left > window.innerWidth * 0.32 && rect.top > window.innerHeight * 0.55;
        return { button, rect, explicit, composerLike };
      })
      .filter((candidate) => candidate.explicit || candidate.composerLike)
      .sort((a, b) =>
        Number(b.explicit) - Number(a.explicit) ||
        Number(b.composerLike) - Number(a.composerLike) ||
        a.rect.left - b.rect.left ||
        b.rect.top - a.rect.top);
    const button = candidates[0]?.button || null;
    if (!button) {
      return null;
    }

    const rect = button.getBoundingClientRect();
    return {
      x: Math.round(rect.left + rect.width / 2),
      y: Math.round(rect.top + rect.height / 2)
    };
  }).catch(() => null);

  if (!point) {
    return false;
  }

  try {
    const fileChooserPromise = p.waitForEvent("filechooser", { timeout: 800 }).catch(() => null);
    await p.mouse.click(point.x, point.y);
    const fileChooser = await fileChooserPromise;
    if (fileChooser) {
      await fileChooser.setFiles(filePath);
      return true;
    }

    return await attachFileViaMenuItem(p, filePath);
  } catch {
    return false;
  }
}

async function attachFileViaMenuItem(p, filePath) {
  const preferMedia = /\.(jpe?g|png|webp|gif|heic|mp4|mov|webm)$/i.test(filePath);
  const deadline = Date.now() + 3500;
  let point = null;
  while (Date.now() < deadline && !point) {
    point = await p.evaluate(({ preferMedia }) => {
      const isVisible = (element) => {
        if (!(element instanceof HTMLElement)) return false;
        const style = window.getComputedStyle(element);
        const rect = element.getBoundingClientRect();
        return style.visibility !== "hidden" &&
          style.display !== "none" &&
          rect.width > 0 &&
          rect.height > 0 &&
          rect.bottom >= 0 &&
          rect.right >= 0 &&
          rect.top <= window.innerHeight &&
          rect.left <= window.innerWidth;
      };
      const cleanText = (value) => String(value || "")
        .replace(/\s+/g, " ")
        .trim()
        .toLowerCase();
      const menuItems = Array.from(document.querySelectorAll("[role='menuitem'], button[class*='actionsMenuItem' i]"))
        .filter((element) => !element.disabled && isVisible(element))
        .filter((element) => !element.closest?.("[data-testid='composer'], [class*='composer' i]"))
        .map((element) => {
          const rect = element.getBoundingClientRect();
          const text = cleanText([
            element.getAttribute("aria-label"),
            element.getAttribute("title"),
            element.getAttribute("data-testid"),
            element.className,
            element.innerText,
            element.textContent
          ].join(" "));
          const media = /photo|video|media|\u0444\u043e\u0442\u043e|\u0432\u0438\u0434\u0435\u043e/.test(text);
          const file = /file|\u0444\u0430\u0439\u043b/.test(text);
          return { element, rect, text, media, file };
        })
        .filter((item) => item.media || item.file)
        .sort((a, b) => {
          const aPreferred = preferMedia ? a.media : a.file;
          const bPreferred = preferMedia ? b.media : b.file;
          return Number(bPreferred) - Number(aPreferred) ||
            a.rect.top - b.rect.top ||
            a.rect.left - b.rect.left;
        });
      const item = menuItems[0]?.element || null;
      if (!item) {
        return null;
      }

      const rect = item.getBoundingClientRect();
      return {
        x: Math.round(rect.left + rect.width / 2),
        y: Math.round(rect.top + rect.height / 2)
      };
    }, { preferMedia }).catch(() => null);

    if (!point) {
      await p.waitForTimeout(100);
    }
  }

  if (!point) {
    return false;
  }

  try {
    const fileChooserPromise = p.waitForEvent("filechooser", { timeout: 5000 }).catch(() => null);
    await p.mouse.click(point.x, point.y);
    const fileChooser = await fileChooserPromise;
    if (!fileChooser) {
      return false;
    }

    await fileChooser.setFiles(filePath);
    return true;
  } catch {
    return false;
  }
}

async function waitForAttachmentPreview(p, timeoutMs = 8000) {
  const deadline = Date.now() + timeoutMs;
  while (Date.now() < deadline) {
    const ready = await p.evaluate(() => {
      const isVisible = (element) => {
        if (!(element instanceof Element)) return false;
        const style = window.getComputedStyle(element);
        const rect = element.getBoundingClientRect();
        return style.visibility !== "hidden" &&
          style.display !== "none" &&
          rect.width > 0 &&
          rect.height > 0 &&
          rect.bottom >= 0 &&
          rect.right >= 0 &&
          rect.top <= window.innerHeight &&
          rect.left <= window.innerWidth;
      };
      const bottomArea = (element) => {
        const rect = element.getBoundingClientRect();
        return rect.left > window.innerWidth * 0.30 && rect.top > window.innerHeight * 0.45;
      };
      const isPendingUploadSurface = (element) => {
        if (element.closest?.("aside, [class*='messageWrapper' i], [class*='bubble' i], [class*='message--' i], [role='listitem']")) {
          return false;
        }

        const surface = element.closest?.([
          "[data-testid='composer']",
          "[class*='composer' i]",
          "[role='dialog']",
          "[class*='modal' i]",
          "[class*='preview' i]",
          "[class*='attach' i]",
          "[class*='upload' i]",
          "[class*='file' i]",
          "[class*='media' i]"
        ].join(","));
        if (surface) {
          return true;
        }

        const rect = element.getBoundingClientRect();
        return rect.left > window.innerWidth * 0.38 &&
          rect.top > window.innerHeight * 0.55 &&
          rect.bottom > window.innerHeight * 0.70;
      };
      const previewSelectors = [
        "[class*='preview' i]",
        "[class*='attach' i]",
        "[class*='upload' i]",
        "[class*='file' i]",
        "[class*='media' i]",
        "img",
        "video"
      ];
      const hasPreview = previewSelectors
        .flatMap((selector) => Array.from(document.querySelectorAll(selector)))
        .some((element) => isVisible(element) && bottomArea(element) && isPendingUploadSurface(element));
      const hasFileName = Array.from(document.querySelectorAll("div, span, p"))
        .some((element) => {
          if (!isVisible(element) || !bottomArea(element) || !isPendingUploadSurface(element)) {
            return false;
          }

          const text = String(element.innerText || element.textContent || "").trim();
          return /\.(jpe?g|png|webp|gif|heic|mp4|mov|webm|mp3|ogg|m4a|wav|pdf|docx?|xlsx?|zip|rar|7z)\b/i.test(text);
        });
      return hasPreview || hasFileName;
    }).catch(() => false);

    if (ready) {
      return true;
    }

    await p.waitForTimeout(250);
  }

  console.warn("[send/attachment] attachment preview was not detected before sending");
  return false;
}

async function clickSendButton(p) {
  const point = await p.evaluate(() => {
    const isVisible = (element) => {
      const style = window.getComputedStyle(element);
      const rect = element.getBoundingClientRect();
      return style.visibility !== "hidden" &&
        style.display !== "none" &&
        rect.width > 0 &&
        rect.height > 0 &&
        rect.bottom >= 0 &&
        rect.right >= 0 &&
        rect.top <= window.innerHeight &&
        rect.left <= window.innerWidth;
    };
    const buttons = Array.from(document.querySelectorAll("button, [role='button']"))
      .filter((button) => !button.disabled && isVisible(button));
    const candidates = buttons
      .map((button) => {
        const rect = button.getBoundingClientRect();
        const text = [
          button.getAttribute("aria-label"),
          button.getAttribute("title"),
          button.getAttribute("data-testid"),
          button.className,
          button.innerText,
          button.textContent
        ].join(" ").trim().toLowerCase();
        const exact = /send message|\u043e\u0442\u043f\u0440\u0430\u0432\u0438\u0442\u044c \u0441\u043e\u043e\u0431\u0449\u0435\u043d\u0438\u0435/.test(text);
        const generic = /send|submit|\u043e\u0442\u043f\u0440\u0430\u0432/.test(text);
        return {
          button,
          rect,
          exact,
          generic,
          bottomRight: rect.left > window.innerWidth * 0.32 && rect.top > window.innerHeight * 0.55
        };
      })
      .filter((candidate) => candidate.generic);
    const match = candidates
      .sort((a, b) =>
        Number(b.exact) - Number(a.exact) ||
        Number(b.bottomRight) - Number(a.bottomRight) ||
        b.rect.left - a.rect.left ||
        b.rect.top - a.rect.top)[0]?.button || null;

    if (!match) {
      return null;
    }

    const rect = match.getBoundingClientRect();
    return {
      x: Math.round(rect.left + rect.width / 2),
      y: Math.round(rect.top + rect.height / 2)
    };
  }).catch(() => false);

  if (!point) {
    return false;
  }

  await p.mouse.click(point.x, point.y);
  return true;
}

async function clickComposerRightmostButton(p) {
  const point = await p.evaluate(() => {
    const isVisible = (element) => {
      const style = window.getComputedStyle(element);
      const rect = element.getBoundingClientRect();
      return style.visibility !== "hidden" &&
        style.display !== "none" &&
        rect.width > 0 &&
        rect.height > 0 &&
        rect.bottom >= 0 &&
        rect.right >= 0 &&
        rect.top <= window.innerHeight &&
        rect.left <= window.innerWidth;
    };
    const isComposerButton = (button) => {
      const rect = button.getBoundingClientRect();
      if (rect.left < window.innerWidth * 0.32 || rect.top < window.innerHeight * 0.55) {
        return false;
      }
      const text = [
        button.getAttribute("aria-label"),
        button.getAttribute("title"),
        button.getAttribute("data-testid"),
        button.className,
        button.innerText,
        button.textContent
      ].join(" ").trim().toLowerCase();
      return !/sticker|emoji|attach|upload|\u0441\u0442\u0438\u043a\u0435\u0440|\u044d\u043c\u043e\u0434\u0437\u0438|\u0444\u0430\u0439\u043b|\u0437\u0430\u0433\u0440\u0443\u0437/.test(text);
    };

    const buttons = Array.from(document.querySelectorAll("button, [role='button']"))
      .filter((button) => !button.disabled && isVisible(button) && isComposerButton(button))
      .sort((a, b) => b.getBoundingClientRect().left - a.getBoundingClientRect().left);
    const button = buttons[0];
    if (!button) {
      return null;
    }

    const rect = button.getBoundingClientRect();
    return {
      x: Math.round(rect.left + rect.width / 2),
      y: Math.round(rect.top + rect.height / 2)
    };
  }).catch(() => false);

  if (!point) {
    return false;
  }

  await p.mouse.click(point.x, point.y);
  return true;
}

async function scrollOpenChatToBottom(p) {
  await p.evaluate(() => {
    const isVisible = (element) => {
      if (!(element instanceof HTMLElement)) return false;
      const style = window.getComputedStyle(element);
      const rect = element.getBoundingClientRect();
      return style.visibility !== "hidden" &&
        style.display !== "none" &&
        rect.width > 0 &&
        rect.height > 0 &&
        rect.bottom >= 0 &&
        rect.right >= 0 &&
        rect.top <= window.innerHeight &&
        rect.left <= window.innerWidth;
    };
    const root = Array.from(document.querySelectorAll("main *, [role='main'] *, [class*='scroll' i]"))
      .filter((element) => element instanceof HTMLElement && isVisible(element))
      .filter((element) => {
        const rect = element.getBoundingClientRect();
        return rect.left > window.innerWidth * 0.32 &&
          rect.top < window.innerHeight * 0.82 &&
          element.scrollHeight > element.clientHeight + 40;
      })
      .sort((a, b) => (b.scrollHeight - b.clientHeight) - (a.scrollHeight - a.clientHeight))[0];
    if (root instanceof HTMLElement) {
      root.scrollTop = root.scrollHeight;
      root.dispatchEvent(new Event("scroll", { bubbles: true }));
    }
  }).catch(() => {});
  await p.waitForTimeout(120);
}

async function editMessageInMax(p, externalChatId, externalMessageId, currentText, text) {
  const target = await locateMessageForAction(p, externalChatId, externalMessageId, currentText);
  if (!target) {
    return { success: false, error: "MAX message was not found on the visible chat history." };
  }

  if (!(await openMessageMenu(p, target.rect))) {
    return { success: false, error: "MAX message menu was not opened." };
  }

  if (!(await clickActionByText(p, ["\u0440\u0435\u0434\u0430\u043a\u0442", "\u0438\u0437\u043c\u0435\u043d", "edit"]))) {
    return { success: false, error: "MAX edit action was not found in the message menu." };
  }

  await p.waitForTimeout(600);
  if (!(await fillComposerText(p, text, true))) {
    return { success: false, error: "MAX edit composer was not found." };
  }

  if (!(await clickSendButton(p))) {
    await p.keyboard.press("Enter");
  }
  await p.waitForTimeout(1000);
  return { success: true, error: null };
}

async function deleteMessageInMax(p, externalChatId, externalMessageId, currentText) {
  const target = await locateMessageForAction(p, externalChatId, externalMessageId, currentText);
  if (!target) {
    return { success: false, error: "MAX message was not found on the visible chat history." };
  }

  if (!(await openMessageMenu(p, target.rect))) {
    return { success: false, error: "MAX message menu was not opened." };
  }

  if (!(await clickActionByText(p, ["\u0443\u0434\u0430\u043b", "delete", "remove"]))) {
    return { success: false, error: "MAX delete action was not found in the message menu." };
  }

  await p.waitForTimeout(500);
  await clickActionByText(p, ["\u0443\u0434\u0430\u043b\u0438\u0442\u044c", "\u0434\u0430", "delete", "yes", "ok"]);
  await p.waitForTimeout(1000);
  return { success: true, error: null };
}

async function clearChatHistoryInMax(p, externalChatId, chatUrl) {
  return await applyChatMenuActionInMax(
    p,
    externalChatId,
    chatUrl,
    ["\u043e\u0447\u0438\u0441\u0442\u0438\u0442\u044c \u0438\u0441\u0442\u043e\u0440", "\u043e\u0447\u0438\u0441\u0442\u0438\u0442\u044c \u0447\u0430\u0442", "clear history", "clear chat"],
    ["\u043e\u0447\u0438\u0441\u0442\u0438\u0442\u044c", "\u0434\u0430", "clear", "yes", "ok"],
    "clear history");
}

async function deleteChatInMax(p, externalChatId, chatUrl) {
  return await applyChatMenuActionInMax(
    p,
    externalChatId,
    chatUrl,
    ["\u0443\u0434\u0430\u043b\u0438\u0442\u044c \u0447\u0430\u0442", "\u0443\u0434\u0430\u043b\u0438\u0442\u044c", "delete chat", "delete conversation", "remove chat"],
    ["\u0443\u0434\u0430\u043b\u0438\u0442\u044c", "\u0434\u0430", "delete", "yes", "ok"],
    "delete chat");
}

async function applyChatMenuActionInMax(p, externalChatId, chatUrl, actionLabels, confirmLabels, actionName) {
  const menuOpened = await openSidebarChatMenu(p, externalChatId, chatUrl, actionLabels);
  if (!menuOpened) {
    return { success: false, error: `MAX ${actionName} menu was not opened.` };
  }

  if (!(await clickActionByTextWithRetry(p, actionLabels, 1500))) {
    await p.keyboard.press("Escape").catch(() => {});
    await clearSidebarSearch(p);
    return { success: false, error: `MAX ${actionName} action was not found in the chat menu.` };
  }

  await p.waitForTimeout(700);
  if (!(await clickActionByTextWithRetry(p, confirmLabels, 3000))) {
    const menuTexts = await readVisibleActionTexts(p);
    await p.keyboard.press("Escape").catch(() => {});
    await clearSidebarSearch(p);
    return {
      success: false,
      error: `MAX ${actionName} confirmation was not found. Visible actions: ${menuTexts.slice(0, 12).join(" | ")}`
    };
  }
  await p.waitForTimeout(1200);
  await clearSidebarSearch(p);
  return { success: true, error: null };
}

async function setMessageReactionInMax(p, externalChatId, externalMessageId, currentText, emoji) {
  const target = await locateMessageForAction(p, externalChatId, externalMessageId, currentText);
  if (!target) {
    return { success: false, error: "MAX message was not found on the visible chat history." };
  }

  if (!(await openMessageMenu(p, target.rect))) {
    return { success: false, error: "MAX message menu was not opened." };
  }

  if (await clickActionByText(p, [emoji])) {
    await p.waitForTimeout(600);
    return { success: true, error: null };
  }

  await clickActionByText(p, ["\u0440\u0435\u0430\u043a", "reaction", "emoji"]);
  await p.waitForTimeout(500);
  if (!(await clickActionByText(p, [emoji]))) {
    return { success: false, error: "MAX reaction picker did not expose the requested emoji." };
  }

  await p.waitForTimeout(600);
  return { success: true, error: null };
}

async function clearMessageReactionInMax(p, externalChatId, externalMessageId, currentText, emoji) {
  const target = await locateMessageForAction(p, externalChatId, externalMessageId, currentText);
  if (!target) {
    return { success: false, error: "MAX message was not found on the visible chat history." };
  }

  if (await clickReactionNearMessage(p, target.rect, emoji)) {
    await p.waitForTimeout(600);
    return { success: true, error: null };
  }

  if (!(await openMessageMenu(p, target.rect))) {
    return { success: false, error: "MAX message menu was not opened." };
  }

  if (await clickActionByText(p, [emoji, "\u0443\u0431\u0440\u0430\u0442\u044c \u0440\u0435\u0430\u043a", "remove reaction", "clear reaction"])) {
    await p.waitForTimeout(600);
    return { success: true, error: null };
  }

  return { success: false, error: "MAX reaction clear action was not found." };
}

async function locateMessageForAction(p, externalChatId, externalMessageId, currentText) {
  if (externalChatId) {
    const opened = await ensureDomChatOpen(p, externalChatId, 700);
    if (!opened) {
      return null;
    }
  }

  const history = await extractOpenChatHistory(p, externalChatId);
  const textHint = cleanComparableText(currentText, 500);
  let message = history.messages.find((item) => item.externalId === externalMessageId);
  if (!message && textHint) {
    const matches = history.messages.filter((item) => {
      const text = cleanComparableText(item.text, 500);
      return text && (text === textHint || text.includes(textHint) || textHint.includes(text));
    });
    message = matches[matches.length - 1];
  }

  if (!message?.rect) {
    return null;
  }

  return message;
}

async function openMessageMenu(p, rect) {
  const point = rectCenter(rect);
  await p.mouse.move(point.x, point.y);
  await p.waitForTimeout(250);

  if (await clickMessageMenuButton(p, rect)) {
    await p.waitForTimeout(500);
    if (await hasActionSurface(p)) {
      return true;
    }
  }

  await p.mouse.click(point.x, point.y, { button: "right" });
  await p.waitForTimeout(500);
  if (await hasActionSurface(p)) {
    return true;
  }

  await p.mouse.dblclick(point.x, point.y);
  await p.waitForTimeout(500);
  return await hasActionSurface(p);
}

async function clickMessageMenuButton(p, rect) {
  return await p.evaluate((targetRect) => {
    const isVisible = (element) => {
      const style = window.getComputedStyle(element);
      const nodeRect = element.getBoundingClientRect();
      return style.visibility !== "hidden" &&
        style.display !== "none" &&
        nodeRect.width > 0 &&
        nodeRect.height > 0 &&
        nodeRect.bottom >= 0 &&
        nodeRect.right >= 0 &&
        nodeRect.top <= window.innerHeight &&
        nodeRect.left <= window.innerWidth;
    };
    const expanded = {
      left: targetRect.x - 60,
      right: targetRect.x + targetRect.width + 90,
      top: targetRect.y - 40,
      bottom: targetRect.y + targetRect.height + 40
    };
    const inArea = (element) => {
      const rect = element.getBoundingClientRect();
      const centerX = rect.left + rect.width / 2;
      const centerY = rect.top + rect.height / 2;
      return centerX >= expanded.left &&
        centerX <= expanded.right &&
        centerY >= expanded.top &&
        centerY <= expanded.bottom;
    };
    const buttons = Array.from(document.querySelectorAll("button,[role='button']"))
      .filter((button) => button instanceof HTMLElement && isVisible(button) && inArea(button));
    const match = buttons.find((button) => {
      const text = String(button.innerText || button.getAttribute("aria-label") || button.getAttribute("title") || "").toLowerCase();
      const cls = String(button.className || "").toLowerCase();
      return text.includes("\u0435\u0449") ||
        text.includes("more") ||
        text.includes("menu") ||
        text.includes("actions") ||
        cls.includes("more") ||
        cls.includes("menu") ||
        text === "\u22ef" ||
        text === "\u2026";
    }) || buttons.sort((a, b) => b.getBoundingClientRect().right - a.getBoundingClientRect().right)[0];

    if (!match) {
      return false;
    }

    match.click();
    return true;
  }, rect).catch(() => false);
}

async function openChatMenu(p, expectedLabels) {
  for (let attempt = 0; attempt < 3; attempt++) {
    if (await clickChatMenuButton(p)) {
      await p.waitForTimeout(600);
      if (await hasMenuActionSurface(p, expectedLabels)) {
        return true;
      }
    }

    await p.keyboard.press("Escape").catch(() => {});
    await p.waitForTimeout(250);
  }

  return false;
}

async function clickChatMenuButton(p) {
  return await p.evaluate(() => {
    const isVisible = (element) => {
      const style = window.getComputedStyle(element);
      const rect = element.getBoundingClientRect();
      return style.visibility !== "hidden" &&
        style.display !== "none" &&
        rect.width > 0 &&
        rect.height > 0 &&
        rect.bottom >= 0 &&
        rect.right >= 0 &&
        rect.top <= window.innerHeight &&
        rect.left <= window.innerWidth;
    };
    const textOf = (element) => String(
      element.innerText ||
      element.textContent ||
      element.getAttribute("aria-label") ||
      element.getAttribute("title") ||
      ""
    ).trim().toLowerCase();
    const chatRoot = document.querySelector("[class*='openedChat' i]") ||
      document.querySelector("main") ||
      document.body;
    const rootRect = chatRoot.getBoundingClientRect();
    const headerBottom = Math.min(window.innerHeight, rootRect.top + 170);
    const buttons = Array.from(document.querySelectorAll("button,[role='button']"))
      .filter((button) => {
        if (!(button instanceof HTMLElement) || !isVisible(button)) return false;
        const rect = button.getBoundingClientRect();
        const centerX = rect.left + rect.width / 2;
        const centerY = rect.top + rect.height / 2;
        return centerX >= rootRect.left + rootRect.width * 0.45 &&
          centerX <= rootRect.right + 8 &&
          centerY >= Math.max(0, rootRect.top) &&
          centerY <= headerBottom;
      });
    const match = buttons.find((button) => {
      const text = textOf(button);
      const cls = String(button.className || "").toLowerCase();
      return text.includes("\u0435\u0449") ||
        text.includes("more") ||
        text.includes("menu") ||
        text.includes("actions") ||
        cls.includes("more") ||
        cls.includes("menu") ||
        text === "\u22ef" ||
        text === "\u2026";
    }) || buttons.sort((a, b) => b.getBoundingClientRect().right - a.getBoundingClientRect().right)[0];

    if (!match) {
      return false;
    }

    match.click();
    return true;
  }).catch(() => false);
}

async function hasMenuActionSurface(p, labels) {
  return await p.evaluate((rawLabels) => {
    const normalizedLabels = rawLabels.map((label) => String(label || "").trim().toLowerCase()).filter(Boolean);
    if (normalizedLabels.length === 0) {
      return false;
    }
    const isVisible = (element) => {
      const style = window.getComputedStyle(element);
      const rect = element.getBoundingClientRect();
      return style.visibility !== "hidden" &&
        style.display !== "none" &&
        rect.width > 0 &&
        rect.height > 0 &&
        rect.bottom >= 0 &&
        rect.right >= 0 &&
        rect.top <= window.innerHeight &&
        rect.left <= window.innerWidth;
    };
    const textOf = (element) => String(
      element.innerText ||
      element.textContent ||
      element.getAttribute("aria-label") ||
      element.getAttribute("title") ||
      ""
    ).trim().toLowerCase();
    return Array.from(document.querySelectorAll("[role='menu'],[role='menuitem'],[class*='menu' i],[class*='popover' i],[class*='dropdown' i],button,span,div"))
      .filter((element) => element instanceof HTMLElement && isVisible(element))
      .some((element) => {
        const text = textOf(element);
        return text && normalizedLabels.some((label) => text === label || text.includes(label));
      });
  }, labels).catch(() => false);
}

async function readVisibleActionTexts(p) {
  return await p.evaluate(() => {
    const isVisible = (element) => {
      if (!(element instanceof HTMLElement)) return false;
      const style = window.getComputedStyle(element);
      const rect = element.getBoundingClientRect();
      return style.visibility !== "hidden" &&
        style.display !== "none" &&
        rect.width > 0 &&
        rect.height > 0 &&
        rect.bottom >= 0 &&
        rect.right >= 0 &&
        rect.top <= window.innerHeight &&
        rect.left <= window.innerWidth;
    };
    const textOf = (element) => String(
      element.innerText ||
      element.textContent ||
      element.getAttribute("aria-label") ||
      element.getAttribute("title") ||
      ""
    ).replace(/\s+/g, " ").trim();
    const selector = [
      "[role='menu']",
      "[role='menuitem']",
      "[class*='menu' i]",
      "[class*='popover' i]",
      "[class*='dropdown' i]",
      "button",
      "[role='button']"
    ].join(",");
    const seen = new Set();
    return Array.from(document.querySelectorAll(selector))
      .filter((element) => element instanceof HTMLElement && isVisible(element))
      .map(textOf)
      .filter(Boolean)
      .filter((text) => {
        if (seen.has(text)) return false;
        seen.add(text);
        return true;
      })
      .slice(0, 80);
  }).catch(() => []);
}

async function hasActionSurface(p) {
  return await p.evaluate(() => {
    const isVisible = (element) => {
      const style = window.getComputedStyle(element);
      const rect = element.getBoundingClientRect();
      return style.visibility !== "hidden" &&
        style.display !== "none" &&
        rect.width > 0 &&
        rect.height > 0 &&
        rect.bottom >= 0 &&
        rect.right >= 0 &&
        rect.top <= window.innerHeight &&
        rect.left <= window.innerWidth;
    };
    const labels = /(\u0440\u0435\u0434\u0430\u043a\u0442|\u0438\u0437\u043c\u0435\u043d|\u0443\u0434\u0430\u043b|\u0440\u0435\u0430\u043a|edit|delete|remove|reaction)/i;
    return Array.from(document.querySelectorAll("[role='menu'],[role='menuitem'],[class*='menu' i],[class*='popover' i],[class*='dropdown' i],button"))
      .filter((element) => element instanceof HTMLElement && isVisible(element))
      .some((element) => labels.test(element.innerText || element.textContent || element.getAttribute("aria-label") || ""));
  }).catch(() => false);
}

async function clickActionByText(p, labels) {
  return await p.evaluate((rawLabels) => {
    const normalizedLabels = rawLabels.map((label) => String(label || "").trim().toLowerCase()).filter(Boolean);
    if (normalizedLabels.length === 0) {
      return false;
    }
    const isVisible = (element) => {
      const style = window.getComputedStyle(element);
      const rect = element.getBoundingClientRect();
      return style.visibility !== "hidden" &&
        style.display !== "none" &&
        rect.width > 0 &&
        rect.height > 0 &&
        rect.bottom >= 0 &&
        rect.right >= 0 &&
        rect.top <= window.innerHeight &&
        rect.left <= window.innerWidth;
    };
    const textOf = (element) => String(
      element.innerText ||
      element.textContent ||
      element.getAttribute("aria-label") ||
      element.getAttribute("title") ||
      ""
    ).trim().toLowerCase();
    const scoreMatch = (element) => {
      const text = textOf(element);
      if (!text) return 0;
      if (normalizedLabels.some((label) => text === label)) return 4;
      if (normalizedLabels.some((label) => text.startsWith(label))) return 3;
      if (normalizedLabels.some((label) => text.includes(label))) return 2;
      return 0;
    };
    const interactive = Array.from(document.querySelectorAll("button,[role='button'],[role='menuitem']"))
      .filter((element) => element instanceof HTMLElement && isVisible(element));
    const leafTextNodes = Array.from(document.querySelectorAll("span,div"))
      .filter((element) => element instanceof HTMLElement && isVisible(element))
      .filter((element) => element.querySelector("button,[role='button'],[role='menuitem']") == null)
      .filter((element) => element.children.length <= 1);
    const match = [...interactive, ...leafTextNodes]
      .map((element, index) => ({ element, index, score: scoreMatch(element) }))
      .filter((item) => item.score > 0)
      .sort((a, b) => b.score - a.score || a.index - b.index)[0]?.element || null;
    if (!match) {
      return false;
    }

    const clickable = match.closest("button,[role='button'],[role='menuitem']") || match;
    clickable.click();
    return true;
  }, labels).catch(() => false);
}

async function clickActionByTextWithRetry(p, labels, timeoutMs = 2000) {
  const deadline = Date.now() + timeoutMs;
  while (Date.now() <= deadline) {
    if (await clickActionByText(p, labels)) {
      return true;
    }
    await p.waitForTimeout(200);
  }

  return false;
}

async function clickReactionNearMessage(p, rect, emoji) {
  return await p.evaluate(({ targetRect, requestedEmoji }) => {
    const isVisible = (element) => {
      const style = window.getComputedStyle(element);
      const rect = element.getBoundingClientRect();
      return style.visibility !== "hidden" &&
        style.display !== "none" &&
        rect.width > 0 &&
        rect.height > 0 &&
        rect.bottom >= 0 &&
        rect.right >= 0 &&
        rect.top <= window.innerHeight &&
        rect.left <= window.innerWidth;
    };
    const expanded = {
      left: targetRect.x - 40,
      right: targetRect.x + targetRect.width + 80,
      top: targetRect.y - 20,
      bottom: targetRect.y + targetRect.height + 70
    };
    const inArea = (element) => {
      const rect = element.getBoundingClientRect();
      const centerX = rect.left + rect.width / 2;
      const centerY = rect.top + rect.height / 2;
      return centerX >= expanded.left &&
        centerX <= expanded.right &&
        centerY >= expanded.top &&
        centerY <= expanded.bottom;
    };
    const match = Array.from(document.querySelectorAll("button,[role='button'],span,div"))
      .filter((element) => element instanceof HTMLElement && isVisible(element) && inArea(element))
      .find((element) => String(element.innerText || element.textContent || element.getAttribute("aria-label") || "").includes(requestedEmoji));
    if (!match) {
      return false;
    }
    const clickable = match.closest("button,[role='button']") || match;
    clickable.click();
    return true;
  }, { targetRect: rect, requestedEmoji: emoji }).catch(() => false);
}

function rectCenter(rect) {
  return {
    x: Math.round(Number(rect.x || 0) + Number(rect.width || 0) / 2),
    y: Math.round(Number(rect.y || 0) + Number(rect.height || 0) / 2)
  };
}

function normalizeDomChatFingerprint(value) {
  const raw = cleanComparableText(value, 800);
  if (!raw || raw.startsWith("data:")) {
    return "";
  }

  try {
    const url = new URL(raw);
    const mediaKey = url.searchParams.get("r");
    if (mediaKey) {
      return `r:${mediaKey}`;
    }

    ["fn", "size", "width", "height"].forEach((key) => url.searchParams.delete(key));
    return url.href;
  } catch {
    return raw;
  }
}

function makeDomChatExternalId(title, text, href, index, avatarUrl) {
  const descriptor = {
    title: cleanComparableText(title, 160),
    avatarUrl: normalizeDomChatFingerprint(avatarUrl),
    href: ""
  };
  const encodedDescriptor = Buffer.from(JSON.stringify(descriptor), "utf8")
    .toString("base64url");
  return `dom:${stableHash("chat", descriptor.title, descriptor.href, descriptor.avatarUrl)}:${encodedDescriptor}`;
}

function decodeDomChatDescriptor(externalChatId) {
  const parts = String(externalChatId || "").split(":");
  if (parts.length < 3 || parts[0] !== "dom") {
    return null;
  }

  try {
    const decoded = Buffer.from(parts[2], "base64url").toString("utf8");
    const parsed = JSON.parse(decoded);
    if (parsed && typeof parsed === "object") {
      const title = cleanComparableText(parsed.title, 160);
      if (!title) {
        return null;
      }

      return {
        title,
        avatarUrl: cleanComparableText(parsed.avatarUrl, 800),
        href: cleanComparableText(parsed.href, 800)
      };
    }
  } catch {
    try {
      const title = Buffer.from(parts[2], "base64url").toString("utf8");
      return title ? { title, avatarUrl: "", href: "" } : null;
    } catch {
      return null;
    }
  }

  return null;
}

function decodeDomChatTitle(externalChatId) {
  return decodeDomChatDescriptor(externalChatId)?.title || null;
}

function stableHash(...parts) {
  return createHash("sha256")
    .update(parts.map((part) => String(part ?? "")).join("\n"))
    .digest("hex")
    .slice(0, 24);
}

function clampNumber(value, min, max, fallback) {
  const number = Number(value);
  if (!Number.isFinite(number)) {
    return fallback;
  }

  return Math.max(min, Math.min(max, Math.trunc(number)));
}

async function fillFirst(p, value, selectors) {
  for (const selector of selectors) {
    try {
      const locator = p.locator(selector).first();
      if ((await locator.count()) === 0) continue;
      await clearAndInsertText(p, locator, value);
      return true;
    } catch {
      // Try the next likely selector.
    }
  }
  return false;
}

async function clearAndInsertText(p, locator, text) {
  await locator.click({ timeout: 5000 });
  await p.keyboard.press(process.platform === "darwin" ? "Meta+A" : "Control+A");
  await p.keyboard.press("Backspace");
  await p.keyboard.insertText(String(text));
}

async function fillLoginCode(p, code) {
  const filled = await p.evaluate((value) => {
    const isVisible = (element) => {
      const style = window.getComputedStyle(element);
      const rect = element.getBoundingClientRect();
      return style.visibility !== "hidden" &&
        style.display !== "none" &&
        rect.width > 0 &&
        rect.height > 0 &&
        rect.bottom >= 0 &&
        rect.right >= 0 &&
        rect.top <= window.innerHeight &&
        rect.left <= window.innerWidth;
    };
    const setControlValue = (node, nextValue) => {
      if (node instanceof HTMLInputElement || node instanceof HTMLTextAreaElement) {
        const proto = node instanceof HTMLTextAreaElement
          ? HTMLTextAreaElement.prototype
          : HTMLInputElement.prototype;
        const descriptor = Object.getOwnPropertyDescriptor(proto, "value");
        if (descriptor?.set) {
          descriptor.set.call(node, nextValue);
        } else {
          node.value = nextValue;
        }
      } else {
        node.textContent = nextValue;
      }
      node.dispatchEvent(new InputEvent("input", { bubbles: true, data: nextValue, inputType: "insertText" }));
      node.dispatchEvent(new Event("change", { bubbles: true }));
    };

    const inputs = Array.from(document.querySelectorAll("input, textarea, [contenteditable='true']"))
      .filter((node) => node instanceof HTMLElement && isVisible(node))
      .filter((node) => {
        const type = String(node.getAttribute("type") || "").toLowerCase();
        return !["hidden", "submit", "button", "checkbox", "radio"].includes(type);
      });
    const codeInputs = inputs.filter((node) => {
      const hint = [
        node.getAttribute("autocomplete"),
        node.getAttribute("name"),
        node.getAttribute("placeholder"),
        node.getAttribute("aria-label"),
        node.className,
        node.getAttribute("inputmode")
      ].join(" ");
      return /one-time|otp|code|pin|verification|numeric/i.test(hint) ||
        Number(node.getAttribute("maxlength") || 0) <= 1;
    });
    const targets = codeInputs.length > 0 ? codeInputs : inputs;
    if (targets.length === 0) {
      return false;
    }
    if (targets.length > 1 && targets.every((node) => Number(node.getAttribute("maxlength") || 1) <= 1)) {
      for (let index = 0; index < Math.min(value.length, targets.length); index += 1) {
        targets[index].focus();
        setControlValue(targets[index], value[index]);
      }
      return true;
    }
    targets[0].focus();
    setControlValue(targets[0], value);
    return true;
  }, code).catch(() => false);

  if (filled) {
    return true;
  }

  const inputFilled = await fillFirst(p, code, [
    "input[autocomplete='one-time-code']",
    "input[inputmode='numeric']",
    "input[type='tel']",
    "input[type='text']",
    "input:not([type])",
    "input"
  ]);
  if (inputFilled) {
    return true;
  }

  for (const selector of ["[role='group'].code", "[role='group'][class*='code' i]", ".code", "[role='group']"]) {
    try {
      const group = p.locator(selector).first();
      if ((await group.count()) === 0) continue;
      await group.click({ timeout: 3000 });
      await p.keyboard.insertText(code);
      return true;
    } catch {
      // Try the next OTP container shape.
    }
  }

  return false;
}

async function openPhoneLogin(p) {
  if (await hasPhoneInput(p)) {
    return;
  }

  const phoneLoginPattern = /(\u0432\u043e\u0439\u0442\u0438.*\u043d\u043e\u043c\u0435\u0440|\u043d\u043e\u043c\u0435\u0440.*\u0442\u0435\u043b\u0435\u0444\u043e\u043d|phone)/i;
  try {
    const byText = p.getByText(phoneLoginPattern).last();
    if ((await byText.count()) > 0) {
      await byText.click({ timeout: 3000 });
      await p.waitForTimeout(1200);
    }
  } catch {
    // Fall through to DOM text matching below.
  }

  if (await hasPhoneInput(p)) {
    return;
  }

  await p.evaluate(() => {
    const phoneLoginPattern = /(\u0432\u043e\u0439\u0442\u0438.*\u043d\u043e\u043c\u0435\u0440|\u043d\u043e\u043c\u0435\u0440.*\u0442\u0435\u043b\u0435\u0444\u043e\u043d|phone)/i;
    const elements = Array.from(document.querySelectorAll("button,a,[role=button],div,span"));
    const match = elements.find((element) => phoneLoginPattern.test(element.textContent || ""));
    if (match) {
      match.click();
    }
  });
  await p.waitForTimeout(1200);
}

async function hasPhoneInput(p) {
  return (await p.locator("input[type='tel'], input[autocomplete='tel']").count()) > 0;
}

async function waitForLoginStage(p, expectedStage, timeoutMs) {
  const deadline = Date.now() + timeoutMs;
  while (Date.now() <= deadline) {
    const stage = await detectLoginStage(p);
    if (stage === expectedStage) {
      return true;
    }

    if (timeoutMs === 0) {
      return false;
    }

    await p.waitForTimeout(1000);
  }

  return false;
}

async function detectLoginStage(p) {
  const title = await safeTitle(p);
  const url = p.url();
  const bodyText = await safeBodyText(p);
  return detectLoginStageFromText(url, title, bodyText);
}

function detectLoginStageFromText(url, title, bodyText) {
  const currentUrl = String(url || "").toLowerCase();
  const currentTitle = String(title || "").toLowerCase();
  const body = String(bodyText || "").replace(/\s+/g, " ").trim().toLowerCase();

  if (!body && currentTitle.includes("max") && currentUrl.includes("web.max.ru")) {
    return "Loading";
  }

  if (body.includes("\u043d\u0435 \u0440\u043e\u0431\u043e\u0442")) {
    return "Captcha";
  }

  if (body.includes("qr") || body.includes("\u0432\u043e\u0439\u0434\u0438\u0442\u0435 \u0432 max \u043f\u043e qr")) {
    return "QrLogin";
  }

  const looksLikeAuthorizedShell = currentUrl.includes("web.max.ru") &&
    (/web\.max\.ru\/\d+/.test(currentUrl) ||
      currentTitle.includes("\u0447\u0430\u0442") ||
      currentTitle.includes("\u043d\u0435\u043f\u0440\u043e\u0447\u0438\u0442\u0430\u043d") ||
      currentTitle.includes("max"));
  if (looksLikeAuthorizedShell && !currentUrl.includes("login")) {
    return "Authorized";
  }

  const phoneScreenMarkers = [
    "\u0441 \u043a\u0430\u043a\u0438\u043c \u043d\u043e\u043c\u0435\u0440\u043e\u043c",
    "\u043d\u043e\u043c\u0435\u0440 \u0442\u0435\u043b\u0435\u0444\u043e\u043d\u0430",
    "\u043d\u0430 \u043d\u0435\u0433\u043e \u043f\u0440\u0438\u0434\u0435\u0442 \u0441\u043c\u0441 \u0441 \u043a\u043e\u0434\u043e\u043c"
  ];
  if (phoneScreenMarkers.some((marker) => body.includes(marker))) {
    return "PhoneEntry";
  }

  const codeMarkers = [
    "\u043e\u0442\u043f\u0440\u0430\u0432\u0438\u043b\u0438 \u043a\u043e\u0434",
    "\u0432\u0432\u0435\u0434\u0438\u0442\u0435 \u043a\u043e\u0434",
    "\u043a\u043e\u0434 \u0438\u0437 sms",
    "\u043a\u043e\u0434 \u0438\u0437 \u0441\u043c\u0441",
    "\u043a\u043e\u0434 \u043f\u043e\u0434\u0442\u0432\u0435\u0440\u0436\u0434",
    "\u043a\u043e\u0434 \u0438\u0437 \u0441\u043e\u043e\u0431\u0449\u0435\u043d",
    "\u0435\u0441\u043b\u0438 \u043d\u0435 \u043f\u043e\u043b\u0443\u0447\u0438\u043b\u0438 \u0441\u043c\u0441",
    "\u043f\u043e\u043b\u0443\u0447\u0438\u0442\u044c \u043d\u043e\u0432\u044b\u0439 \u043a\u043e\u0434"
  ];
  if (codeMarkers.some((marker) => body.includes(marker))) {
    return "CodeEntry";
  }

  const loginMarkers = [
    "\u0432\u043e\u0439\u0442\u0438",
    "\u043f\u043e\u043b\u0438\u0442\u0438\u043a",
    "\u0441\u043e\u0433\u043b\u0430\u0448\u0435\u043d"
  ];
  if (loginMarkers.some((marker) => body.includes(marker))) {
    return "Login";
  }

  if (looksLikeAuthorizedShell) {
    return "Authorized";
  }

  return "Unknown";
}

async function isCodeEntryScreen(p) {
  return await p.evaluate(() => {
    const text = String(document.body?.innerText || "").replace(/\s+/g, " ").trim().toLowerCase();
    const inputs = Array.from(document.querySelectorAll("input"));
    const hasOneTimeCodeInput = inputs.some((input) =>
      String(input.getAttribute("autocomplete") || "").toLowerCase() === "one-time-code");
    if (hasOneTimeCodeInput) {
      return true;
    }

    if (text.includes("\u043d\u0435 \u0440\u043e\u0431\u043e\u0442")) {
      return false;
    }

    const phoneScreenMarkers = [
      "\u0441 \u043a\u0430\u043a\u0438\u043c \u043d\u043e\u043c\u0435\u0440\u043e\u043c",
      "\u043d\u043e\u043c\u0435\u0440 \u0442\u0435\u043b\u0435\u0444\u043e\u043d\u0430",
      "\u043d\u0430 \u043d\u0435\u0433\u043e \u043f\u0440\u0438\u0434\u0435\u0442 \u0441\u043c\u0441 \u0441 \u043a\u043e\u0434\u043e\u043c"
    ];
    if (phoneScreenMarkers.some((marker) => text.includes(marker))) {
      return false;
    }

    const codeMarkers = [
      "\u043e\u0442\u043f\u0440\u0430\u0432\u0438\u043b\u0438 \u043a\u043e\u0434",
      "\u0432\u0432\u0435\u0434\u0438\u0442\u0435 \u043a\u043e\u0434",
      "\u043a\u043e\u0434 \u0438\u0437 sms",
      "\u043a\u043e\u0434 \u0438\u0437 \u0441\u043c\u0441",
      "\u043a\u043e\u0434 \u043f\u043e\u0434\u0442\u0432\u0435\u0440\u0436\u0434",
      "\u043a\u043e\u0434 \u0438\u0437 \u0441\u043e\u043e\u0431\u0449\u0435\u043d",
      "\u0435\u0441\u043b\u0438 \u043d\u0435 \u043f\u043e\u043b\u0443\u0447\u0438\u043b\u0438 \u0441\u043c\u0441",
      "\u043f\u043e\u043b\u0443\u0447\u0438\u0442\u044c \u043d\u043e\u0432\u044b\u0439 \u043a\u043e\u0434"
    ];
    return inputs.length > 0 && codeMarkers.some((marker) => text.includes(marker));
  });
}

function normalizePhoneNumberForMax(phoneNumber) {
  const digits = String(phoneNumber || "").replace(/\D/g, "");
  if (digits.length === 11 && (digits.startsWith("8") || digits.startsWith("7"))) {
    return digits.slice(1);
  }
  return digits || String(phoneNumber || "").trim();
}

function normalizeLoginCode(value) {
  return String(value || "").replace(/\D/g, "").trim();
}

async function cleanupChromiumProfileLocks(profileDir) {
  await Promise.all(["SingletonLock", "SingletonCookie", "SingletonSocket"].map((name) =>
    fs.rm(`${profileDir}/${name}`, { force: true, recursive: true }).catch(() => {})
  ));
}

async function clickLikelySubmitFixed(p) {
  const labels = [
    "\u043f\u0440\u043e\u0434\u043e\u043b\u0436\u0438\u0442\u044c",
    "\u0432\u043e\u0439\u0442\u0438",
    "\u0434\u0430\u043b\u0435\u0435",
    "\u043e\u0442\u043f\u0440\u0430\u0432\u0438\u0442\u044c",
    "continue",
    "next",
    "login"
  ];
  const clicked = await p.evaluate((knownLabels) => {
    const normalized = knownLabels.map((x) => x.toLowerCase());
    const buttons = Array.from(document.querySelectorAll("button,[role=button],input[type=submit]"));
    const match = buttons.find((button) => {
      const text = (button.innerText || button.value || button.getAttribute("aria-label") || "").trim().toLowerCase();
      return !button.disabled && text && normalized.some((label) => text.includes(label));
    }) || buttons.find((button) => !button.disabled);
    if (match) {
      match.click();
      return true;
    }
    return false;
  }, labels);

  if (!clicked) {
    await p.keyboard.press("Enter");
  }
}

async function clickLikelySubmit(p) {
  const labels = ["продолжить", "войти", "далее", "отправить", "continue", "next", "login"];
  const clicked = await p.evaluate((knownLabels) => {
    const normalized = knownLabels.map((x) => x.toLowerCase());
    const buttons = Array.from(document.querySelectorAll("button,[role=button],input[type=submit]"));
    const match = buttons.find((button) => {
      const text = (button.innerText || button.value || button.getAttribute("aria-label") || "").trim().toLowerCase();
      return text && normalized.some((label) => text.includes(label));
    }) || buttons.find((button) => !button.disabled);
    if (match) {
      match.click();
      return true;
    }
    return false;
  }, labels);

  if (!clicked) {
    await p.keyboard.press("Enter");
  }
}

async function clickTextIfVisible(p, text) {
  try {
    const locator = p.getByText(text, { exact: false }).first();
    if ((await locator.count()) > 0) {
      await locator.click({ timeout: 1500 });
    }
  } catch {
    // Chat may already be open.
  }
}

async function safeTitle(p) {
  try {
    return await p.title();
  } catch {
    return null;
  }
}

async function safeBodyText(p) {
  try {
    return (await p.locator("body").innerText({ timeout: 1500 })).replace(/\s+/g, " ").trim();
  } catch {
    return "";
  }
}

function likelyAuthorized(url, title, bodyText) {
  if (!url) return false;
  if (url.toLowerCase().includes("login")) return false;
  const body = String(bodyText || "").toLowerCase();
  const loginMarkers = [
    "\u043d\u0435 \u0440\u043e\u0431\u043e\u0442",
    "\u0432\u043e\u0439\u0442\u0438",
    "\u043d\u043e\u043c\u0435\u0440 \u0442\u0435\u043b\u0435\u0444\u043e\u043d\u0430",
    "qr",
    "\u043a\u043e\u0434\u043e\u043c"
  ];
  if (loginMarkers.some((marker) => body.includes(marker))) return false;
  return String(title || "").toLowerCase().includes("max");
}