@toolstackhq/cdpwright 1.0.0

package/dist/chunk-6BPF3IEU.js

@@ -0,0 +1,1572 @@
+// src/assert/AssertionError.ts
+var AssertionError = class extends Error {
+  selector;
+  timeoutMs;
+  lastState;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "AssertionError";
+    this.selector = options.selector;
+    this.timeoutMs = options.timeoutMs;
+    this.lastState = options.lastState;
+  }
+};
+
+// src/core/Waiter.ts
+async function waitFor(predicate, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  const intervalMs = options.intervalMs ?? 100;
+  const start = Date.now();
+  let lastError;
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const result = await predicate();
+      if (result) {
+        return result;
+      }
+    } catch (err) {
+      lastError = err;
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+  const description = options.description ? ` (${options.description})` : "";
+  const error = new Error(`Timeout after ${timeoutMs}ms${description}`);
+  error.cause = lastError;
+  throw error;
+}
+
+// src/core/Page.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/core/Frame.ts
+import fs from "fs";
+import path from "path";
+
+// src/core/Selectors.ts
+function isXPathSelector(input) {
+  if (input.startsWith("/")) return true;
+  if (input.startsWith("./")) return true;
+  if (input.startsWith(".//")) return true;
+  if (input.startsWith("..")) return true;
+  if (input.startsWith("(")) {
+    const trimmed = input.trimStart();
+    if (trimmed.startsWith("(")) {
+      const inner = trimmed.slice(1).trimStart();
+      return inner.startsWith("/") || inner.startsWith(".");
+    }
+  }
+  return false;
+}
+function parseSelector(input) {
+  const value = input.trim();
+  const pierceShadowDom = value.includes(">>>");
+  return {
+    type: isXPathSelector(value) ? "xpath" : "css",
+    value,
+    pierceShadowDom
+  };
+}
+
+// src/core/ShadowDom.ts
+function getElementCtor(root) {
+  if (typeof Element !== "undefined") return Element;
+  const doc = root.ownerDocument;
+  const view = (doc || root).defaultView;
+  return view?.Element ?? null;
+}
+function isElementNode(node, ElementCtor) {
+  return node instanceof ElementCtor;
+}
+function nodeChildren(node) {
+  if (!("children" in node)) {
+    return [];
+  }
+  return Array.from(node.children);
+}
+function querySelectorDeep(root, selector) {
+  const ElementCtor = getElementCtor(root);
+  if (!ElementCtor) return null;
+  const elementCtor = ElementCtor;
+  function walk(node, sel, results2) {
+    if (isElementNode(node, elementCtor) && node.matches(sel)) {
+      results2.push(node);
+    }
+    if (isElementNode(node, elementCtor) && node.shadowRoot) {
+      walk(node.shadowRoot, sel, results2);
+    }
+    for (const child of nodeChildren(node)) {
+      walk(child, sel, results2);
+    }
+  }
+  function findAll(rootNode, sel) {
+    const results2 = [];
+    walk(rootNode, sel, results2);
+    return results2;
+  }
+  if (selector.includes(">>>")) {
+    const parts = selector.split(">>>").map((p) => p.trim()).filter(Boolean);
+    let scope = [root];
+    for (const part of parts) {
+      const matches = [];
+      for (const item of scope) {
+        matches.push(...findAll(item, part));
+      }
+      if (matches.length === 0) return null;
+      scope = matches;
+    }
+    return scope[0] ?? null;
+  }
+  const results = findAll(root, selector);
+  return results[0] ?? null;
+}
+function querySelectorAllDeep(root, selector) {
+  const ElementCtor = getElementCtor(root);
+  if (!ElementCtor) return [];
+  const elementCtor = ElementCtor;
+  function walk(node, sel, results) {
+    if (isElementNode(node, elementCtor) && node.matches(sel)) {
+      results.push(node);
+    }
+    if (isElementNode(node, elementCtor) && node.shadowRoot) {
+      walk(node.shadowRoot, sel, results);
+    }
+    for (const child of nodeChildren(node)) {
+      walk(child, sel, results);
+    }
+  }
+  function findAll(rootNode, sel) {
+    const results = [];
+    walk(rootNode, sel, results);
+    return results;
+  }
+  if (selector.includes(">>>")) {
+    const parts = selector.split(">>>").map((p) => p.trim()).filter(Boolean);
+    let scope = [root];
+    for (const part of parts) {
+      const matches = [];
+      for (const item of scope) {
+        matches.push(...findAll(item, part));
+      }
+      scope = matches;
+      if (scope.length === 0) return [];
+    }
+    return scope.filter((el) => el instanceof Element);
+  }
+  return findAll(root, selector);
+}
+function serializeShadowDomHelpers() {
+  return {
+    querySelectorDeep: querySelectorDeep.toString(),
+    querySelectorAllDeep: querySelectorAllDeep.toString()
+  };
+}
+
+// src/core/Locator.ts
+var Locator = class {
+  frame;
+  selector;
+  options;
+  constructor(frame, selector, options = {}) {
+    this.frame = frame;
+    this.selector = selector;
+    this.options = options;
+  }
+  async click(options = {}) {
+    return this.frame.click(this.selector, { ...this.options, ...options });
+  }
+  async dblclick(options = {}) {
+    return this.frame.dblclick(this.selector, { ...this.options, ...options });
+  }
+  async type(text, options = {}) {
+    return this.frame.type(this.selector, text, { ...this.options, ...options });
+  }
+  async exists() {
+    return this.frame.exists(this.selector, this.options);
+  }
+  async text() {
+    return this.frame.text(this.selector, this.options);
+  }
+};
+
+// src/core/Frame.ts
+var Frame = class {
+  id;
+  name;
+  url;
+  parentId;
+  session;
+  logger;
+  events;
+  contextId;
+  defaultTimeout = 3e4;
+  constructor(id, session, logger, events) {
+    this.id = id;
+    this.session = session;
+    this.logger = logger;
+    this.events = events;
+  }
+  setExecutionContext(contextId) {
+    this.contextId = contextId;
+  }
+  getExecutionContext() {
+    return this.contextId;
+  }
+  setMeta(meta) {
+    this.name = meta.name;
+    this.url = meta.url;
+    this.parentId = meta.parentId;
+  }
+  async evaluate(fnOrString, ...args) {
+    return this.evaluateInContext(fnOrString, args);
+  }
+  async query(selector, options = {}) {
+    return this.querySelectorInternal(selector, options, false);
+  }
+  async queryAll(selector, options = {}) {
+    return this.querySelectorAllInternal(selector, options, false);
+  }
+  async queryXPath(selector, options = {}) {
+    return this.querySelectorInternal(selector, options, true);
+  }
+  async queryAllXPath(selector, options = {}) {
+    return this.querySelectorAllInternal(selector, options, true);
+  }
+  locator(selector, options = {}) {
+    return new Locator(this, selector, options);
+  }
+  async click(selector, options = {}) {
+    await this.performClick(selector, options, false);
+  }
+  async dblclick(selector, options = {}) {
+    await this.performClick(selector, options, true);
+  }
+  async type(selector, text, options = {}) {
+    const start = Date.now();
+    const parsed = parseSelector(selector);
+    const pierce = Boolean(parsed.pierceShadowDom);
+    this.events.emit("action:start", { name: "type", selector, frameId: this.id, sensitive: options.sensitive });
+    await waitFor(async () => {
+      const box = await this.resolveElementBox(selector, options);
+      if (!box || !box.visible) {
+        return false;
+      }
+      return true;
+    }, { timeoutMs: options.timeoutMs ?? this.defaultTimeout, description: `type ${selector}` });
+    const helpers = serializeShadowDomHelpers();
+    const focusExpression = `(function() {
+      const querySelectorDeep = ${helpers.querySelectorDeep};
+      const root = document;
+      const selector = ${JSON.stringify(selector)};
+      const el = ${pierce ? "querySelectorDeep(root, selector)" : "root.querySelector(selector)"};
+      if (!el) {
+        return;
+      }
+      el.focus();
+    })()`;
+    const focusParams = {
+      expression: focusExpression,
+      returnByValue: true
+    };
+    if (this.contextId) {
+      focusParams.contextId = this.contextId;
+    }
+    await this.session.send("Runtime.evaluate", focusParams);
+    await this.session.send("Input.insertText", { text });
+    const duration = Date.now() - start;
+    this.events.emit("action:end", { name: "type", selector, frameId: this.id, durationMs: duration, sensitive: options.sensitive });
+    this.logger.debug("Type", selector, `${duration}ms`);
+  }
+  async typeSecure(selector, text, options = {}) {
+    return this.type(selector, text, { ...options, sensitive: true });
+  }
+  async fillInput(selector, value, options = {}) {
+    const start = Date.now();
+    this.events.emit("action:start", { name: "fillInput", selector, frameId: this.id });
+    await waitFor(async () => {
+      const expression = `(function() {
+        const selector = ${JSON.stringify(selector)};
+        const findDeep = (sel) => {
+          if (sel.includes(">>>")) {
+            const parts = sel.split(">>>").map((s) => s.trim()).filter(Boolean);
+            let scope = [document];
+            for (const part of parts) {
+              const next = [];
+              for (const node of scope) {
+                const roots = [node];
+                if (node instanceof Element && node.shadowRoot) roots.push(node.shadowRoot);
+                for (const root of roots) {
+                  next.push(...root.querySelectorAll(part));
+                }
+              }
+              if (!next.length) return null;
+              scope = next;
+            }
+            return scope[0] || null;
+          }
+          return document.querySelector(sel);
+        };
+        const el = findDeep(selector);
+        if (!el) return false;
+        if (!(el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement)) {
+          return false;
+        }
+        el.value = ${JSON.stringify(value)};
+        el.dispatchEvent(new Event("input", { bubbles: true }));
+        el.dispatchEvent(new Event("change", { bubbles: true }));
+        return true;
+      })()`;
+      const params = {
+        expression,
+        returnByValue: true
+      };
+      if (this.contextId) {
+        params.contextId = this.contextId;
+      }
+      const result = await this.session.send("Runtime.evaluate", params);
+      return Boolean(result.result?.value);
+    }, { timeoutMs: options.timeoutMs ?? this.defaultTimeout, description: `fillInput ${selector}` });
+    const duration = Date.now() - start;
+    this.events.emit("action:end", { name: "fillInput", selector, frameId: this.id, durationMs: duration });
+    this.logger.debug("FillInput", selector, `${duration}ms`);
+  }
+  async findLocators(options = {}) {
+    const start = Date.now();
+    this.events.emit("action:start", { name: "findLocators", frameId: this.id });
+    const artifactsDir = path.resolve(process.cwd(), "artifacts");
+    try {
+      fs.mkdirSync(artifactsDir, { recursive: true });
+    } catch {
+    }
+    const resolveOut = (name) => {
+      if (!name) return null;
+      const base = path.basename(name);
+      return path.join(artifactsDir, base);
+    };
+    const outputJson = resolveOut(options.outputJson || options.outputPath);
+    const outputHtml = resolveOut(options.outputHtml);
+    const expression = `(function() {
+      const highlight = ${options.highlight !== false};
+      const previous = Array.from(document.querySelectorAll(".__cdpwright-locator-overlay"));
+      previous.forEach((el) => el.remove());
+
+      const cssEscape = (value) => {
+        if (typeof CSS !== "undefined" && CSS.escape) return CSS.escape(value);
+        return value.replace(/[^a-zA-Z0-9_-]/g, (c) => "\\\\" + c.charCodeAt(0).toString(16) + " ");
+      };
+
+      const visible = (el) => {
+        const rect = el.getBoundingClientRect();
+        const style = window.getComputedStyle(el);
+        return rect.width > 0 && rect.height > 0 && style.visibility !== "hidden" && style.display !== "none" && Number(style.opacity || "1") > 0;
+      };
+
+      const siblingsIndex = (el) => {
+        if (!el.parentElement) return 1;
+        const sibs = Array.from(el.parentElement.children).filter((n) => n.tagName === el.tagName);
+        return sibs.indexOf(el) + 1;
+      };
+
+      const xpathFor = (el) => {
+        const parts = [];
+        let node = el;
+        while (node && node.nodeType === 1 && node !== document.documentElement) {
+          const idx = siblingsIndex(node);
+          parts.unshift(node.tagName.toLowerCase() + "[" + idx + "]");
+          node = node.parentElement;
+        }
+        return "//" + parts.join("/");
+      };
+
+      const buildLocator = (el) => {
+        const testid = el.getAttribute("data-testid");
+        const id = el.id;
+        const name = el.getAttribute("name");
+        const aria = el.getAttribute("aria-label");
+        const labelledBy = el.getAttribute("aria-labelledby");
+        const placeholder = el.getAttribute("placeholder");
+        const role = el.getAttribute("role");
+        const labelText = (() => {
+          if (labelledBy) {
+            const ref = document.getElementById(labelledBy);
+            if (ref) return ref.textContent?.trim() || "";
+          }
+          if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement) {
+            const idRef = el.id && document.querySelector("label[for='" + el.id.replace(/'/g, "\\\\'") + "']");
+            if (idRef) return idRef.textContent?.trim() || "";
+            const wrap = el.closest("label");
+            if (wrap) return wrap.textContent?.trim() || "";
+          }
+          return "";
+        })();
+
+        let css = "";
+        let quality = "low";
+        let reason = "fallback";
+        if (testid) {
+          css = "[data-testid="" + testid.replace(/"/g, '\\\\"') + ""]";
+          quality = "high";
+          reason = "data-testid";
+        } else if (id) {
+          css = "#" + cssEscape(id);
+          quality = "high";
+          reason = "id";
+        } else if (name) {
+          css = "[name="" + name.replace(/"/g, '\\\\"') + ""]";
+          quality = "ok";
+          reason = "name";
+        } else if (aria) {
+          css = "[aria-label="" + aria.replace(/"/g, '\\\\"') + ""]";
+          quality = "ok";
+          reason = "aria-label";
+        } else if (placeholder) {
+          css = "[placeholder="" + placeholder.replace(/"/g, '\\\\"') + ""]";
+          quality = "low";
+          reason = "placeholder";
+        } else if (labelText) {
+          css = el.tagName.toLowerCase() + "[aria-label="" + labelText.replace(/"/g, '\\\\"') + ""]";
+          quality = "low";
+          reason = "label text";
+        } else {
+          const nth = siblingsIndex(el);
+          css = el.tagName.toLowerCase() + ":nth-of-type(" + nth + ")";
+          quality = "low";
+          reason = "nth-of-type";
+        }
+
+        const tag = el.tagName.toLowerCase();
+        const type = el.getAttribute("type") || "";
+        const text = (el.textContent || "").trim().slice(0, 80);
+
+        return {
+          name: labelText || aria || placeholder || name || testid || id || tag,
+          css,
+          xpath: xpathFor(el),
+          quality,
+          reason,
+          visible: true,
+          tag,
+          type,
+          role,
+          text,
+          id,
+          nameAttr: name,
+          dataTestid: testid
+        };
+      };
+
+        const preferredSelectors = ["input", "select", "textarea", "button", "a[href]", "[role='button']", "[contenteditable='true']", "h1", "h2", "h3", "h4", "h5", "h6", "label", "legend", "fieldset"];
+        let nodes = Array.from(document.querySelectorAll(preferredSelectors.join(", ")));
+        if (nodes.length === 0) {
+          nodes = Array.from(document.querySelectorAll("*")).filter((el) => {
+            if (!(el instanceof HTMLElement)) return false;
+            const tag = el.tagName.toLowerCase();
+            if (preferredSelectors.includes(tag)) return true;
+            if (tag === "a" && el.hasAttribute("href")) return true;
+            if (el.getAttribute("role") === "button") return true;
+            if (el.hasAttribute("contenteditable")) return true;
+            return false;
+          });
+        }
+      const results = [];
+      nodes.forEach((el) => {
+        const isVisible = visible(el);
+        const locator = buildLocator(el);
+        locator.visible = isVisible;
+        results.push(locator);
+      });
+
+      if (highlight) {
+        results.forEach((loc, index) => {
+          const el = nodes[index];
+          if (!el) return;
+          const rect = el.getBoundingClientRect();
+          const overlay = document.createElement("div");
+          overlay.className = "__cdpwright-locator-overlay";
+          overlay.style.position = "absolute";
+          overlay.style.left = rect.x + window.scrollX + "px";
+          overlay.style.top = rect.y + window.scrollY + "px";
+          overlay.style.width = rect.width + "px";
+          overlay.style.height = rect.height + "px";
+          overlay.style.border = "2px solid #e67e22";
+          overlay.style.borderRadius = "6px";
+          overlay.style.pointerEvents = "none";
+          overlay.style.zIndex = "99999";
+          const badge = document.createElement("div");
+          badge.textContent = String(index);
+          badge.style.position = "absolute";
+          badge.style.top = "-10px";
+          badge.style.left = "-10px";
+          badge.style.background = "#e67e22";
+          badge.style.color = "#fff";
+          badge.style.fontSize = "12px";
+          badge.style.padding = "2px 6px";
+          badge.style.borderRadius = "10px";
+          overlay.appendChild(badge);
+          document.body.appendChild(overlay);
+        });
+      }
+
+      if (console && console.table) {
+        console.table(results.map((r, idx) => ({ idx, name: r.name, css: r.css, quality: r.quality, reason: r.reason, tag: r.tag, type: r.type })));
+      }
+      return results;
+    })()`;
+    const params = {
+      expression,
+      returnByValue: true
+    };
+    if (this.contextId) {
+      params.contextId = this.contextId;
+    }
+    let result = await this.session.send("Runtime.evaluate", params);
+    const duration = Date.now() - start;
+    this.events.emit("action:end", { name: "findLocators", frameId: this.id, durationMs: duration });
+    const value = result.result?.value ?? [];
+    if (Array.isArray(value) && value.length > 0) {
+      this.logger.info("FindLocators", `${value.length} candidates`, value.slice(0, 5).map((v) => v.css || v.name || v.tag));
+      if (outputJson) {
+        try {
+          fs.writeFileSync(outputJson, JSON.stringify(value, null, 2), "utf-8");
+          this.logger.info("FindLocators", `written to ${outputJson}`);
+        } catch (err) {
+          this.logger.warn("FindLocators write failed", err);
+        }
+      }
+      if (outputHtml) {
+        this.writeLocatorHtml(outputHtml, value);
+      }
+      return value;
+    }
+    result = await this.session.send("Runtime.evaluate", {
+      expression: `(function() {
+        const allowed = ["input","select","textarea","button","a","label","legend","fieldset","h1","h2","h3","h4","h5","h6"];
+        const skip = ["html","head","body","meta","link","script","style"];
+        return Array.from(document.querySelectorAll("*"))
+          .filter((el) => {
+            if (!(el instanceof HTMLElement)) return false;
+            const tag = el.tagName.toLowerCase();
+            if (skip.includes(tag)) return false;
+            if (tag === "a" && el.hasAttribute("href")) return true;
+            if (el.getAttribute("role") === "button") return true;
+            if (el.hasAttribute("contenteditable")) return true;
+            return allowed.includes(tag);
+          })
+          .slice(0, 200)
+          .map((el, idx) => ({
+            name: el.getAttribute("aria-label") || el.getAttribute("name") || el.getAttribute("data-testid") || el.id || el.tagName.toLowerCase() + "-" + idx,
+            css: el.id ? "#" + el.id : el.getAttribute("data-testid") ? "[data-testid=\\"" + el.getAttribute("data-testid") + "\\"]" : el.tagName.toLowerCase(),
+            xpath: "",
+            quality: "low",
+            reason: "fallback",
+            visible: true,
+            tag: el.tagName.toLowerCase(),
+            type: el.getAttribute("type") || "",
+            role: el.getAttribute("role") || ""
+          }));
+      })()`,
+      returnByValue: true
+    });
+    const fallback = result.result?.value ?? [];
+    this.logger.info("FindLocators", `${fallback.length} candidates`, fallback.slice(0, 5).map((v) => v.css || v.name || v.tag));
+    if (outputJson) {
+      try {
+        fs.writeFileSync(outputJson, JSON.stringify(fallback, null, 2), "utf-8");
+        this.logger.info("FindLocators", `written to ${outputJson}`);
+      } catch (err) {
+        this.logger.warn("FindLocators write failed", err);
+      }
+    }
+    if (outputHtml) {
+      this.writeLocatorHtml(outputHtml, fallback);
+    }
+    return fallback;
+  }
+  writeLocatorHtml(filePath, data) {
+    const html = `<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <title>Locators</title>
+  <style>
+    body { font-family: "Segoe UI", system-ui, -apple-system, sans-serif; padding: 16px; background: #f8f9fa; color: #222; }
+    h1 { font-size: 20px; margin-bottom: 12px; }
+    table { border-collapse: collapse; width: 100%; background: #fff; box-shadow: 0 2px 6px rgba(0,0,0,0.08); }
+    th, td { border: 1px solid #e5e7eb; padding: 8px; font-size: 13px; text-align: left; }
+    th { background: linear-gradient(180deg, #f6f7fb, #edf0f7); font-weight: 600; }
+    tr:nth-child(even) { background: #fafbfc; }
+    .copy { color: #2563eb; text-decoration: underline dotted; cursor: pointer; font-size: 12px; background: none; border: none; padding: 0; opacity: 0; transition: opacity 0.15s ease; }
+    tr:hover .copy { opacity: 1; }
+    .copy:hover { color: #1d4ed8; }
+    .loc-value { margin-left: 6px; font-family: ui-monospace, SFMono-Regular, SFMono, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace; }
+  </style>
+</head>
+<body>
+  <h1>Locator candidates</h1>
+  <table>
+    <thead>
+      <tr><th>#</th><th>Name</th><th>CSS</th><th>XPath</th><th>Quality</th><th>Reason</th><th>Visible</th></tr>
+    </thead>
+    <tbody id="rows"></tbody>
+  </table>
+  <script>
+    const data = ${JSON.stringify(data)};
+    const rows = document.getElementById("rows");
+    data.forEach((loc, idx) => {
+      const tr = document.createElement("tr");
+      const cells = [
+        idx,
+        loc.name || "",
+        loc.css || "",
+        loc.xpath || "",
+        loc.quality || "",
+        loc.reason || "",
+        String(loc.visible)
+      ];
+      cells.forEach((val, i) => {
+        const td = document.createElement("td");
+        if (i === 2 || i === 3) {
+          const link = document.createElement("button");
+          link.className = "copy";
+          link.textContent = "copy";
+          link.addEventListener("click", async (e) => {
+            e.preventDefault();
+            try { await navigator.clipboard.writeText(val); link.textContent = "copied"; setTimeout(() => link.textContent = "copy", 1000); }
+            catch { link.textContent = "error"; }
+          });
+          const span = document.createElement("span");
+          span.className = "loc-value";
+          span.textContent = val;
+          td.appendChild(link);
+          td.appendChild(span);
+        } else {
+          td.textContent = val;
+        }
+        tr.appendChild(td);
+      });
+      rows.appendChild(tr);
+    });
+  </script>
+</body>
+</html>`;
+    try {
+      fs.writeFileSync(filePath, html, "utf-8");
+      this.logger.info("FindLocators", `HTML written to ${filePath}`);
+    } catch (err) {
+      this.logger.warn("FindLocators HTML write failed", err);
+    }
+  }
+  async exists(selector, options = {}) {
+    const handle = await this.query(selector, options);
+    if (handle) {
+      await this.releaseObject(handle.objectId);
+      return true;
+    }
+    return false;
+  }
+  async isVisible(selector, options = {}) {
+    const box = await this.resolveElementBox(selector, options);
+    return Boolean(box && box.visible);
+  }
+  async text(selector, options = {}) {
+    return this.evalOnSelector(selector, options, false, `
+      if (!el) {
+        return null;
+      }
+      return el.textContent || "";
+    `);
+  }
+  async textSecure(selector, options = {}) {
+    const start = Date.now();
+    this.events.emit("action:start", { name: "text", selector, frameId: this.id, sensitive: true });
+    const result = await this.text(selector, options);
+    const duration = Date.now() - start;
+    this.events.emit("action:end", { name: "text", selector, frameId: this.id, durationMs: duration, sensitive: true });
+    return result;
+  }
+  async selectOption(selector, value) {
+    await this.evaluate(
+      (sel, val) => {
+        const el = document.querySelector(sel);
+        if (!(el instanceof HTMLSelectElement)) return false;
+        el.value = val;
+        el.dispatchEvent(new Event("input", { bubbles: true }));
+        el.dispatchEvent(new Event("change", { bubbles: true }));
+        return true;
+      },
+      selector,
+      value
+    );
+  }
+  async setFileInput(selector, name, contents, options = {}) {
+    await this.evaluate(
+      (sel, fileName, text, mime) => {
+        const input = document.querySelector(sel);
+        if (!(input instanceof HTMLInputElement)) return false;
+        const file = new File([text], fileName, { type: mime || "text/plain" });
+        const data = new DataTransfer();
+        data.items.add(file);
+        input.files = data.files;
+        input.dispatchEvent(new Event("input", { bubbles: true }));
+        input.dispatchEvent(new Event("change", { bubbles: true }));
+        return true;
+      },
+      selector,
+      name,
+      contents,
+      options.mimeType || "text/plain"
+    );
+  }
+  async attribute(selector, name, options = {}) {
+    return this.evalOnSelector(selector, options, false, `
+      if (!el || !(el instanceof Element)) {
+        return null;
+      }
+      return el.getAttribute(${JSON.stringify(name)});
+    `);
+  }
+  async value(selector, options = {}) {
+    return this.evalOnSelector(selector, options, false, `
+      if (!el) {
+        return null;
+      }
+      if ("value" in el) {
+        return el.value ?? "";
+      }
+      return el.getAttribute("value");
+    `);
+  }
+  async valueSecure(selector, options = {}) {
+    const start = Date.now();
+    this.events.emit("action:start", { name: "value", selector, frameId: this.id, sensitive: true });
+    const result = await this.value(selector, options);
+    const duration = Date.now() - start;
+    this.events.emit("action:end", { name: "value", selector, frameId: this.id, durationMs: duration, sensitive: true });
+    return result;
+  }
+  async isEnabled(selector, options = {}) {
+    return this.evalOnSelector(selector, options, false, `
+      if (!el) {
+        return null;
+      }
+      const disabled = Boolean(el.disabled) || el.hasAttribute("disabled");
+      const ariaDisabled = el.getAttribute && el.getAttribute("aria-disabled") === "true";
+      return !(disabled || ariaDisabled);
+    `);
+  }
+  async isChecked(selector, options = {}) {
+    return this.evalOnSelector(selector, options, false, `
+      if (!el) {
+        return null;
+      }
+      const aria = el.getAttribute && el.getAttribute("aria-checked");
+      if (aria === "true") {
+        return true;
+      }
+      if (aria === "false") {
+        return false;
+      }
+      if ("checked" in el) {
+        return Boolean(el.checked);
+      }
+      return null;
+    `);
+  }
+  async count(selector, options = {}) {
+    const parsed = parseSelector(selector);
+    const pierce = Boolean(parsed.pierceShadowDom);
+    const helpers = serializeShadowDomHelpers();
+    const expression = parsed.type === "xpath" ? `(function() {
+          const result = document.evaluate(${JSON.stringify(parsed.value)}, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+          return result.snapshotLength;
+        })()` : `(function() {
+          const querySelectorAllDeep = ${helpers.querySelectorAllDeep};
+          const root = document;
+          const selector = ${JSON.stringify(parsed.value)};
+          const nodes = ${pierce ? "querySelectorAllDeep(root, selector)" : "root.querySelectorAll(selector)"};
+          return nodes.length;
+        })()`;
+    const params = {
+      expression,
+      returnByValue: true
+    };
+    if (this.contextId) {
+      params.contextId = this.contextId;
+    }
+    const result = await this.session.send("Runtime.evaluate", params);
+    return result.result.value ?? 0;
+  }
+  async classes(selector, options = {}) {
+    return this.evalOnSelector(selector, options, false, `
+      if (!el) {
+        return null;
+      }
+      if (!el.classList) {
+        return [];
+      }
+      return Array.from(el.classList);
+    `);
+  }
+  async css(selector, property, options = {}) {
+    return this.evalOnSelector(selector, options, false, `
+      if (!el) {
+        return null;
+      }
+      const style = window.getComputedStyle(el);
+      return style.getPropertyValue(${JSON.stringify(property)}) || "";
+    `);
+  }
+  async hasFocus(selector, options = {}) {
+    return this.evalOnSelector(selector, options, false, `
+      if (!el) {
+        return null;
+      }
+      return document.activeElement === el;
+    `);
+  }
+  async isInViewport(selector, options = {}, fully = false) {
+    return this.evalOnSelector(selector, options, false, `
+      if (!el) {
+        return null;
+      }
+      const rect = el.getBoundingClientRect();
+      const viewWidth = window.innerWidth || document.documentElement.clientWidth;
+      const viewHeight = window.innerHeight || document.documentElement.clientHeight;
+      if (${fully ? "true" : "false"}) {
+        return rect.top >= 0 && rect.left >= 0 && rect.bottom <= viewHeight && rect.right <= viewWidth;
+      }
+      return rect.bottom > 0 && rect.right > 0 && rect.top < viewHeight && rect.left < viewWidth;
+    `);
+  }
+  async isEditable(selector, options = {}) {
+    return this.evalOnSelector(selector, options, false, `
+      if (!el) {
+        return null;
+      }
+      const disabled = Boolean(el.disabled) || el.hasAttribute("disabled");
+      const readOnly = Boolean(el.readOnly) || el.hasAttribute("readonly");
+      const ariaDisabled = el.getAttribute && el.getAttribute("aria-disabled") === "true";
+      return !(disabled || readOnly || ariaDisabled);
+    `);
+  }
+  async performClick(selector, options, isDouble) {
+    const start = Date.now();
+    const actionName = isDouble ? "dblclick" : "click";
+    this.events.emit("action:start", { name: actionName, selector, frameId: this.id });
+    const box = await waitFor(async () => {
+      const result = await this.resolveElementBox(selector, options);
+      if (!result || !result.visible) {
+        return null;
+      }
+      return result;
+    }, { timeoutMs: options.timeoutMs ?? this.defaultTimeout, description: `${actionName} ${selector}` });
+    const centerX = box.x + box.width / 2;
+    const centerY = box.y + box.height / 2;
+    await this.session.send("Input.dispatchMouseEvent", { type: "mouseMoved", x: centerX, y: centerY });
+    await this.session.send("Input.dispatchMouseEvent", { type: "mousePressed", x: centerX, y: centerY, button: "left", clickCount: 1, buttons: 1 });
+    await this.session.send("Input.dispatchMouseEvent", { type: "mouseReleased", x: centerX, y: centerY, button: "left", clickCount: 1, buttons: 0 });
+    if (isDouble) {
+      await this.session.send("Input.dispatchMouseEvent", { type: "mouseMoved", x: centerX, y: centerY });
+      await this.session.send("Input.dispatchMouseEvent", { type: "mousePressed", x: centerX, y: centerY, button: "left", clickCount: 2, buttons: 1 });
+      await this.session.send("Input.dispatchMouseEvent", { type: "mouseReleased", x: centerX, y: centerY, button: "left", clickCount: 2, buttons: 0 });
+    }
+    const duration = Date.now() - start;
+    this.events.emit("action:end", { name: actionName, selector, frameId: this.id, durationMs: duration });
+    this.logger.debug("Click", selector, `${duration}ms`);
+  }
+  async resolveElementBox(selector, options) {
+    const parsed = parseSelector(selector);
+    const pierce = Boolean(parsed.pierceShadowDom);
+    const helpers = serializeShadowDomHelpers();
+    const expression = parsed.type === "xpath" ? `(function() {
+          const result = document.evaluate(${JSON.stringify(parsed.value)}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+          if (!result || !(result instanceof Element)) {
+            return null;
+          }
+          result.scrollIntoView({ block: 'center', inline: 'center' });
+          const rect = result.getBoundingClientRect();
+          const style = window.getComputedStyle(result);
+          return { x: rect.x, y: rect.y, width: rect.width, height: rect.height, visible: rect.width > 0 && rect.height > 0 && style.visibility !== 'hidden' && style.display !== 'none' && Number(style.opacity || '1') > 0 };
+        })()` : `(function() {
+          const querySelectorDeep = ${helpers.querySelectorDeep};
+          const root = document;
+          const selector = ${JSON.stringify(parsed.value)};
+          const el = ${pierce ? "querySelectorDeep(root, selector)" : "root.querySelector(selector)"};
+          if (!el) {
+            return null;
+          }
+          el.scrollIntoView({ block: 'center', inline: 'center' });
+          const rect = el.getBoundingClientRect();
+          const style = window.getComputedStyle(el);
+          return { x: rect.x, y: rect.y, width: rect.width, height: rect.height, visible: rect.width > 0 && rect.height > 0 && style.visibility !== 'hidden' && style.display !== 'none' && Number(style.opacity || '1') > 0 };
+        })()`;
+    const boxParams = {
+      expression,
+      returnByValue: true
+    };
+    if (this.contextId) {
+      boxParams.contextId = this.contextId;
+    }
+    const result = await this.session.send("Runtime.evaluate", boxParams);
+    return result?.result?.value ?? null;
+  }
+  async querySelectorInternal(selector, options, forceXPath) {
+    const parsed = forceXPath ? { type: "xpath", value: selector.trim(), pierceShadowDom: void 0 } : parseSelector(selector);
+    const pierce = Boolean(parsed.pierceShadowDom);
+    const helpers = serializeShadowDomHelpers();
+    const expression = parsed.type === "xpath" ? `(function() {
+          const result = document.evaluate(${JSON.stringify(parsed.value)}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+          return result || null;
+        })()` : `(function() {
+          const querySelectorDeep = ${helpers.querySelectorDeep};
+          const root = document;
+          const selector = ${JSON.stringify(parsed.value)};
+          return ${pierce ? "querySelectorDeep(root, selector)" : "root.querySelector(selector)"};
+        })()`;
+    const queryParams = {
+      expression,
+      returnByValue: false
+    };
+    if (this.contextId) {
+      queryParams.contextId = this.contextId;
+    }
+    const response = await this.session.send("Runtime.evaluate", queryParams);
+    if (response.result?.subtype === "null" || !response.result?.objectId) {
+      return null;
+    }
+    return { objectId: response.result.objectId, contextId: this.contextId ?? 0 };
+  }
+  async querySelectorAllInternal(selector, options, forceXPath) {
+    const parsed = forceXPath ? { type: "xpath", value: selector.trim(), pierceShadowDom: void 0 } : parseSelector(selector);
+    const pierce = Boolean(parsed.pierceShadowDom);
+    const helpers = serializeShadowDomHelpers();
+    const expression = parsed.type === "xpath" ? `(function() {
+          const result = document.evaluate(${JSON.stringify(parsed.value)}, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+          const nodes = [];
+          for (let i = 0; i < result.snapshotLength; i += 1) {
+            nodes.push(result.snapshotItem(i));
+          }
+          return nodes;
+        })()` : `(function() {
+          const querySelectorAllDeep = ${helpers.querySelectorAllDeep};
+          const root = document;
+          const selector = ${JSON.stringify(parsed.value)};
+          return ${pierce ? "querySelectorAllDeep(root, selector)" : "Array.from(root.querySelectorAll(selector))"};
+        })()`;
+    const listParams = {
+      expression,
+      returnByValue: false
+    };
+    if (this.contextId) {
+      listParams.contextId = this.contextId;
+    }
+    const response = await this.session.send("Runtime.evaluate", listParams);
+    if (!response.result?.objectId) {
+      return [];
+    }
+    const properties = await this.session.send("Runtime.getProperties", {
+      objectId: response.result.objectId,
+      ownProperties: true
+    });
+    const handles = [];
+    for (const prop of properties.result) {
+      if (prop.name && !/^\d+$/.test(prop.name)) {
+        continue;
+      }
+      const objectId = prop.value?.objectId;
+      if (objectId) {
+        handles.push({ objectId, contextId: this.contextId ?? 0 });
+      }
+    }
+    await this.releaseObject(response.result.objectId);
+    return handles;
+  }
+  async evaluateInContext(fnOrString, args) {
+    if (typeof fnOrString === "string") {
+      const params2 = {
+        expression: fnOrString,
+        returnByValue: true,
+        awaitPromise: true
+      };
+      if (this.contextId) {
+        params2.contextId = this.contextId;
+      }
+      const result2 = await this.session.send("Runtime.evaluate", params2);
+      return result2.result.value;
+    }
+    const serializedArgs = args.map((arg) => serializeArgument(arg)).join(", ");
+    const expression = `(${fnOrString.toString()})(${serializedArgs})`;
+    const params = {
+      expression,
+      returnByValue: true,
+      awaitPromise: true
+    };
+    if (this.contextId) {
+      params.contextId = this.contextId;
+    }
+    const result = await this.session.send("Runtime.evaluate", params);
+    return result.result.value;
+  }
+  async releaseObject(objectId) {
+    try {
+      await this.session.send("Runtime.releaseObject", { objectId });
+    } catch {
+    }
+  }
+  buildElementExpression(selector, options, forceXPath, body) {
+    const parsed = forceXPath ? { type: "xpath", value: selector.trim(), pierceShadowDom: void 0 } : parseSelector(selector);
+    const pierce = options.pierceShadowDom ?? Boolean(parsed.pierceShadowDom);
+    const helpers = serializeShadowDomHelpers();
+    if (parsed.type === "xpath") {
+      return `(function() {
+        const el = document.evaluate(${JSON.stringify(parsed.value)}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+        ${body}
+      })()`;
+    }
+    return `(function() {
+      const querySelectorDeep = ${helpers.querySelectorDeep};
+      const root = document;
+      const selector = ${JSON.stringify(parsed.value)};
+      const el = ${pierce ? "querySelectorDeep(root, selector)" : "root.querySelector(selector)"};
+      ${body}
+    })()`;
+  }
+  async evalOnSelector(selector, options, forceXPath, body) {
+    const expression = this.buildElementExpression(selector, options, forceXPath, body);
+    const params = {
+      expression,
+      returnByValue: true
+    };
+    if (this.contextId) {
+      params.contextId = this.contextId;
+    }
+    const result = await this.session.send("Runtime.evaluate", params);
+    return result.result.value;
+  }
+};
+function serializeArgument(value) {
+  if (value === void 0) {
+    return "undefined";
+  }
+  return JSON.stringify(value);
+}
+
+// src/core/UrlGuard.ts
+function ensureAllowedUrl(url, options = {}) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error(`Invalid URL: ${url}`);
+  }
+  if (parsed.protocol === "http:" || parsed.protocol === "https:") {
+    return;
+  }
+  if (parsed.protocol === "file:" && options.allowFileUrl) {
+    return;
+  }
+  throw new Error(`URL protocol not allowed: ${parsed.protocol}`);
+}
+
+// src/core/Page.ts
+var Page = class {
+  session;
+  logger;
+  events;
+  framesById = /* @__PURE__ */ new Map();
+  mainFrameId;
+  lifecycleEvents = /* @__PURE__ */ new Map();
+  defaultTimeout = 3e4;
+  constructor(session, logger, events) {
+    this.session = session;
+    this.logger = logger;
+    this.events = events;
+  }
+  async initialize() {
+    await this.session.send("Page.enable");
+    await this.session.send("DOM.enable");
+    await this.session.send("Runtime.enable");
+    await this.session.send("Network.enable");
+    await this.session.send("Page.setLifecycleEventsEnabled", { enabled: true });
+    this.session.on("Page.frameAttached", (params) => this.onFrameAttached(params));
+    this.session.on("Page.frameNavigated", (params) => this.onFrameNavigated(params));
+    this.session.on("Page.frameDetached", (params) => this.onFrameDetached(params));
+    this.session.on("Runtime.executionContextCreated", (params) => this.onExecutionContextCreated(params));
+    this.session.on("Runtime.executionContextDestroyed", (params) => this.onExecutionContextDestroyed(params));
+    this.session.on("Runtime.executionContextsCleared", () => this.onExecutionContextsCleared());
+    this.session.on("Page.lifecycleEvent", (params) => this.onLifecycleEvent(params));
+    const tree = await this.session.send("Page.getFrameTree");
+    this.buildFrameTree(tree.frameTree);
+  }
+  frames() {
+    return Array.from(this.framesById.values());
+  }
+  mainFrame() {
+    if (!this.mainFrameId) {
+      throw new Error("Main frame not initialized");
+    }
+    const frame = this.framesById.get(this.mainFrameId);
+    if (!frame) {
+      throw new Error("Main frame missing");
+    }
+    return frame;
+  }
+  frame(options) {
+    for (const frame of this.framesById.values()) {
+      if (options.name && frame.name !== options.name) continue;
+      if (options.urlIncludes && !frame.url?.includes(options.urlIncludes)) continue;
+      if (options.predicate && !options.predicate(frame)) continue;
+      return frame;
+    }
+    return null;
+  }
+  locator(selector) {
+    return new Locator(this.mainFrame(), selector);
+  }
+  async goto(url, options = {}) {
+    ensureAllowedUrl(url, { allowFileUrl: options.allowFileUrl });
+    const waitUntil = options.waitUntil ?? "load";
+    const lifecycleName = waitUntil === "domcontentloaded" ? "DOMContentLoaded" : waitUntil === "load" ? "load" : null;
+    if (!lifecycleName) {
+      throw new Error(`Invalid waitUntil "${waitUntil}". Use "load" or "domcontentloaded".`);
+    }
+    const timeoutMs = options.timeoutMs ?? this.defaultTimeout;
+    this.events.emit("action:start", { name: "goto", selector: url, frameId: this.mainFrameId });
+    const start = Date.now();
+    this.lifecycleEvents.clear();
+    const navigation = await this.session.send("Page.navigate", { url });
+    if (navigation?.errorText) {
+      throw new Error(`Navigation failed: ${navigation.errorText}`);
+    }
+    await this.waitForLifecycle(this.mainFrameId, lifecycleName, timeoutMs);
+    const duration = Date.now() - start;
+    this.events.emit("action:end", { name: "goto", selector: url, frameId: this.mainFrameId, durationMs: duration });
+    this.logger.debug("Goto", url, `${duration}ms`);
+  }
+  async query(selector) {
+    return this.mainFrame().query(selector);
+  }
+  async queryAll(selector) {
+    return this.mainFrame().queryAll(selector);
+  }
+  async queryXPath(selector) {
+    return this.mainFrame().queryXPath(selector);
+  }
+  async queryAllXPath(selector) {
+    return this.mainFrame().queryAllXPath(selector);
+  }
+  async click(selector, options) {
+    return this.mainFrame().click(selector, options);
+  }
+  async dblclick(selector, options) {
+    return this.mainFrame().dblclick(selector, options);
+  }
+  async type(selector, text, options) {
+    return this.mainFrame().type(selector, text, options);
+  }
+  async typeSecure(selector, text, options) {
+    return this.mainFrame().typeSecure(selector, text, options);
+  }
+  async fillInput(selector, value, options = {}) {
+    return this.mainFrame().fillInput(selector, value, options);
+  }
+  async evaluate(fnOrString, ...args) {
+    return this.mainFrame().evaluate(fnOrString, ...args);
+  }
+  async textSecure(selector) {
+    return this.mainFrame().textSecure(selector);
+  }
+  async valueSecure(selector) {
+    return this.mainFrame().valueSecure(selector);
+  }
+  async selectOption(selector, value) {
+    return this.mainFrame().selectOption(selector, value);
+  }
+  async setFileInput(selector, name, contents, options = {}) {
+    return this.mainFrame().setFileInput(selector, name, contents, options);
+  }
+  async findLocators(options = {}) {
+    return this.mainFrame().findLocators(options);
+  }
+  async screenshot(options = {}) {
+    const start = Date.now();
+    this.events.emit("action:start", { name: "screenshot", frameId: this.mainFrameId });
+    const result = await this.session.send("Page.captureScreenshot", {
+      format: options.format ?? "png",
+      quality: options.quality,
+      fromSurface: true
+    });
+    const buffer = Buffer.from(result.data, "base64");
+    if (options.path) {
+      const resolved = path2.resolve(options.path);
+      fs2.writeFileSync(resolved, buffer);
+    }
+    const duration = Date.now() - start;
+    this.events.emit("action:end", { name: "screenshot", frameId: this.mainFrameId, durationMs: duration });
+    return buffer;
+  }
+  async screenshotBase64(options = {}) {
+    const start = Date.now();
+    this.events.emit("action:start", { name: "screenshotBase64", frameId: this.mainFrameId });
+    const result = await this.session.send("Page.captureScreenshot", {
+      format: options.format ?? "png",
+      quality: options.quality,
+      fromSurface: true
+    });
+    const duration = Date.now() - start;
+    this.events.emit("action:end", { name: "screenshotBase64", frameId: this.mainFrameId, durationMs: duration });
+    return result.data;
+  }
+  getEvents() {
+    return this.events;
+  }
+  getDefaultTimeout() {
+    return this.defaultTimeout;
+  }
+  buildFrameTree(tree) {
+    const frame = this.ensureFrame(tree.frame.id);
+    frame.setMeta({ name: tree.frame.name, url: tree.frame.url, parentId: tree.frame.parentId });
+    if (!tree.frame.parentId) {
+      this.mainFrameId = tree.frame.id;
+    }
+    if (tree.childFrames) {
+      for (const child of tree.childFrames) {
+        this.buildFrameTree(child);
+      }
+    }
+  }
+  ensureFrame(id) {
+    let frame = this.framesById.get(id);
+    if (!frame) {
+      frame = new Frame(id, this.session, this.logger, this.events);
+      this.framesById.set(id, frame);
+    }
+    return frame;
+  }
+  onFrameAttached(params) {
+    const frame = this.ensureFrame(params.frameId);
+    frame.setMeta({ parentId: params.parentFrameId });
+  }
+  onFrameNavigated(params) {
+    const frame = this.ensureFrame(params.frame.id);
+    frame.setMeta({ name: params.frame.name, url: params.frame.url, parentId: params.frame.parentId });
+    if (!params.frame.parentId) {
+      this.mainFrameId = params.frame.id;
+    }
+  }
+  onFrameDetached(params) {
+    this.framesById.delete(params.frameId);
+  }
+  onExecutionContextCreated(params) {
+    const frameId = params.context.auxData?.frameId;
+    if (!frameId) {
+      return;
+    }
+    const frame = this.ensureFrame(frameId);
+    frame.setExecutionContext(params.context.id);
+  }
+  onExecutionContextDestroyed(params) {
+    for (const frame of this.framesById.values()) {
+      if (frame.getExecutionContext() === params.executionContextId) {
+        frame.setExecutionContext(void 0);
+      }
+    }
+  }
+  onExecutionContextsCleared() {
+    for (const frame of this.framesById.values()) {
+      frame.setExecutionContext(void 0);
+    }
+  }
+  onLifecycleEvent(params) {
+    if (!this.lifecycleEvents.has(params.frameId)) {
+      this.lifecycleEvents.set(params.frameId, /* @__PURE__ */ new Set());
+    }
+    this.lifecycleEvents.get(params.frameId).add(params.name);
+  }
+  async waitForLifecycle(frameId, eventName, timeoutMs) {
+    if (!frameId) {
+      throw new Error("Missing frame id for lifecycle wait");
+    }
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      const events = this.lifecycleEvents.get(frameId);
+      if (events && events.has(eventName)) {
+        return;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    throw new Error(`Timeout waiting for lifecycle event: ${eventName}`);
+  }
+};
+
+// src/assert/expect.ts
+var ElementExpectation = class _ElementExpectation {
+  frame;
+  selector;
+  options;
+  negate;
+  events;
+  constructor(frame, selector, options, negate, events) {
+    this.frame = frame;
+    this.selector = selector;
+    this.options = options;
+    this.negate = negate;
+    this.events = events;
+  }
+  get not() {
+    return new _ElementExpectation(this.frame, this.selector, this.options, !this.negate, this.events);
+  }
+  async toExist() {
+    return this.assert(async () => {
+      const exists = await this.frame.exists(this.selector, this.options);
+      return this.negate ? !exists : exists;
+    }, this.negate ? "Expected element not to exist" : "Expected element to exist");
+  }
+  async toBeVisible() {
+    return this.assert(async () => {
+      const visible = await this.frame.isVisible(this.selector, this.options);
+      return this.negate ? !visible : visible;
+    }, this.negate ? "Expected element not to be visible" : "Expected element to be visible");
+  }
+  async toBeHidden() {
+    return this.assert(async () => {
+      const visible = await this.frame.isVisible(this.selector, this.options);
+      return this.negate ? visible : !visible;
+    }, this.negate ? "Expected element not to be hidden" : "Expected element to be hidden");
+  }
+  async toBeEnabled() {
+    return this.assert(async () => {
+      const enabled = await this.frame.isEnabled(this.selector, this.options);
+      if (enabled == null) {
+        return this.negate ? true : false;
+      }
+      return this.negate ? !enabled : enabled;
+    }, this.negate ? "Expected element not to be enabled" : "Expected element to be enabled");
+  }
+  async toBeDisabled() {
+    return this.assert(async () => {
+      const enabled = await this.frame.isEnabled(this.selector, this.options);
+      if (enabled == null) {
+        return this.negate ? true : false;
+      }
+      const disabled = !enabled;
+      return this.negate ? !disabled : disabled;
+    }, this.negate ? "Expected element not to be disabled" : "Expected element to be disabled");
+  }
+  async toBeChecked() {
+    return this.assert(async () => {
+      const checked = await this.frame.isChecked(this.selector, this.options);
+      if (checked == null) {
+        return this.negate ? true : false;
+      }
+      return this.negate ? !checked : checked;
+    }, this.negate ? "Expected element not to be checked" : "Expected element to be checked");
+  }
+  async toBeUnchecked() {
+    return this.assert(async () => {
+      const checked = await this.frame.isChecked(this.selector, this.options);
+      if (checked == null) {
+        return this.negate ? true : false;
+      }
+      const unchecked = !checked;
+      return this.negate ? !unchecked : unchecked;
+    }, this.negate ? "Expected element not to be unchecked" : "Expected element to be unchecked");
+  }
+  async toHaveText(textOrRegex) {
+    const expected = textOrRegex;
+    return this.assert(async () => {
+      const text = await this.frame.text(this.selector, this.options);
+      if (text == null) {
+        return this.negate ? true : false;
+      }
+      const matches = expected instanceof RegExp ? new RegExp(expected.source, expected.flags.replace("g", "")).test(text) : text.includes(expected);
+      return this.negate ? !matches : matches;
+    }, this.negate ? "Expected element text not to match" : "Expected element text to match", { expected });
+  }
+  async toHaveExactText(textOrRegex) {
+    const expected = textOrRegex;
+    return this.assert(async () => {
+      const text = await this.frame.text(this.selector, this.options);
+      if (text == null) {
+        return this.negate ? true : false;
+      }
+      const matches = expected instanceof RegExp ? new RegExp(expected.source, expected.flags.replace("g", "")).test(text) : text === expected;
+      return this.negate ? !matches : matches;
+    }, this.negate ? "Expected element text not to match exactly" : "Expected element text to match exactly", { expected });
+  }
+  async toContainText(textOrRegex) {
+    const expected = textOrRegex;
+    return this.assert(async () => {
+      const text = await this.frame.text(this.selector, this.options);
+      if (text == null) {
+        return this.negate ? true : false;
+      }
+      const matches = expected instanceof RegExp ? new RegExp(expected.source, expected.flags.replace("g", "")).test(text) : text.includes(expected);
+      return this.negate ? !matches : matches;
+    }, this.negate ? "Expected element text not to contain" : "Expected element text to contain", { expected });
+  }
+  async toHaveValue(valueOrRegex) {
+    const expected = valueOrRegex;
+    return this.assert(async () => {
+      const value = await this.frame.value(this.selector, this.options);
+      if (value == null) {
+        return this.negate ? true : false;
+      }
+      const matches = expected instanceof RegExp ? new RegExp(expected.source, expected.flags.replace("g", "")).test(value) : value === expected;
+      return this.negate ? !matches : matches;
+    }, this.negate ? "Expected element value not to match" : "Expected element value to match", { expected });
+  }
+  async toHaveAttribute(name, valueOrRegex) {
+    const expected = valueOrRegex;
+    return this.assert(async () => {
+      const value = await this.frame.attribute(this.selector, name, this.options);
+      if (expected === void 0) {
+        const exists = value != null;
+        return this.negate ? !exists : exists;
+      }
+      if (value == null) {
+        return this.negate ? true : false;
+      }
+      const matches = expected instanceof RegExp ? new RegExp(expected.source, expected.flags.replace("g", "")).test(value) : value === expected;
+      return this.negate ? !matches : matches;
+    }, this.negate ? "Expected element attribute not to match" : "Expected element attribute to match", { expected, name });
+  }
+  async toHaveId(idOrRegex) {
+    return this.toHaveAttribute("id", idOrRegex);
+  }
+  async toHaveName(nameOrRegex) {
+    return this.toHaveAttribute("name", nameOrRegex);
+  }
+  async toHaveCount(expected) {
+    return this.assert(async () => {
+      const count = await this.frame.count(this.selector, this.options);
+      const matches = count === expected;
+      return this.negate ? !matches : matches;
+    }, this.negate ? "Expected element count not to match" : "Expected element count to match", { expected });
+  }
+  async toHaveClass(nameOrRegex) {
+    const expected = nameOrRegex;
+    return this.assert(async () => {
+      const classes = await this.frame.classes(this.selector, this.options);
+      if (classes == null) {
+        return this.negate ? true : false;
+      }
+      const matches = expected instanceof RegExp ? classes.some((value) => new RegExp(expected.source, expected.flags.replace("g", "")).test(value)) : classes.includes(expected);
+      return this.negate ? !matches : matches;
+    }, this.negate ? "Expected element class not to match" : "Expected element class to match", { expected });
+  }
+  async toHaveClasses(expected) {
+    return this.assert(async () => {
+      const classes = await this.frame.classes(this.selector, this.options);
+      if (classes == null) {
+        return this.negate ? true : false;
+      }
+      const matches = expected.every((value) => classes.includes(value));
+      return this.negate ? !matches : matches;
+    }, this.negate ? "Expected element classes not to match" : "Expected element classes to match", { expected });
+  }
+  async toHaveCss(property, valueOrRegex) {
+    const expected = valueOrRegex;
+    return this.assert(async () => {
+      const value = await this.frame.css(this.selector, property, this.options);
+      if (value == null) {
+        return this.negate ? true : false;
+      }
+      const actual = value.trim();
+      const matches = expected instanceof RegExp ? new RegExp(expected.source, expected.flags.replace("g", "")).test(actual) : actual === expected;
+      return this.negate ? !matches : matches;
+    }, this.negate ? "Expected element css not to match" : "Expected element css to match", { expected, property });
+  }
+  async toHaveFocus() {
+    return this.assert(async () => {
+      const focused = await this.frame.hasFocus(this.selector, this.options);
+      if (focused == null) {
+        return this.negate ? true : false;
+      }
+      return this.negate ? !focused : focused;
+    }, this.negate ? "Expected element not to have focus" : "Expected element to have focus");
+  }
+  async toBeInViewport(options = {}) {
+    return this.assert(async () => {
+      const inViewport = await this.frame.isInViewport(this.selector, this.options, Boolean(options.fully));
+      if (inViewport == null) {
+        return this.negate ? true : false;
+      }
+      return this.negate ? !inViewport : inViewport;
+    }, this.negate ? "Expected element not to be in viewport" : "Expected element to be in viewport");
+  }
+  async toBeEditable() {
+    return this.assert(async () => {
+      const editable = await this.frame.isEditable(this.selector, this.options);
+      if (editable == null) {
+        return this.negate ? true : false;
+      }
+      return this.negate ? !editable : editable;
+    }, this.negate ? "Expected element not to be editable" : "Expected element to be editable");
+  }
+  async assert(predicate, message, details = {}) {
+    const timeoutMs = this.options.timeoutMs ?? 3e4;
+    const start = Date.now();
+    this.events.emit("assertion:start", { name: message, selector: this.selector, frameId: this.frame.id });
+    let lastState;
+    try {
+      await waitFor(async () => {
+        const result = await predicate();
+        lastState = result;
+        return result;
+      }, { timeoutMs, description: message });
+    } catch {
+      const duration2 = Date.now() - start;
+      this.events.emit("assertion:end", { name: message, selector: this.selector, frameId: this.frame.id, durationMs: duration2, status: "failed" });
+      throw new AssertionError(message, { selector: this.selector, timeoutMs, lastState: { lastState, ...details } });
+    }
+    const duration = Date.now() - start;
+    this.events.emit("assertion:end", { name: message, selector: this.selector, frameId: this.frame.id, durationMs: duration, status: "passed" });
+  }
+};
+var ExpectFrame = class {
+  frame;
+  events;
+  constructor(frame, events) {
+    this.frame = frame;
+    this.events = events;
+  }
+  element(selector, options = {}) {
+    return new ElementExpectation(this.frame, selector, options, false, this.events);
+  }
+};
+function expect(page) {
+  return {
+    element: (selector, options = {}) => new ElementExpectation(page.mainFrame(), selector, options, false, page.getEvents()),
+    frame: (options) => {
+      const frame = page.frame(options);
+      if (!frame) {
+        throw new AssertionError("Frame not found", { selector: JSON.stringify(options) });
+      }
+      return new ExpectFrame(frame, page.getEvents());
+    }
+  };
+}
+Page.prototype.expect = function(selector, options) {
+  const builder = expect(this);
+  if (selector) {
+    return builder.element(selector, options);
+  }
+  return builder;
+};
+Object.defineProperty(Page.prototype, "find", {
+  get: function() {
+    return {
+      locators: (options) => this.findLocators(options)
+    };
+  }
+});
+
+export {
+  Locator,
+  Frame,
+  Page,
+  AssertionError,
+  expect
+};
+//# sourceMappingURL=chunk-6BPF3IEU.js.map