browsecraft 0.1.0

package/dist/chunk-KIPQFK3Y.cjs

@@ -0,0 +1,2021 @@
+'use strict';
+
+var os = require('os');
+var browsecraftBidi = require('browsecraft-bidi');
+var promises = require('fs/promises');
+var path = require('path');
+
+// src/config.ts
+var DEFAULTS = {
+  browser: "chrome",
+  headless: true,
+  timeout: 3e4,
+  retries: 0,
+  screenshot: "on-failure",
+  baseURL: "",
+  viewport: { width: 1280, height: 720 },
+  maximized: false,
+  workers: Math.max(1, Math.floor((typeof os.cpus === "function" ? os.cpus().length : 4) / 2)),
+  testMatch: "**/*.test.{ts,js,mts,mjs}",
+  outputDir: ".browsecraft",
+  ai: "auto",
+  debug: false
+};
+function defineConfig(config) {
+  return config;
+}
+function resolveConfig(userConfig) {
+  if (!userConfig) return { ...DEFAULTS };
+  return {
+    ...DEFAULTS,
+    ...userConfig,
+    viewport: userConfig.viewport ?? DEFAULTS.viewport
+  };
+}
+
+// src/wait.ts
+async function waitFor(description, fn, options) {
+  const { timeout, interval = 100 } = options;
+  const startTime = Date.now();
+  let lastError = null;
+  while (Date.now() - startTime < timeout) {
+    try {
+      const result = await fn();
+      if (result !== null && result !== false) {
+        return result;
+      }
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+    }
+    await sleep(interval);
+  }
+  const elapsed = Date.now() - startTime;
+  const errorMsg = lastError ? `
+Last error: ${lastError.message}` : "";
+  throw new Error(
+    `Timed out after ${elapsed}ms waiting for: ${description}${errorMsg}`
+  );
+}
+async function waitForLoadState(session, contextId, state = "load", timeout = 3e4) {
+  const result = await session.script.evaluate({
+    expression: "document.readyState",
+    target: { context: contextId },
+    awaitPromise: false
+  });
+  if (result.type === "success" && result.result) {
+    const readyState = result.result.value;
+    if (state === "domcontentloaded" && (readyState === "interactive" || readyState === "complete")) {
+      return;
+    }
+    if (state === "load" && readyState === "complete") {
+      return;
+    }
+  }
+  const eventName = state === "load" ? "browsingContext.load" : "browsingContext.domContentLoaded";
+  await session.subscribe([eventName], [contextId]);
+  try {
+    await session.waitForEvent(
+      eventName,
+      (event) => event.params.context === contextId,
+      timeout
+    );
+  } finally {
+    await session.unsubscribe([eventName], [contextId]).catch(() => {
+    });
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/locator.ts
+async function locateElement(session, contextId, target, options) {
+  const opts = normalizeTarget(target);
+  return waitFor(
+    describeTarget(target),
+    async () => {
+      const strategies = buildStrategies(opts);
+      for (const { locator, strategy, isLabelLookup } of strategies) {
+        try {
+          const result = await session.browsingContext.locateNodes({
+            context: contextId,
+            locator,
+            maxNodeCount: (opts.index ?? 0) + 10
+            // fetch extra for label resolution
+          });
+          if (result.nodes.length > 0) {
+            if (isLabelLookup) {
+              const resolved = await resolveLabelsToInputs(session, contextId, result.nodes);
+              if (resolved) {
+                return { node: resolved, strategy };
+              }
+              continue;
+            }
+            const nodeIndex = opts.index ?? 0;
+            const node = result.nodes[nodeIndex];
+            if (node) {
+              return { node, strategy };
+            }
+          }
+        } catch {
+          continue;
+        }
+      }
+      return null;
+    },
+    options
+  );
+}
+async function locateAllElements(session, contextId, target) {
+  const opts = normalizeTarget(target);
+  const strategies = buildStrategies(opts);
+  for (const { locator, strategy } of strategies) {
+    try {
+      const result = await session.browsingContext.locateNodes({
+        context: contextId,
+        locator,
+        maxNodeCount: 1e3
+      });
+      if (result.nodes.length > 0) {
+        return result.nodes.map((node) => ({ node, strategy }));
+      }
+    } catch {
+      continue;
+    }
+  }
+  return [];
+}
+function normalizeTarget(target) {
+  if (typeof target === "string") {
+    return { name: target };
+  }
+  return target;
+}
+function describeTarget(target) {
+  if (typeof target === "string") {
+    return `element "${target}"`;
+  }
+  const parts = [];
+  if (target.role) parts.push(`role="${target.role}"`);
+  if (target.name) parts.push(`name="${target.name}"`);
+  if (target.text) parts.push(`text="${target.text}"`);
+  if (target.label) parts.push(`label="${target.label}"`);
+  if (target.testId) parts.push(`testId="${target.testId}"`);
+  if (target.selector) parts.push(`selector="${target.selector}"`);
+  return `element [${parts.join(", ")}]`;
+}
+function buildStrategies(opts) {
+  const strategies = [];
+  const matchType = opts.exact ? "full" : "partial";
+  if (opts.selector) {
+    strategies.push({
+      locator: { type: "css", value: opts.selector },
+      strategy: "css"
+    });
+    return strategies;
+  }
+  if (opts.testId) {
+    strategies.push({
+      locator: { type: "css", value: `[data-testid="${opts.testId}"]` },
+      strategy: "testId"
+    });
+    return strategies;
+  }
+  const name = opts.name ?? opts.text;
+  if (name) {
+    if (opts.role) {
+      strategies.push({
+        locator: {
+          type: "accessibility",
+          value: { role: opts.role, name }
+        },
+        strategy: `accessibility[role="${opts.role}", name="${name}"]`
+      });
+    } else {
+      for (const role of ["button", "link", "menuitem", "tab"]) {
+        strategies.push({
+          locator: {
+            type: "accessibility",
+            value: { role, name }
+          },
+          strategy: `accessibility[role="${role}", name="${name}"]`
+        });
+      }
+    }
+    strategies.push({
+      locator: {
+        type: "innerText",
+        value: name,
+        matchType,
+        ignoreCase: !opts.exact
+      },
+      strategy: `innerText("${name}")`
+    });
+    if (name.match(/^[#.\[a-z]/i)) {
+      strategies.push({
+        locator: { type: "css", value: name },
+        strategy: `css("${name}")`
+      });
+    }
+  }
+  if (opts.label) {
+    strategies.push({
+      locator: {
+        type: "accessibility",
+        value: { name: opts.label }
+      },
+      strategy: `label("${opts.label}")`
+    });
+    strategies.push({
+      locator: {
+        type: "css",
+        value: `[aria-label="${opts.label}"], [placeholder="${opts.label}"]`
+      },
+      strategy: `label-css("${opts.label}")`
+    });
+    strategies.push({
+      locator: {
+        type: "innerText",
+        value: opts.label,
+        matchType,
+        ignoreCase: !opts.exact
+      },
+      strategy: `label-text("${opts.label}")`,
+      isLabelLookup: true
+    });
+  }
+  if (opts.role && !name) {
+    strategies.push({
+      locator: {
+        type: "accessibility",
+        value: { role: opts.role }
+      },
+      strategy: `role("${opts.role}")`
+    });
+  }
+  return strategies;
+}
+async function resolveLabelsToInputs(session, contextId, nodes) {
+  for (const node of nodes) {
+    if (!node.sharedId) continue;
+    try {
+      const result = await session.script.callFunction({
+        functionDeclaration: `function(el) {
+					// If the element is a <label> with a 'for' attribute, find the associated input
+					if (el.tagName === 'LABEL') {
+						const forId = el.getAttribute('for');
+						if (forId) {
+							const input = document.getElementById(forId);
+							if (input) return input;
+						}
+						// Also check for implicit label association (input nested inside label)
+						const nested = el.querySelector('input, textarea, select');
+						if (nested) return nested;
+					}
+					return null;
+				}`,
+        target: { context: contextId },
+        arguments: [{ sharedId: node.sharedId, handle: node.handle }],
+        awaitPromise: false,
+        resultOwnership: "root"
+      });
+      if (result.type === "success" && result.result?.type === "node" && result.result.sharedId) {
+        return result.result;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+// src/page.ts
+var Page = class {
+  /** @internal */
+  session;
+  /** @internal */
+  contextId;
+  /** @internal */
+  config;
+  /** @internal */
+  interceptIds = [];
+  /** @internal -- event listener unsubscribe functions for cleanup */
+  eventCleanups = [];
+  constructor(session, contextId, config) {
+    this.session = session;
+    this.contextId = contextId;
+    this.config = config;
+  }
+  // -----------------------------------------------------------------------
+  // Navigation
+  // -----------------------------------------------------------------------
+  /**
+   * Navigate to a URL.
+   *
+   * ```ts
+   * await page.goto('https://example.com');
+   * await page.goto('/login');  // uses baseURL from config
+   * ```
+   */
+  async goto(url, options) {
+    const fullUrl = this.resolveURL(url);
+    const waitUntil = options?.waitUntil ?? "complete";
+    await this.session.browsingContext.navigate({
+      context: this.contextId,
+      url: fullUrl,
+      wait: waitUntil
+    });
+  }
+  /**
+   * Reload the current page.
+   */
+  async reload(options) {
+    await this.session.browsingContext.reload({
+      context: this.contextId,
+      wait: options?.waitUntil ?? "complete"
+    });
+  }
+  /**
+   * Go back in browser history.
+   */
+  async goBack() {
+    await this.session.browsingContext.traverseHistory({
+      context: this.contextId,
+      delta: -1
+    });
+  }
+  /**
+   * Go forward in browser history.
+   */
+  async goForward() {
+    await this.session.browsingContext.traverseHistory({
+      context: this.contextId,
+      delta: 1
+    });
+  }
+  // -----------------------------------------------------------------------
+  // Element interaction - the "stupidly simple" API
+  // -----------------------------------------------------------------------
+  /**
+   * Click an element. Finds it by text, role, or selector -- auto-waits.
+   *
+   * ```ts
+   * await page.click('Submit');                           // by text
+   * await page.click({ role: 'button', name: 'Submit' }); // precise
+   * await page.click({ selector: '#my-button' });          // CSS
+   * ```
+   */
+  async click(target, options) {
+    const timeout = options?.timeout ?? this.config.timeout;
+    const located = await locateElement(this.session, this.contextId, target, { timeout });
+    await this.scrollIntoViewAndClick(located, options);
+  }
+  /**
+   * Fill a text input. First arg finds the input, second is the value.
+   *
+   * ```ts
+   * await page.fill('Email', 'user@test.com');       // by label
+   * await page.fill('Search', 'browsecraft');          // by placeholder
+   * await page.fill({ selector: '#email' }, 'test');   // by CSS
+   * ```
+   */
+  async fill(target, value, options) {
+    const timeout = options?.timeout ?? this.config.timeout;
+    const resolvedTarget = typeof target === "string" ? { label: target, name: target } : target;
+    const located = await locateElement(this.session, this.contextId, resolvedTarget, { timeout });
+    const ref = this.getSharedRef(located.node);
+    await this.session.script.callFunction({
+      functionDeclaration: `function(element, value) {
+				element.focus();
+				// Use native setter to bypass React/Vue/Angular internal value trackers.
+				// Frameworks like React override the value property on input elements,
+				// so setting element.value directly doesn't trigger their state updates.
+				const proto = element.tagName === 'TEXTAREA'
+					? HTMLTextAreaElement.prototype
+					: HTMLInputElement.prototype;
+				const nativeSetter = Object.getOwnPropertyDescriptor(proto, 'value')?.set;
+				if (nativeSetter) {
+					nativeSetter.call(element, '');
+					nativeSetter.call(element, value);
+				} else {
+					element.value = '';
+					element.value = value;
+				}
+				element.dispatchEvent(new Event('input', { bubbles: true }));
+				element.dispatchEvent(new Event('change', { bubbles: true }));
+			}`,
+      target: { context: this.contextId },
+      arguments: [ref, { type: "string", value }],
+      awaitPromise: false
+    });
+  }
+  /**
+   * Type text character by character (triggers keyboard events).
+   * Use this instead of fill() when you need realistic keyboard input.
+   *
+   * ```ts
+   * await page.type('Search', 'browsecraft');
+   * ```
+   */
+  async type(target, text, options) {
+    const timeout = options?.timeout ?? this.config.timeout;
+    const resolvedTarget = typeof target === "string" ? { label: target, name: target } : target;
+    const located = await locateElement(this.session, this.contextId, resolvedTarget, { timeout });
+    const ref = this.getSharedRef(located.node);
+    await this.session.script.callFunction({
+      functionDeclaration: "function(el) { el.focus(); }",
+      target: { context: this.contextId },
+      arguments: [ref],
+      awaitPromise: false
+    });
+    const actions = [];
+    for (const char of text) {
+      actions.push({ type: "keyDown", value: char });
+      actions.push({ type: "keyUp", value: char });
+    }
+    await this.session.input.performActions({
+      context: this.contextId,
+      actions: [{ type: "key", id: "keyboard", actions }]
+    });
+  }
+  /**
+   * Select an option from a <select> dropdown.
+   *
+   * ```ts
+   * await page.select('Country', 'United States');
+   * ```
+   */
+  async select(target, value, options) {
+    const timeout = options?.timeout ?? this.config.timeout;
+    const resolvedTarget = typeof target === "string" ? { label: target, name: target } : target;
+    const located = await locateElement(this.session, this.contextId, resolvedTarget, { timeout });
+    const ref = this.getSharedRef(located.node);
+    await this.session.script.callFunction({
+      functionDeclaration: `function(element, value) {
+				const options = Array.from(element.options);
+				const option = options.find(o => o.value === value || o.text === value || o.textContent.trim() === value);
+				if (option) {
+					element.value = option.value;
+					element.dispatchEvent(new Event('change', { bubbles: true }));
+				} else {
+					throw new Error('Option "' + value + '" not found in <select>');
+				}
+			}`,
+      target: { context: this.contextId },
+      arguments: [ref, { type: "string", value }],
+      awaitPromise: false
+    });
+  }
+  /**
+   * Check a checkbox or radio button.
+   *
+   * ```ts
+   * await page.check('I agree to the terms');
+   * ```
+   */
+  async check(target, options) {
+    const timeout = options?.timeout ?? this.config.timeout;
+    const located = await locateElement(this.session, this.contextId, target, { timeout });
+    const ref = this.getSharedRef(located.node);
+    const result = await this.session.script.callFunction({
+      functionDeclaration: "function(el) { return el.checked; }",
+      target: { context: this.contextId },
+      arguments: [ref],
+      awaitPromise: false
+    });
+    const isChecked = result.type === "success" && result.result?.type === "boolean" && result.result.value === true;
+    if (!isChecked) {
+      await this.scrollIntoViewAndClick(located, options);
+    }
+  }
+  /**
+   * Uncheck a checkbox.
+   */
+  async uncheck(target, options) {
+    const timeout = options?.timeout ?? this.config.timeout;
+    const located = await locateElement(this.session, this.contextId, target, { timeout });
+    const ref = this.getSharedRef(located.node);
+    const result = await this.session.script.callFunction({
+      functionDeclaration: "function(el) { return el.checked; }",
+      target: { context: this.contextId },
+      arguments: [ref],
+      awaitPromise: false
+    });
+    const isChecked = result.type === "success" && result.result?.type === "boolean" && result.result.value === true;
+    if (isChecked) {
+      await this.scrollIntoViewAndClick(located, options);
+    }
+  }
+  /**
+   * Hover over an element.
+   *
+   * ```ts
+   * await page.hover('Profile Menu');
+   * ```
+   */
+  async hover(target, options) {
+    const timeout = options?.timeout ?? this.config.timeout;
+    const located = await locateElement(this.session, this.contextId, target, { timeout });
+    const ref = this.getSharedRef(located.node);
+    await this.session.script.callFunction({
+      functionDeclaration: 'function(el) { el.scrollIntoView({ block: "center", behavior: "instant" }); }',
+      target: { context: this.contextId },
+      arguments: [ref],
+      awaitPromise: false
+    });
+    await this.session.script.callFunction({
+      functionDeclaration: `function(el) {
+				el.dispatchEvent(new MouseEvent('mouseenter', { bubbles: true }));
+				el.dispatchEvent(new MouseEvent('mouseover', { bubbles: true }));
+			}`,
+      target: { context: this.contextId },
+      arguments: [ref],
+      awaitPromise: false
+    });
+    const pos = await this.getElementCenter(ref);
+    await this.session.input.performActions({
+      context: this.contextId,
+      actions: [{
+        type: "pointer",
+        id: "mouse",
+        parameters: { pointerType: "mouse" },
+        actions: [
+          { type: "pointerMove", x: pos.x, y: pos.y, origin: "viewport" }
+        ]
+      }]
+    });
+  }
+  // -----------------------------------------------------------------------
+  // Finding elements (for assertions and inspection)
+  // -----------------------------------------------------------------------
+  /**
+   * Get a single element. Returns an ElementHandle for assertions.
+   *
+   * ```ts
+   * const heading = page.get('Welcome back!');
+   * await expect(heading).toBeVisible();
+   * ```
+   */
+  get(target) {
+    return new ElementHandle(this, target);
+  }
+  /**
+   * Get a locator by visible text. Alias for get() with text matching.
+   *
+   * ```ts
+   * const btn = page.getByText('Submit');
+   * ```
+   */
+  getByText(text, options) {
+    return new ElementHandle(this, { text, exact: options?.exact });
+  }
+  /**
+   * Get a locator by ARIA role and optional name.
+   *
+   * ```ts
+   * const btn = page.getByRole('button', { name: 'Submit' });
+   * ```
+   */
+  getByRole(role, options) {
+    return new ElementHandle(this, { role, name: options?.name, exact: options?.exact });
+  }
+  /**
+   * Get a locator by label text (for form inputs).
+   *
+   * ```ts
+   * const email = page.getByLabel('Email Address');
+   * ```
+   */
+  getByLabel(label, options) {
+    return new ElementHandle(this, { label, exact: options?.exact });
+  }
+  /**
+   * Get a locator by data-testid attribute.
+   *
+   * ```ts
+   * const card = page.getByTestId('user-card');
+   * ```
+   */
+  getByTestId(testId) {
+    return new ElementHandle(this, { testId });
+  }
+  // -----------------------------------------------------------------------
+  // Page state
+  // -----------------------------------------------------------------------
+  /** Get the current page URL */
+  async url() {
+    const result = await this.session.script.evaluate({
+      expression: "window.location.href",
+      target: { context: this.contextId },
+      awaitPromise: false
+    });
+    return this.extractStringResult(result) ?? "";
+  }
+  /** Get the page title */
+  async title() {
+    const result = await this.session.script.evaluate({
+      expression: "document.title",
+      target: { context: this.contextId },
+      awaitPromise: false
+    });
+    return this.extractStringResult(result) ?? "";
+  }
+  /** Get the full page HTML content */
+  async content() {
+    const result = await this.session.script.evaluate({
+      expression: "document.documentElement.outerHTML",
+      target: { context: this.contextId },
+      awaitPromise: false
+    });
+    return this.extractStringResult(result) ?? "";
+  }
+  // -----------------------------------------------------------------------
+  // Cookies
+  // -----------------------------------------------------------------------
+  /**
+   * Get cookies for the current page's browsing context.
+   *
+   * ```ts
+   * const cookies = await page.cookies();
+   * const session = cookies.find(c => c.name === 'session_id');
+   * ```
+   */
+  async cookies(filter) {
+    const result = await this.session.storage.getCookies({
+      filter: filter ? {
+        name: filter.name,
+        domain: filter.domain,
+        path: filter.path
+      } : void 0,
+      partition: { type: "context", context: this.contextId }
+    });
+    return result.cookies;
+  }
+  /**
+   * Set one or more cookies.
+   *
+   * ```ts
+   * await page.setCookies([
+   *   { name: 'token', value: 'abc123', domain: 'example.com' },
+   *   { name: 'theme', value: 'dark', domain: 'example.com' },
+   * ]);
+   * ```
+   */
+  async setCookies(cookies) {
+    for (const cookie of cookies) {
+      const cookieHeader = {
+        name: cookie.name,
+        value: { type: "string", value: cookie.value },
+        domain: cookie.domain,
+        path: cookie.path,
+        httpOnly: cookie.httpOnly,
+        secure: cookie.secure,
+        sameSite: cookie.sameSite,
+        expiry: cookie.expiry
+      };
+      await this.session.storage.setCookie({
+        cookie: cookieHeader,
+        partition: { type: "context", context: this.contextId }
+      });
+    }
+  }
+  /**
+   * Clear all cookies (or those matching a filter).
+   *
+   * ```ts
+   * await page.clearCookies();                           // all cookies
+   * await page.clearCookies({ name: 'session_id' });     // specific cookie
+   * await page.clearCookies({ domain: 'example.com' });  // by domain
+   * ```
+   */
+  async clearCookies(filter) {
+    await this.session.storage.deleteCookies({
+      filter: filter ? {
+        name: filter.name,
+        domain: filter.domain,
+        path: filter.path
+      } : void 0,
+      partition: { type: "context", context: this.contextId }
+    });
+  }
+  // -----------------------------------------------------------------------
+  // JavaScript execution
+  // -----------------------------------------------------------------------
+  /**
+   * Execute JavaScript in the page and return the result.
+   *
+   * ```ts
+   * const title = await page.evaluate('document.title');
+   * const count = await page.evaluate(() => document.querySelectorAll('li').length);
+   * ```
+   */
+  async evaluate(expression) {
+    const expr = typeof expression === "function" ? `(${expression.toString()})()` : expression;
+    const result = await this.session.script.evaluate({
+      expression: expr,
+      target: { context: this.contextId },
+      awaitPromise: true
+    });
+    if (result.type === "exception") {
+      const errorText = result.exceptionDetails?.text ?? "Script evaluation failed";
+      throw new Error(errorText);
+    }
+    return this.deserializeRemoteValue(result.result);
+  }
+  // -----------------------------------------------------------------------
+  // Screenshots
+  // -----------------------------------------------------------------------
+  /**
+   * Take a screenshot of the page.
+   *
+   * ```ts
+   * const buffer = await page.screenshot();
+   * ```
+   */
+  async screenshot() {
+    const result = await this.session.browsingContext.captureScreenshot({
+      context: this.contextId
+    });
+    return Buffer.from(result.data, "base64");
+  }
+  // -----------------------------------------------------------------------
+  // Network mocking
+  // -----------------------------------------------------------------------
+  /**
+   * Mock a network request with a fake response.
+   *
+   * ```ts
+   * await page.mock('POST /api/login', { status: 200, body: { token: 'abc' } });
+   * await page.mock('GET /api/users', { status: 500 });
+   * await page.mock('https://api.example.com/data', { body: { items: [] } });
+   * ```
+   */
+  async mock(pattern, response) {
+    const { method, urlPattern } = parseMockPattern(pattern);
+    await this.session.subscribe(
+      ["network.beforeRequestSent"],
+      [this.contextId]
+    );
+    const result = await this.session.network.addIntercept({
+      phases: ["beforeRequestSent"],
+      urlPatterns: [urlPattern],
+      contexts: [this.contextId]
+    });
+    this.interceptIds.push(result.intercept);
+    const unsubscribe = this.session.on("network.beforeRequestSent", async (event) => {
+      const params = event.params;
+      if (!params.isBlocked || params.context !== this.contextId) return;
+      if (!params.intercepts?.includes(result.intercept)) return;
+      if (method && params.request.method.toUpperCase() !== method.toUpperCase()) {
+        await this.session.network.continueRequest({ request: params.request.request });
+        return;
+      }
+      const headers = buildMockHeaders(response);
+      const body = buildMockBody(response);
+      await this.session.network.provideResponse({
+        request: params.request.request,
+        statusCode: response.status ?? 200,
+        headers,
+        body: body ? { type: "string", value: body } : void 0
+      });
+    });
+    this.eventCleanups.push(unsubscribe);
+  }
+  /**
+   * Remove all network mocks and clean up event listeners.
+   */
+  async clearMocks() {
+    for (const id of this.interceptIds) {
+      await this.session.network.removeIntercept({ intercept: id }).catch(() => {
+      });
+    }
+    this.interceptIds = [];
+    for (const cleanup of this.eventCleanups) {
+      cleanup();
+    }
+    this.eventCleanups = [];
+  }
+  // -----------------------------------------------------------------------
+  // Dialog handling
+  // -----------------------------------------------------------------------
+  /**
+   * Accept the next dialog (alert, confirm, prompt).
+   *
+   * ```ts
+   * await page.acceptDialog();
+   * page.click('Delete'); // triggers confirm dialog
+   * ```
+   */
+  async acceptDialog(text) {
+    await this.session.subscribe(["browsingContext.userPromptOpened"], [this.contextId]);
+    await this.session.waitForEvent(
+      "browsingContext.userPromptOpened",
+      (e) => e.params.context === this.contextId
+    );
+    await this.session.browsingContext.handleUserPrompt({
+      context: this.contextId,
+      accept: true,
+      userText: text
+    });
+  }
+  /**
+   * Dismiss the next dialog.
+   */
+  async dismissDialog() {
+    await this.session.subscribe(["browsingContext.userPromptOpened"], [this.contextId]);
+    await this.session.waitForEvent(
+      "browsingContext.userPromptOpened",
+      (e) => e.params.context === this.contextId
+    );
+    await this.session.browsingContext.handleUserPrompt({
+      context: this.contextId,
+      accept: false
+    });
+  }
+  /**
+   * Double-click an element.
+   *
+   * ```ts
+   * await page.dblclick('Edit');
+   * ```
+   */
+  async dblclick(target, options) {
+    await this.click(target, { ...options, clickCount: 2 });
+  }
+  /**
+   * Tap an element (touch gesture).
+   *
+   * ```ts
+   * await page.tap('Menu');
+   * ```
+   */
+  async tap(target, options) {
+    const timeout = options?.timeout ?? this.config.timeout;
+    const located = await locateElement(this.session, this.contextId, target, { timeout });
+    const ref = this.getSharedRef(located.node);
+    await this.session.script.callFunction({
+      functionDeclaration: 'function(el) { el.scrollIntoView({ block: "center", behavior: "instant" }); }',
+      target: { context: this.contextId },
+      arguments: [ref],
+      awaitPromise: false
+    });
+    const pos = await this.getElementCenter(ref);
+    await this.session.input.performActions({
+      context: this.contextId,
+      actions: [{
+        type: "pointer",
+        id: "touch",
+        parameters: { pointerType: "touch" },
+        actions: [
+          { type: "pointerMove", x: pos.x, y: pos.y, origin: "viewport" },
+          { type: "pointerDown", button: 0 },
+          { type: "pointerUp", button: 0 }
+        ]
+      }]
+    });
+  }
+  /**
+   * Focus an element.
+   *
+   * ```ts
+   * await page.focus('Email');
+   * ```
+   */
+  async focus(target, options) {
+    const timeout = options?.timeout ?? this.config.timeout;
+    const resolvedTarget = typeof target === "string" ? { label: target, name: target } : target;
+    const located = await locateElement(this.session, this.contextId, resolvedTarget, { timeout });
+    const ref = this.getSharedRef(located.node);
+    await this.session.script.callFunction({
+      functionDeclaration: "function(el) { el.focus(); }",
+      target: { context: this.contextId },
+      arguments: [ref],
+      awaitPromise: false
+    });
+  }
+  /**
+   * Remove focus from an element.
+   *
+   * ```ts
+   * await page.blur('Email');
+   * ```
+   */
+  async blur(target, options) {
+    const timeout = options?.timeout ?? this.config.timeout;
+    const resolvedTarget = typeof target === "string" ? { label: target, name: target } : target;
+    const located = await locateElement(this.session, this.contextId, resolvedTarget, { timeout });
+    const ref = this.getSharedRef(located.node);
+    await this.session.script.callFunction({
+      functionDeclaration: "function(el) { el.blur(); }",
+      target: { context: this.contextId },
+      arguments: [ref],
+      awaitPromise: false
+    });
+  }
+  /**
+   * Get the visible inner text of an element (like element.innerText).
+   *
+   * ```ts
+   * const text = await page.innerText('h1');
+   * ```
+   */
+  async innerText(target, options) {
+    const timeout = options?.timeout ?? this.config.timeout;
+    const located = await locateElement(this.session, this.contextId, target, { timeout });
+    const ref = this.getSharedRef(located.node);
+    const result = await this.session.script.callFunction({
+      functionDeclaration: 'function(el) { return el.innerText || ""; }',
+      target: { context: this.contextId },
+      arguments: [ref],
+      awaitPromise: false
+    });
+    return this.extractStringResult(result) ?? "";
+  }
+  /**
+   * Get the innerHTML of an element.
+   *
+   * ```ts
+   * const html = await page.innerHTML('.container');
+   * ```
+   */
+  async innerHTML(target, options) {
+    const timeout = options?.timeout ?? this.config.timeout;
+    const located = await locateElement(this.session, this.contextId, target, { timeout });
+    const ref = this.getSharedRef(located.node);
+    const result = await this.session.script.callFunction({
+      functionDeclaration: 'function(el) { return el.innerHTML || ""; }',
+      target: { context: this.contextId },
+      arguments: [ref],
+      awaitPromise: false
+    });
+    return this.extractStringResult(result) ?? "";
+  }
+  /**
+   * Get the current value of an input/textarea/select.
+   *
+   * ```ts
+   * const email = await page.inputValue('Email');
+   * ```
+   */
+  async inputValue(target, options) {
+    const timeout = options?.timeout ?? this.config.timeout;
+    const resolvedTarget = typeof target === "string" ? { label: target, name: target } : target;
+    const located = await locateElement(this.session, this.contextId, resolvedTarget, { timeout });
+    const ref = this.getSharedRef(located.node);
+    const result = await this.session.script.callFunction({
+      functionDeclaration: 'function(el) { return el.value ?? ""; }',
+      target: { context: this.contextId },
+      arguments: [ref],
+      awaitPromise: false
+    });
+    return this.extractStringResult(result) ?? "";
+  }
+  /**
+   * Select multiple options from a <select multiple> dropdown.
+   *
+   * ```ts
+   * await page.selectOption('Colors', ['red', 'blue']);
+   * ```
+   */
+  async selectOption(target, values, options) {
+    const timeout = options?.timeout ?? this.config.timeout;
+    const resolvedTarget = typeof target === "string" ? { label: target, name: target } : target;
+    const located = await locateElement(this.session, this.contextId, resolvedTarget, { timeout });
+    const ref = this.getSharedRef(located.node);
+    const valuesArray = Array.isArray(values) ? values : [values];
+    await this.session.script.callFunction({
+      functionDeclaration: `function(element, values) {
+				const opts = Array.from(element.options);
+				for (const opt of opts) {
+					opt.selected = values.some(v => opt.value === v || opt.text === v || opt.textContent.trim() === v);
+				}
+				element.dispatchEvent(new Event('change', { bubbles: true }));
+			}`,
+      target: { context: this.contextId },
+      arguments: [ref, { type: "array", value: valuesArray.map((v) => ({ type: "string", value: v })) }],
+      awaitPromise: false
+    });
+  }
+  /**
+   * Drag an element to another element or position.
+   *
+   * ```ts
+   * await page.dragTo('Draggable', 'Drop Zone');
+   * ```
+   */
+  async dragTo(source, dest, options) {
+    const timeout = options?.timeout ?? this.config.timeout;
+    const sourceLoc = await locateElement(this.session, this.contextId, source, { timeout });
+    const sourceRef = this.getSharedRef(sourceLoc.node);
+    const sourcePos = await this.getElementCenter(sourceRef);
+    const destLoc = await locateElement(this.session, this.contextId, dest, { timeout });
+    const destRef = this.getSharedRef(destLoc.node);
+    const destPos = await this.getElementCenter(destRef);
+    await this.session.input.performActions({
+      context: this.contextId,
+      actions: [{
+        type: "pointer",
+        id: "mouse",
+        parameters: { pointerType: "mouse" },
+        actions: [
+          { type: "pointerMove", x: sourcePos.x, y: sourcePos.y, origin: "viewport" },
+          { type: "pointerDown", button: 0 },
+          { type: "pointerMove", x: destPos.x, y: destPos.y, origin: "viewport", duration: 300 },
+          { type: "pointerUp", button: 0 }
+        ]
+      }]
+    });
+  }
+  // -----------------------------------------------------------------------
+  // Waiting (explicit -- but usually you don't need these)
+  // -----------------------------------------------------------------------
+  /**
+   * Wait for an element matching the target to appear in the DOM.
+   *
+   * ```ts
+   * await page.waitForSelector('.loaded');
+   * await page.waitForSelector({ role: 'dialog' });
+   * ```
+   */
+  async waitForSelector(target, options) {
+    const timeout = options?.timeout ?? this.config.timeout;
+    const state = options?.state ?? "visible";
+    if (state === "hidden") {
+      await waitFor(
+        `element to be hidden`,
+        async () => {
+          try {
+            const elements = await locateAllElements(this.session, this.contextId, target);
+            if (elements.length === 0) return true;
+            const ref = this.getSharedRef(elements[0].node);
+            const result = await this.session.script.callFunction({
+              functionDeclaration: `function(el) {
+								const style = window.getComputedStyle(el);
+								return style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0';
+							}`,
+              target: { context: this.contextId },
+              arguments: [ref],
+              awaitPromise: false
+            });
+            const isHidden = result.type === "success" && result.result?.type === "boolean" && result.result.value === true;
+            return isHidden ? true : null;
+          } catch {
+            return true;
+          }
+        },
+        { timeout }
+      );
+      return new ElementHandle(this, target);
+    }
+    const located = await locateElement(this.session, this.contextId, target, { timeout });
+    if (state === "visible") {
+      const ref = this.getSharedRef(located.node);
+      await waitFor(
+        `element to be visible`,
+        async () => {
+          const result = await this.session.script.callFunction({
+            functionDeclaration: `function(el) {
+							const style = window.getComputedStyle(el);
+							const rect = el.getBoundingClientRect();
+							return style.display !== 'none' && style.visibility !== 'hidden' &&
+								style.opacity !== '0' && rect.width > 0 && rect.height > 0;
+						}`,
+            target: { context: this.contextId },
+            arguments: [ref],
+            awaitPromise: false
+          });
+          const isVisible = result.type === "success" && result.result?.type === "boolean" && result.result.value === true;
+          return isVisible ? true : null;
+        },
+        { timeout }
+      );
+    }
+    return new ElementHandle(this, target);
+  }
+  /**
+   * Wait for a JavaScript function to return a truthy value.
+   *
+   * ```ts
+   * await page.waitForFunction('document.querySelectorAll("li").length > 5');
+   * await page.waitForFunction(() => window.appReady === true);
+   * ```
+   */
+  async waitForFunction(expression, options) {
+    const timeout = options?.timeout ?? this.config.timeout;
+    const expr = typeof expression === "function" ? `(${expression.toString()})()` : expression;
+    return waitFor(
+      "function to return truthy",
+      async () => {
+        const result = await this.session.script.evaluate({
+          expression: expr,
+          target: { context: this.contextId },
+          awaitPromise: true
+        });
+        if (result.type === "exception") return null;
+        const value = this.deserializeRemoteValue(result.result);
+        return value ? value : null;
+      },
+      { timeout }
+    );
+  }
+  /**
+   * Wait for a specific URL. Usually you use expect(page).toHaveURL() instead.
+   */
+  async waitForURL(url, options) {
+    const timeout = options?.timeout ?? this.config.timeout;
+    await waitFor(
+      `URL to match ${url}`,
+      async () => {
+        const currentUrl = await this.url();
+        if (typeof url === "string") {
+          return currentUrl.includes(url) ? true : null;
+        }
+        return url.test(currentUrl) ? true : null;
+      },
+      { timeout }
+    );
+  }
+  /**
+   * Wait for the page to finish loading.
+   */
+  async waitForLoadState(state) {
+    await waitForLoadState(this.session, this.contextId, state, this.config.timeout);
+  }
+  // -----------------------------------------------------------------------
+  // Lifecycle
+  // -----------------------------------------------------------------------
+  /**
+   * Close this page/tab.
+   */
+  async close() {
+    await this.clearMocks();
+    await this.session.browsingContext.close({ context: this.contextId });
+  }
+  // -----------------------------------------------------------------------
+  // Keyboard shortcuts
+  // -----------------------------------------------------------------------
+  /**
+   * Press a keyboard key.
+   *
+   * ```ts
+   * await page.press('Enter');
+   * await page.press('Control+a');
+   * ```
+   */
+  async press(key) {
+    const keys = key.split("+");
+    const actions = [];
+    for (const k of keys) {
+      actions.push({ type: "keyDown", value: mapKey(k) });
+    }
+    for (const k of keys.reverse()) {
+      actions.push({ type: "keyUp", value: mapKey(k) });
+    }
+    await this.session.input.performActions({
+      context: this.contextId,
+      actions: [{ type: "key", id: "keyboard", actions }]
+    });
+  }
+  // -----------------------------------------------------------------------
+  // Private helpers
+  // -----------------------------------------------------------------------
+  /** Resolve a relative URL against the baseURL */
+  resolveURL(url) {
+    if (url.startsWith("http://") || url.startsWith("https://") || url.startsWith("about:") || url.startsWith("data:")) {
+      return url;
+    }
+    const base = this.config.baseURL.replace(/\/$/, "");
+    const path = url.startsWith("/") ? url : `/${url}`;
+    return base ? `${base}${path}` : url;
+  }
+  /** Get a shared reference from a located node */
+  getSharedRef(node) {
+    if (node.sharedId) {
+      return { sharedId: node.sharedId, handle: node.handle };
+    }
+    throw new Error("Element has no shared reference. This is a bug in Browsecraft.");
+  }
+  /** Get the center coordinates of an element */
+  async getElementCenter(ref) {
+    const result = await this.session.script.callFunction({
+      functionDeclaration: `function(el) {
+				const rect = el.getBoundingClientRect();
+				if (rect.width === 0 && rect.height === 0) {
+					throw new Error('Element has zero size -- it may be hidden or not rendered');
+				}
+				return { x: Math.round(rect.x + rect.width / 2), y: Math.round(rect.y + rect.height / 2) };
+			}`,
+      target: { context: this.contextId },
+      arguments: [ref],
+      awaitPromise: false
+    });
+    if (result.type === "exception") {
+      const errorText = result.exceptionDetails?.text ?? "Failed to get element position";
+      throw new Error(`Cannot interact with element: ${errorText}`);
+    }
+    if (result.type === "success" && result.result?.type === "object") {
+      const val = result.result.value;
+      if (Array.isArray(val)) {
+        const map = new Map(val);
+        const xVal = map.get("x");
+        const yVal = map.get("y");
+        const x = typeof xVal === "object" && xVal !== null && "value" in xVal ? xVal.value : null;
+        const y = typeof yVal === "object" && yVal !== null && "value" in yVal ? yVal.value : null;
+        if (x !== null && y !== null) {
+          return { x, y };
+        }
+      }
+    }
+    throw new Error(
+      "Cannot get element position: unexpected response from browser. The element may not be visible or may not have a bounding rectangle."
+    );
+  }
+  /**
+   * Scroll element into view and click it.
+   *
+   * Uses JavaScript `.click()` as the primary mechanism because it is
+   * immune to viewport coordinate mismatches, DPI scaling, layout shifts,
+   * and Chrome BiDi's unreliable element-origin support. This works
+   * identically in headless and headed mode, with or without slowMo delays.
+   *
+   * The element is scrolled into view first so it's visible in headed mode
+   * (important when users are watching the test run).
+   */
+  async scrollIntoViewAndClick(located, options) {
+    const ref = this.getSharedRef(located.node);
+    const clickCount = options?.clickCount ?? 1;
+    await this.session.script.callFunction({
+      functionDeclaration: `function(el, clickCount) {
+				el.scrollIntoView({ block: "center", behavior: "instant" });
+				for (let i = 0; i < clickCount; i++) {
+					el.click();
+				}
+			}`,
+      target: { context: this.contextId },
+      arguments: [ref, { type: "number", value: clickCount }],
+      awaitPromise: false
+    });
+  }
+  /** Extract a string from a script evaluation result */
+  extractStringResult(result) {
+    if (result.type === "success" && result.result?.type === "string") {
+      return result.result.value;
+    }
+    return null;
+  }
+  /** Convert a BiDi RemoteValue back to a JS value */
+  deserializeRemoteValue(value) {
+    if (!value || typeof value !== "object") return value;
+    const v = value;
+    switch (v.type) {
+      case "undefined":
+        return void 0;
+      case "null":
+        return null;
+      case "string":
+        return v.value;
+      case "number": {
+        const n = v.value;
+        if (n === "NaN") return Number.NaN;
+        if (n === "-0") return -0;
+        if (n === "Infinity") return Number.POSITIVE_INFINITY;
+        if (n === "-Infinity") return Number.NEGATIVE_INFINITY;
+        return n;
+      }
+      case "boolean":
+        return v.value;
+      case "bigint":
+        return BigInt(v.value);
+      case "array": {
+        if (Array.isArray(v.value)) {
+          return v.value.map((item) => this.deserializeRemoteValue(item));
+        }
+        return [];
+      }
+      case "object": {
+        if (Array.isArray(v.value)) {
+          const obj = {};
+          for (const [key, val] of v.value) {
+            obj[key] = this.deserializeRemoteValue(val);
+          }
+          return obj;
+        }
+        return {};
+      }
+      default:
+        return v.value ?? null;
+    }
+  }
+};
+var ElementHandle = class {
+  /** @internal */
+  page;
+  /** @internal */
+  target;
+  constructor(page, target) {
+    this.page = page;
+    this.target = target;
+  }
+  /** Click this element */
+  async click(options) {
+    await this.page.click(this.target, options);
+  }
+  /** Fill this element with text */
+  async fill(value, options) {
+    await this.page.fill(this.target, value, options);
+  }
+  /** Get the visible text content of this element */
+  async textContent() {
+    const located = await this.locate();
+    const ref = this.getRef(located);
+    const result = await this.page.session.script.callFunction({
+      functionDeclaration: 'function(el) { return el.textContent || ""; }',
+      target: { context: this.page.contextId },
+      arguments: [ref],
+      awaitPromise: false
+    });
+    if (result.type === "success" && result.result?.type === "string") {
+      return result.result.value;
+    }
+    return "";
+  }
+  /** Get an attribute value */
+  async getAttribute(name) {
+    const located = await this.locate();
+    const ref = this.getRef(located);
+    const result = await this.page.session.script.callFunction({
+      functionDeclaration: `function(el, name) { return el.getAttribute(name); }`,
+      target: { context: this.page.contextId },
+      arguments: [ref, { type: "string", value: name }],
+      awaitPromise: false
+    });
+    if (result.type === "success" && result.result?.type === "string") {
+      return result.result.value;
+    }
+    return null;
+  }
+  /** Check if the element is visible on the page */
+  async isVisible() {
+    try {
+      const located = await this.locate(5e3);
+      const ref = this.getRef(located);
+      const result = await this.page.session.script.callFunction({
+        functionDeclaration: `function(el) {
+					const style = window.getComputedStyle(el);
+					const rect = el.getBoundingClientRect();
+					return style.display !== 'none' &&
+						style.visibility !== 'hidden' &&
+						style.opacity !== '0' &&
+						rect.width > 0 &&
+						rect.height > 0;
+				}`,
+        target: { context: this.page.contextId },
+        arguments: [ref],
+        awaitPromise: false
+      });
+      return result.type === "success" && result.result?.type === "boolean" && result.result.value === true;
+    } catch {
+      return false;
+    }
+  }
+  /** Count matching elements */
+  async count() {
+    const elements = await locateAllElements(this.page.session, this.page.contextId, this.target);
+    return elements.length;
+  }
+  /** Get the visible inner text (like element.innerText, not textContent) */
+  async innerText() {
+    const located = await this.locate();
+    const ref = this.getRef(located);
+    const result = await this.page.session.script.callFunction({
+      functionDeclaration: 'function(el) { return el.innerText || ""; }',
+      target: { context: this.page.contextId },
+      arguments: [ref],
+      awaitPromise: false
+    });
+    if (result.type === "success" && result.result?.type === "string") {
+      return result.result.value;
+    }
+    return "";
+  }
+  /** Get the innerHTML of this element */
+  async innerHTML() {
+    const located = await this.locate();
+    const ref = this.getRef(located);
+    const result = await this.page.session.script.callFunction({
+      functionDeclaration: 'function(el) { return el.innerHTML || ""; }',
+      target: { context: this.page.contextId },
+      arguments: [ref],
+      awaitPromise: false
+    });
+    if (result.type === "success" && result.result?.type === "string") {
+      return result.result.value;
+    }
+    return "";
+  }
+  /** Get the current value of an input/textarea/select */
+  async inputValue() {
+    const located = await this.locate();
+    const ref = this.getRef(located);
+    const result = await this.page.session.script.callFunction({
+      functionDeclaration: 'function(el) { return el.value ?? ""; }',
+      target: { context: this.page.contextId },
+      arguments: [ref],
+      awaitPromise: false
+    });
+    if (result.type === "success" && result.result?.type === "string") {
+      return result.result.value;
+    }
+    return "";
+  }
+  /** Check if the element is enabled (not disabled) */
+  async isEnabled() {
+    try {
+      const located = await this.locate(5e3);
+      const ref = this.getRef(located);
+      const result = await this.page.session.script.callFunction({
+        functionDeclaration: "function(el) { return !el.disabled; }",
+        target: { context: this.page.contextId },
+        arguments: [ref],
+        awaitPromise: false
+      });
+      return result.type === "success" && result.result?.type === "boolean" && result.result.value === true;
+    } catch {
+      return false;
+    }
+  }
+  /** Check if a checkbox/radio is checked */
+  async isChecked() {
+    try {
+      const located = await this.locate(5e3);
+      const ref = this.getRef(located);
+      const result = await this.page.session.script.callFunction({
+        functionDeclaration: "function(el) { return !!el.checked; }",
+        target: { context: this.page.contextId },
+        arguments: [ref],
+        awaitPromise: false
+      });
+      return result.type === "success" && result.result?.type === "boolean" && result.result.value === true;
+    } catch {
+      return false;
+    }
+  }
+  /** Get the bounding box of the element */
+  async boundingBox() {
+    try {
+      const located = await this.locate(5e3);
+      const ref = this.getRef(located);
+      const result = await this.page.session.script.callFunction({
+        functionDeclaration: `function(el) {
+					const rect = el.getBoundingClientRect();
+					return { x: rect.x, y: rect.y, width: rect.width, height: rect.height };
+				}`,
+        target: { context: this.page.contextId },
+        arguments: [ref],
+        awaitPromise: false
+      });
+      if (result.type === "success" && result.result?.type === "object") {
+        const val = result.result.value;
+        if (Array.isArray(val)) {
+          const map = new Map(val);
+          const extract = (key) => {
+            const v = map.get(key);
+            return typeof v === "object" && v !== null && "value" in v ? v.value : 0;
+          };
+          return { x: extract("x"), y: extract("y"), width: extract("width"), height: extract("height") };
+        }
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  /** Take a screenshot of just this element */
+  async screenshot() {
+    const located = await this.locate();
+    const ref = this.getRef(located);
+    await this.page.session.script.callFunction({
+      functionDeclaration: 'function(el) { el.scrollIntoView({ block: "center", behavior: "instant" }); }',
+      target: { context: this.page.contextId },
+      arguments: [ref],
+      awaitPromise: false
+    });
+    const box = await this.boundingBox();
+    if (!box || box.width === 0 || box.height === 0) {
+      throw new Error("Cannot screenshot element: element has no size or is not visible");
+    }
+    const result = await this.page.session.browsingContext.captureScreenshot({
+      context: this.page.contextId,
+      clip: {
+        type: "box",
+        x: box.x,
+        y: box.y,
+        width: box.width,
+        height: box.height
+      }
+    });
+    return Buffer.from(result.data, "base64");
+  }
+  /** Double-click this element */
+  async dblclick(options) {
+    await this.page.dblclick(this.target, options);
+  }
+  /** Hover over this element */
+  async hover(options) {
+    await this.page.hover(this.target, options);
+  }
+  /** Type text into this element character by character */
+  async type(text, options) {
+    await this.page.type(this.target, text, options);
+  }
+  /** Focus this element */
+  async focus(options) {
+    await this.page.focus(this.target, options);
+  }
+  /** Remove focus from this element */
+  async blur(options) {
+    await this.page.blur(this.target, options);
+  }
+  /** @internal Locate the element with auto-wait */
+  async locate(timeout) {
+    return locateElement(
+      this.page.session,
+      this.page.contextId,
+      this.target,
+      { timeout: timeout ?? 3e4 }
+    );
+  }
+  getRef(located) {
+    if (located.node.sharedId) {
+      return { sharedId: located.node.sharedId, handle: located.node.handle };
+    }
+    throw new Error("Element has no shared reference");
+  }
+};
+function mapKey(key) {
+  const keyMap = {
+    Enter: "\uE007",
+    Tab: "\uE004",
+    Escape: "\uE00C",
+    Backspace: "\uE003",
+    Delete: "\uE017",
+    ArrowUp: "\uE013",
+    ArrowDown: "\uE015",
+    ArrowLeft: "\uE012",
+    ArrowRight: "\uE014",
+    Home: "\uE011",
+    End: "\uE010",
+    PageUp: "\uE00E",
+    PageDown: "\uE00F",
+    Control: "\uE009",
+    Alt: "\uE00A",
+    Shift: "\uE008",
+    Meta: "\uE03D",
+    Space: " "
+  };
+  return keyMap[key] ?? key;
+}
+function parseMockPattern(pattern) {
+  const methodMatch = pattern.match(/^(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s+(.+)$/i);
+  if (methodMatch) {
+    const method = methodMatch[1].toUpperCase();
+    const path = methodMatch[2];
+    if (path.startsWith("http")) {
+      return { method, urlPattern: { type: "string", pattern: path } };
+    }
+    return { method, urlPattern: { type: "pattern", pathname: path } };
+  }
+  if (pattern.startsWith("http")) {
+    return { method: null, urlPattern: { type: "string", pattern } };
+  }
+  return { method: null, urlPattern: { type: "pattern", pathname: pattern } };
+}
+function buildMockHeaders(response) {
+  const headers = [];
+  let contentType = response.contentType;
+  if (!contentType) {
+    if (typeof response.body === "object" && response.body !== null) {
+      contentType = "application/json";
+    } else if (typeof response.body === "string") {
+      contentType = "text/plain";
+    }
+  }
+  if (contentType) {
+    headers.push({ name: "Content-Type", value: { type: "string", value: contentType } });
+  }
+  if (response.headers) {
+    for (const [name, value] of Object.entries(response.headers)) {
+      headers.push({ name, value: { type: "string", value } });
+    }
+  }
+  return headers;
+}
+function buildMockBody(response) {
+  if (response.body === void 0 || response.body === null) return null;
+  if (typeof response.body === "string") return response.body;
+  return JSON.stringify(response.body);
+}
+async function applyViewport(session, contextId, config) {
+  if (config.maximized && !config.headless) {
+    return;
+  }
+  if (config.headless) {
+    try {
+      await session.browsingContext.setViewport({
+        context: contextId,
+        viewport: config.viewport
+      });
+    } catch {
+    }
+    return;
+  }
+  try {
+    const { width, height } = config.viewport;
+    await session.script.callFunction({
+      functionDeclaration: `function(targetW, targetH) {
+				const chromeW = window.outerWidth - window.innerWidth;
+				const chromeH = window.outerHeight - window.innerHeight;
+				window.resizeTo(targetW + chromeW, targetH + chromeH);
+			}`,
+      target: { context: contextId },
+      arguments: [
+        { type: "number", value: width },
+        { type: "number", value: height }
+      ],
+      awaitPromise: false
+    });
+  } catch {
+    try {
+      await session.browsingContext.setViewport({
+        context: contextId,
+        viewport: config.viewport
+      });
+    } catch {
+    }
+  }
+}
+var Browser = class _Browser {
+  /** @internal */
+  session;
+  /** @internal */
+  config;
+  /** @internal */
+  pages = [];
+  constructor(session, config) {
+    this.session = session;
+    this.config = config;
+  }
+  /**
+   * Launch a new browser instance.
+   *
+   * ```ts
+   * const browser = await Browser.launch(); // Chrome, headless
+   * const browser = await Browser.launch({ browser: 'firefox', headless: false });
+   * ```
+   */
+  static async launch(userConfig) {
+    const config = resolveConfig(userConfig);
+    const sessionOptions = {
+      browser: config.browser,
+      headless: config.headless,
+      executablePath: config.executablePath,
+      debug: config.debug,
+      timeout: config.timeout,
+      maximized: config.maximized
+    };
+    const session = await browsecraftBidi.BiDiSession.launch(sessionOptions);
+    return new _Browser(session, config);
+  }
+  /**
+   * Connect to an already-running browser.
+   *
+   * ```ts
+   * const browser = await Browser.connect('ws://localhost:9222/session');
+   * ```
+   */
+  static async connect(wsEndpoint, userConfig) {
+    const config = resolveConfig(userConfig);
+    const session = await browsecraftBidi.BiDiSession.connect(wsEndpoint);
+    return new _Browser(session, config);
+  }
+  /**
+   * Create a new page (tab).
+   *
+   * ```ts
+   * const page = await browser.newPage();
+   * await page.goto('https://example.com');
+   * ```
+   */
+  async newPage() {
+    const result = await this.session.browsingContext.create({ type: "tab" });
+    const contextId = result.context;
+    await applyViewport(this.session, contextId, this.config);
+    const page = new Page(this.session, contextId, this.config);
+    this.pages.push(page);
+    this.session.on("browsingContext.closed", (event) => {
+      const params = event.params;
+      if (params.context === contextId) {
+        const idx = this.pages.indexOf(page);
+        if (idx !== -1) this.pages.splice(idx, 1);
+      }
+    });
+    return page;
+  }
+  /** Get all open pages. */
+  get openPages() {
+    return [...this.pages];
+  }
+  /**
+   * Create an isolated browser context (like incognito).
+   * Returns a BrowserContext that can create its own pages.
+   */
+  async newContext() {
+    try {
+      const result = await this.session.send("browser.createUserContext", {});
+      const userContext = result.userContext;
+      return new BrowserContext(this.session, this.config, userContext);
+    } catch (err) {
+      console.warn(
+        "[browsecraft] Warning: browser.createUserContext is not supported. Pages will share cookies/storage. " + (err instanceof Error ? err.message : String(err))
+      );
+      return new BrowserContext(this.session, this.config, null);
+    }
+  }
+  /** Close the browser and clean up all resources. */
+  async close() {
+    for (const page of this.pages) {
+      await page.close().catch(() => {
+      });
+    }
+    this.pages = [];
+    await this.session.close();
+  }
+  /** Whether the browser is still connected */
+  get isConnected() {
+    return this.session.isConnected;
+  }
+  /** Get the resolved config */
+  getConfig() {
+    return { ...this.config };
+  }
+};
+var BrowserContext = class {
+  /** @internal */
+  session;
+  /** @internal */
+  config;
+  /** @internal */
+  userContext;
+  /** @internal */
+  pages = [];
+  constructor(session, config, userContext) {
+    this.session = session;
+    this.config = config;
+    this.userContext = userContext;
+  }
+  /** Create a new page in this context. */
+  async newPage() {
+    const params = { type: "tab" };
+    if (this.userContext) {
+      params.userContext = this.userContext;
+    }
+    const result = await this.session.browsingContext.create(params);
+    const contextId = result.context;
+    await applyViewport(this.session, contextId, this.config);
+    const page = new Page(this.session, contextId, this.config);
+    this.pages.push(page);
+    return page;
+  }
+  /** Close this context and all its pages. */
+  async close() {
+    for (const page of this.pages) {
+      await page.close().catch(() => {
+      });
+    }
+    this.pages = [];
+    if (this.userContext) {
+      await this.session.send("browser.removeUserContext", {
+        userContext: this.userContext
+      }).catch(() => {
+      });
+    }
+  }
+};
+var testRegistry = [];
+var suiteStack = [];
+var executedBeforeAllHooks = /* @__PURE__ */ new Set();
+var executedAfterAllHooks = /* @__PURE__ */ new Set();
+function test(title, fnOrOptions, maybeFn) {
+  const fn = typeof fnOrOptions === "function" ? fnOrOptions : maybeFn;
+  const options = typeof fnOrOptions === "function" ? {} : fnOrOptions;
+  testRegistry.push({
+    title,
+    fn,
+    options,
+    suitePath: [...suiteStack],
+    skip: false,
+    only: false
+  });
+}
+test.skip = function skipTest(title, fn) {
+  testRegistry.push({
+    title,
+    fn,
+    options: {},
+    suitePath: [...suiteStack],
+    skip: true,
+    only: false
+  });
+};
+test.only = function onlyTest(title, fn) {
+  testRegistry.push({
+    title,
+    fn,
+    options: {},
+    suitePath: [...suiteStack],
+    skip: false,
+    only: true
+  });
+};
+function describe(title, fn) {
+  suiteStack.push(title);
+  fn();
+  suiteStack.pop();
+}
+describe.skip = function skipDescribe(title, fn) {
+  suiteStack.push(title);
+  const startIndex = testRegistry.length;
+  fn();
+  for (let i = startIndex; i < testRegistry.length; i++) {
+    testRegistry[i].skip = true;
+  }
+  suiteStack.pop();
+};
+describe.only = function onlyDescribe(title, fn) {
+  suiteStack.push(title);
+  const startIndex = testRegistry.length;
+  fn();
+  for (let i = startIndex; i < testRegistry.length; i++) {
+    testRegistry[i].only = true;
+  }
+  suiteStack.pop();
+};
+var hooks = {
+  beforeAll: [],
+  afterAll: [],
+  beforeEach: [],
+  afterEach: []
+};
+function beforeAll(fn) {
+  hooks.beforeAll.push({ fn, suitePath: [...suiteStack] });
+}
+function afterAll(fn) {
+  hooks.afterAll.push({ fn, suitePath: [...suiteStack] });
+}
+function beforeEach(fn) {
+  hooks.beforeEach.push({ fn, suitePath: [...suiteStack] });
+}
+function afterEach(fn) {
+  hooks.afterEach.push({ fn, suitePath: [...suiteStack] });
+}
+async function runTest(testCase, sharedBrowser, userConfig) {
+  const startTime = Date.now();
+  const config = resolveConfig(userConfig);
+  if (testCase.skip) {
+    return {
+      title: testCase.title,
+      suitePath: testCase.suitePath,
+      status: "skipped",
+      duration: 0
+    };
+  }
+  let browser;
+  let context;
+  let page;
+  try {
+    browser = sharedBrowser ?? await Browser.launch();
+    context = await browser.newContext();
+    page = await context.newPage();
+    const fixtures = { page, context, browser };
+    const applicableBeforeAll = hooks.beforeAll.filter(
+      (h) => isHookApplicable(h.suitePath, testCase.suitePath)
+    );
+    for (const hook of applicableBeforeAll) {
+      const hookKey = `${hook.suitePath.join(">")}:${hooks.beforeAll.indexOf(hook)}`;
+      if (!executedBeforeAllHooks.has(hookKey)) {
+        await hook.fn(fixtures);
+        executedBeforeAllHooks.add(hookKey);
+      }
+    }
+    const applicableBeforeEach = hooks.beforeEach.filter(
+      (h) => isHookApplicable(h.suitePath, testCase.suitePath)
+    );
+    for (const hook of applicableBeforeEach) {
+      await hook.fn(fixtures);
+    }
+    const timeout = testCase.options.timeout ?? config.timeout;
+    await Promise.race([
+      testCase.fn(fixtures),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error(`Test timed out after ${timeout}ms`)), timeout)
+      )
+    ]);
+    const applicableAfterEach = hooks.afterEach.filter(
+      (h) => isHookApplicable(h.suitePath, testCase.suitePath)
+    );
+    for (const hook of applicableAfterEach) {
+      await hook.fn(fixtures);
+    }
+    let screenshotPath;
+    if (config.screenshot === "always" && page) {
+      screenshotPath = await captureScreenshot(page, testCase, config.outputDir).catch(() => void 0);
+    }
+    const duration = Date.now() - startTime;
+    return {
+      title: testCase.title,
+      suitePath: testCase.suitePath,
+      status: "passed",
+      duration,
+      screenshotPath
+    };
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    let screenshotPath;
+    if ((config.screenshot === "on-failure" || config.screenshot === "always") && page) {
+      screenshotPath = await captureScreenshot(page, testCase, config.outputDir).catch(() => void 0);
+    }
+    return {
+      title: testCase.title,
+      suitePath: testCase.suitePath,
+      status: "failed",
+      duration,
+      error: error instanceof Error ? error : new Error(String(error)),
+      screenshotPath
+    };
+  } finally {
+    await context?.close().catch(() => {
+    });
+    if (!sharedBrowser && browser) {
+      await browser.close().catch(() => {
+      });
+    }
+  }
+}
+async function runAfterAllHooks(suitePath, fixtures) {
+  const applicableAfterAll = hooks.afterAll.filter(
+    (h) => isHookApplicable(h.suitePath, suitePath)
+  );
+  for (const hook of applicableAfterAll) {
+    const hookKey = `${hook.suitePath.join(">")}:${hooks.afterAll.indexOf(hook)}`;
+    if (!executedAfterAllHooks.has(hookKey)) {
+      await hook.fn(fixtures);
+      executedAfterAllHooks.add(hookKey);
+    }
+  }
+}
+function resetTestState() {
+  testRegistry.length = 0;
+  hooks.beforeAll.length = 0;
+  hooks.afterAll.length = 0;
+  hooks.beforeEach.length = 0;
+  hooks.afterEach.length = 0;
+  executedBeforeAllHooks.clear();
+  executedAfterAllHooks.clear();
+  suiteStack.length = 0;
+}
+function isHookApplicable(hookSuitePath, testSuitePath) {
+  if (hookSuitePath.length === 0) return true;
+  if (hookSuitePath.length > testSuitePath.length) return false;
+  return hookSuitePath.every((s, i) => testSuitePath[i] === s);
+}
+async function captureScreenshot(page, testCase, outputDir) {
+  const parts = [...testCase.suitePath, testCase.title];
+  const safeName = parts.join("-").replace(/[^a-zA-Z0-9_-]/g, "_").replace(/_+/g, "_").slice(0, 200);
+  const timestamp = Date.now();
+  const filename = `${safeName}-${timestamp}.png`;
+  const screenshotDir = path.join(outputDir, "screenshots");
+  await promises.mkdir(screenshotDir, { recursive: true });
+  const buffer = await page.screenshot();
+  const filePath = path.join(screenshotDir, filename);
+  await promises.writeFile(filePath, buffer);
+  return filePath;
+}
+
+exports.Browser = Browser;
+exports.BrowserContext = BrowserContext;
+exports.ElementHandle = ElementHandle;
+exports.Page = Page;
+exports.afterAll = afterAll;
+exports.afterEach = afterEach;
+exports.beforeAll = beforeAll;
+exports.beforeEach = beforeEach;
+exports.defineConfig = defineConfig;
+exports.describe = describe;
+exports.resetTestState = resetTestState;
+exports.resolveConfig = resolveConfig;
+exports.runAfterAllHooks = runAfterAllHooks;
+exports.runTest = runTest;
+exports.test = test;
+exports.testRegistry = testRegistry;
+//# sourceMappingURL=chunk-KIPQFK3Y.cjs.map
+//# sourceMappingURL=chunk-KIPQFK3Y.cjs.map