@ricsam/r5d-browser 0.0.136 → 0.0.138

package/dist/cjs/browser-runtime.cjs

@@ -1,708 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var browser_runtime_exports = {};
-__export(browser_runtime_exports, {
-  BrowserRuntime: () => BrowserRuntime
-});
-module.exports = __toCommonJS(browser_runtime_exports);
-var import_node_fs = __toESM(require("node:fs"), 1);
-var import_node_path = __toESM(require("node:path"), 1);
-var import_browser_input = require("./browser-input.cjs");
-var import_upload_store = require("./upload-store.cjs");
-var import_browser_upload = require("@ricsam/r5d-api/browser-upload");
-var import_password_safe_snapshot = require("./password-safe-snapshot.cjs");
-const MAX_DOWNLOAD_CHUNK_BYTES = 1024 * 1024;
-const MAX_RUN_JS_RESULT_BYTES = 1024 * 1024;
-const MAX_RUN_JS_ARTIFACT_BYTES = 4 * 1024 * 1024;
-const MAX_RUN_JS_ARTIFACT_COUNT = 32;
-const REF_ACTION_TIMEOUT_MS = 5e3;
-const NAVIGATION_TIMEOUT_MS = 2e4;
-const READ_PAGE_TIMEOUT_MS = 1e4;
-const MAX_FULL_PAGE_HEIGHT = 4e3;
-const MAX_FULL_PAGE_WIDTH = 4096;
-const MAX_TYPED_KEYS_CHARS = 500;
-const MAX_TYPED_KEYS_TOTAL_MS = 2e4;
-function clampInt(value, min, max, fallback) {
-  const num = value === void 0 ? fallback : Number(value);
-  if (!Number.isFinite(num)) return fallback;
-  return Math.min(max, Math.max(min, Math.round(num)));
-}
-function requireRef(value) {
-  if (typeof value !== "string" || !/^(f\d+)?e\d+$/.test(value)) {
-    throw new Error('ref must look like "e12" or "f1e3", exactly as printed by browser_read_page ([ref=e12]).');
-  }
-  return value;
-}
-function stripCallLog(message) {
-  const withoutCallLog = message.split(/\n\s*Call log:/)[0] ?? message;
-  return withoutCallLog.split("\n").filter((line) => !/^\s+at\s/.test(line)).join("\n").trim();
-}
-function isDestroyedContext(message) {
-  return /Execution context was destroyed|because of a navigation|Cannot find context with specified id|Target closed/i.test(message);
-}
-function refActionError(error, ref, verb) {
-  const message = stripCallLog(error instanceof Error ? error.message : String(error));
-  return new Error(
-    `${message}
-Ref ${ref} comes from the most recent browser_read_page snapshot of this tab. If the page navigated or re-rendered since, take a new snapshot and retry. If another element covers the target, dismiss the overlay before the ${verb}.`
-  );
-}
-class BrowserRuntime {
-  constructor(context, downloadsPath, uploadsPath = `${downloadsPath}.uploads`) {
-    this.context = context;
-    this.downloadsPath = downloadsPath;
-    this.uploads = new import_upload_store.BrowserUploadStore(uploadsPath, (target) => {
-      void target.dispose().catch(() => void 0);
-    });
-    import_node_fs.default.mkdirSync(downloadsPath, { recursive: true });
-    for (const page of context.pages()) this.track(page);
-    context.on("page", (page) => this.track(page));
-  }
-  context;
-  downloadsPath;
-  ids = /* @__PURE__ */ new WeakMap();
-  pages = /* @__PURE__ */ new Map();
-  cursor = /* @__PURE__ */ new Map();
-  viewportSessions = /* @__PURE__ */ new Map();
-  uploads;
-  downloadSaveQueue = Promise.resolve();
-  track(page) {
-    const existing = this.ids.get(page);
-    if (existing) return existing;
-    const id = crypto.randomUUID();
-    this.ids.set(page, id);
-    this.pages.set(id, page);
-    page.on("download", (download) => {
-      this.downloadSaveQueue = this.downloadSaveQueue.then(() => this.persistDownload(download)).catch((error) => {
-        process.stderr.write(`[r5d-browser] failed to save download: ${error instanceof Error ? error.message : String(error)}
-`);
-      });
-    });
-    page.once("close", () => {
-      this.uploads.closeTab(id);
-      this.pages.delete(id);
-      this.cursor.delete(id);
-      this.viewportSessions.delete(id);
-    });
-    return id;
-  }
-  safeDownloadFilename(suggestedFilename) {
-    const basename = import_node_path.default.basename(suggestedFilename).replace(/[\\/\0]/g, "-").trim();
-    if (!basename || basename === "." || basename === "..") return "download";
-    const extension = import_node_path.default.extname(basename).slice(0, 30);
-    let stem = basename.slice(0, basename.length - import_node_path.default.extname(basename).length) || "download";
-    while (Buffer.byteLength(`${stem}${extension}`) > 200) stem = stem.slice(0, -1);
-    return `${stem || "download"}${extension}`;
-  }
-  availableDownloadPath(suggestedFilename) {
-    const filename = this.safeDownloadFilename(suggestedFilename);
-    const extension = import_node_path.default.extname(filename);
-    const stem = filename.slice(0, filename.length - extension.length) || "download";
-    for (let suffix = 1; ; suffix += 1) {
-      const candidate = suffix === 1 ? filename : `${stem}-${suffix}${extension}`;
-      const candidatePath = import_node_path.default.join(this.downloadsPath, candidate);
-      if (!import_node_fs.default.existsSync(candidatePath)) return candidatePath;
-    }
-  }
-  async persistDownload(download) {
-    const failure = await download.failure();
-    if (failure) throw new Error(failure);
-    const targetPath = this.availableDownloadPath(download.suggestedFilename());
-    await download.saveAs(targetPath);
-    process.stdout.write(`[r5d-browser] downloaded ${import_node_path.default.basename(targetPath)}
-`);
-  }
-  downloadId(filename) {
-    return Buffer.from(filename, "utf8").toString("base64url");
-  }
-  resolveDownload(downloadId) {
-    if (typeof downloadId !== "string" || !downloadId) throw new Error("downloadId is required.");
-    const filename = Buffer.from(downloadId, "base64url").toString("utf8");
-    if (this.downloadId(filename) !== downloadId || filename !== import_node_path.default.basename(filename) || filename.includes("\0")) {
-      throw new Error("Invalid downloadId.");
-    }
-    const filePath = import_node_path.default.join(this.downloadsPath, filename);
-    let stats;
-    try {
-      stats = import_node_fs.default.lstatSync(filePath);
-    } catch {
-      throw new Error(`Browser download ${downloadId} no longer exists.`);
-    }
-    if (!stats.isFile() || stats.isSymbolicLink()) throw new Error("Browser download is not a regular file.");
-    return { filename, filePath, stats };
-  }
-  async listDownloads() {
-    await this.downloadSaveQueue;
-    return import_node_fs.default.readdirSync(this.downloadsPath, { withFileTypes: true }).flatMap((entry) => {
-      if (!entry.isFile() || entry.name.startsWith(".")) return [];
-      const { filename, stats } = this.resolveDownload(this.downloadId(entry.name));
-      return [
-        {
-          downloadId: this.downloadId(filename),
-          filename,
-          size: stats.size,
-          modifiedAt: stats.mtime.toISOString()
-        }
-      ];
-    }).sort((left, right) => right.modifiedAt.localeCompare(left.modifiedAt) || left.filename.localeCompare(right.filename));
-  }
-  async getDownloadChunk(input) {
-    await this.downloadSaveQueue;
-    const { filename, filePath, stats } = this.resolveDownload(input.downloadId);
-    const offset = input.offset === void 0 ? 0 : Number(input.offset);
-    const requestedBytes = input.maxBytes === void 0 ? MAX_DOWNLOAD_CHUNK_BYTES : Number(input.maxBytes);
-    if (!Number.isSafeInteger(offset) || offset < 0 || offset > stats.size) throw new Error("Invalid download offset.");
-    if (!Number.isSafeInteger(requestedBytes) || requestedBytes < 1) throw new Error("Invalid download chunk size.");
-    const chunkSize = Math.min(requestedBytes, MAX_DOWNLOAD_CHUNK_BYTES, stats.size - offset);
-    const bytes = Buffer.alloc(chunkSize);
-    const handle = import_node_fs.default.openSync(filePath, import_node_fs.default.constants.O_RDONLY | import_node_fs.default.constants.O_NOFOLLOW);
-    let bytesRead = 0;
-    try {
-      const openedStats = import_node_fs.default.fstatSync(handle);
-      if (!openedStats.isFile() || openedStats.dev !== stats.dev || openedStats.ino !== stats.ino) {
-        throw new Error("Browser download changed before it could be read.");
-      }
-      bytesRead = import_node_fs.default.readSync(handle, bytes, 0, chunkSize, offset);
-      const completedStats = import_node_fs.default.fstatSync(handle);
-      if (completedStats.size !== stats.size || completedStats.mtimeMs !== stats.mtimeMs) {
-        throw new Error("Browser download changed while it was being read.");
-      }
-    } finally {
-      import_node_fs.default.closeSync(handle);
-    }
-    const nextOffset = offset + bytesRead;
-    return {
-      downloadId: this.downloadId(filename),
-      filename,
-      size: stats.size,
-      modifiedAt: stats.mtime.toISOString(),
-      offset,
-      nextOffset,
-      eof: nextOffset === stats.size,
-      base64: bytes.subarray(0, bytesRead).toString("base64")
-    };
-  }
-  page(tabId) {
-    if (typeof tabId !== "string") throw new Error("tabId is required.");
-    const page = this.pages.get(tabId);
-    if (!page || page.isClosed()) throw new Error(`Browser tab ${tabId} is no longer open.`);
-    return page;
-  }
-  refLocator(page, ref) {
-    return page.locator(`aria-ref=${ref}`);
-  }
-  async gotoSettled(page, url) {
-    try {
-      await page.goto(url, { waitUntil: "domcontentloaded", timeout: NAVIGATION_TIMEOUT_MS });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      if (!/ERR_ABORTED|interrupted by another navigation/i.test(message)) throw new Error(stripCallLog(message));
-      await page.waitForLoadState("domcontentloaded", { timeout: 5e3 }).catch(() => void 0);
-    }
-  }
-  async tabInfo(page) {
-    const tabId = this.track(page);
-    let windowId = "unknown";
-    try {
-      const cdp = await this.context.newCDPSession(page);
-      const result = await cdp.send("Browser.getWindowForTarget");
-      windowId = String(result.windowId);
-      await cdp.detach();
-    } catch {
-    }
-    return { tabId, windowId, title: await page.title().catch(() => ""), url: page.url() };
-  }
-  async listTabs() {
-    return await Promise.all([...this.pages.values()].filter((page) => !page.isClosed()).map((page) => this.tabInfo(page)));
-  }
-  async drainDownloads() {
-    await this.downloadSaveQueue;
-  }
-  async setViewport(page, tabId, viewport) {
-    const existing = this.viewportSessions.get(tabId);
-    if (viewport) {
-      const cdp = existing ?? await this.context.newCDPSession(page);
-      try {
-        await cdp.send("Emulation.setDeviceMetricsOverride", { ...viewport, deviceScaleFactor: 0, mobile: false });
-        this.viewportSessions.set(tabId, cdp);
-      } catch (error) {
-        if (!existing) await cdp.detach().catch(() => void 0);
-        throw error;
-      }
-    } else if (existing) {
-      await existing.send("Emulation.clearDeviceMetricsOverride");
-      this.viewportSessions.delete(tabId);
-      await existing.detach().catch(() => void 0);
-    }
-    this.cursor.delete(tabId);
-    if (viewport) {
-      const ready = await page.waitForFunction(
-        ({ width, height }) => window.innerWidth === width && window.innerHeight === height,
-        viewport,
-        { timeout: 5e3 }
-      );
-      await ready.dispose();
-    }
-    const actual = await page.evaluate(() => ({ width: window.innerWidth, height: window.innerHeight }));
-    return { tabId, ...actual, reset: viewport === null };
-  }
-  closeUploads() {
-    this.uploads.close();
-  }
-  async execute(action, input) {
-    input = (0, import_browser_input.normalizeBrowserInput)(action, input);
-    if (action === "upload_abort") {
-      this.uploads.abort(input.uploadId, input.tabId);
-      return { aborted: true };
-    }
-    if (action === "list_tabs") return { tabs: await this.listTabs() };
-    if (action === "list_downloads") return { downloads: await this.listDownloads() };
-    if (action === "get_download") return await this.getDownloadChunk(input);
-    if (action === "open_tab") {
-      const previous = this.context.pages().findLast((candidate) => !candidate.isClosed());
-      let page2;
-      if (previous) {
-        const cdp = await this.context.newCDPSession(previous);
-        const pagePromise = this.context.waitForEvent("page");
-        await cdp.send("Target.createTarget", {
-          url: "about:blank",
-          newWindow: input.disposition === "window",
-          background: true
-        });
-        page2 = await pagePromise;
-        await cdp.detach();
-        if (input.disposition === "window") {
-          const pageCdp = await this.context.newCDPSession(page2);
-          const { windowId } = await pageCdp.send("Browser.getWindowForTarget");
-          await pageCdp.send("Browser.setWindowBounds", { windowId, bounds: { windowState: "minimized" } });
-          await pageCdp.detach();
-        }
-      } else {
-        page2 = await this.context.newPage();
-      }
-      const url = typeof input.url === "string" ? input.url : "about:blank";
-      if (url !== "about:blank") await this.gotoSettled(page2, url);
-      return { tab: await this.tabInfo(page2) };
-    }
-    const page = this.page(input.tabId);
-    const tabId = input.tabId;
-    switch (action) {
-      case "close_tab":
-        await page.close();
-        return { closed: true, tabId };
-      case "navigate":
-        await this.gotoSettled(page, String(input.url));
-        return { tab: await this.tabInfo(page) };
-      case "set_viewport":
-        return await this.setViewport(page, tabId, (0, import_browser_input.parseViewportInput)(input));
-      case "read_page": {
-        const maxChars = clampInt(input.maxChars, 1e3, 2e5, 5e4);
-        const depth = input.depth === void 0 ? void 0 : clampInt(input.depth, 1, 50, 50);
-        const options = { mode: "ai", boxes: true, timeout: READ_PAGE_TIMEOUT_MS, ...depth === void 0 ? {} : { depth } };
-        let snapshot;
-        try {
-          snapshot = await (0, import_password_safe_snapshot.passwordSafeAriaSnapshot)(page, options);
-        } catch (error) {
-          const message = error instanceof Error ? error.message : String(error);
-          if (isDestroyedContext(message)) {
-            await page.waitForLoadState("domcontentloaded", { timeout: 5e3 }).catch(() => void 0);
-            snapshot = await (0, import_password_safe_snapshot.passwordSafeAriaSnapshot)(page, options);
-          } else if (/Timeout/i.test(message)) {
-            throw new Error(
-              `read_page timed out after ${READ_PAGE_TIMEOUT_MS}ms building the outline. The page is very large or busy; retry with a depth limit (e.g. depth: 10).`
-            );
-          } else {
-            throw new Error(stripCallLog(message));
-          }
-        }
-        let text = snapshot;
-        let truncated = false;
-        if (text.length > maxChars) {
-          const cut = text.lastIndexOf("\n", maxChars);
-          text = text.slice(0, cut > 0 ? cut : maxChars);
-          truncated = true;
-        }
-        return {
-          tabId,
-          url: page.url(),
-          title: await page.title().catch(() => ""),
-          text,
-          truncated,
-          ...truncated ? { note: `Truncated at ${maxChars} of ${snapshot.length} chars. Raise maxChars, pass depth for an overview, or scroll and re-read.` } : {}
-        };
-      }
-      case "screenshot": {
-        if (input.fullPage === true) {
-          const metrics = await page.evaluate(() => ({
-            // Match Playwright's full-page bounds, which exclude scrollbar gutters.
-            docWidth: Math.max(
-              document.documentElement.scrollWidth,
-              document.documentElement.offsetWidth,
-              document.documentElement.clientWidth,
-              document.body?.scrollWidth ?? 0,
-              document.body?.offsetWidth ?? 0,
-              document.body?.clientWidth ?? 0
-            ),
-            docHeight: Math.max(
-              document.documentElement.scrollHeight,
-              document.documentElement.offsetHeight,
-              document.documentElement.clientHeight,
-              document.body?.scrollHeight ?? 0,
-              document.body?.offsetHeight ?? 0,
-              document.body?.clientHeight ?? 0
-            )
-          }));
-          const width = Math.min(metrics.docWidth, MAX_FULL_PAGE_WIDTH);
-          const height = Math.min(metrics.docHeight, MAX_FULL_PAGE_HEIGHT);
-          const truncated = metrics.docHeight > MAX_FULL_PAGE_HEIGHT || metrics.docWidth > MAX_FULL_PAGE_WIDTH;
-          const bytes2 = truncated ? await page.screenshot({ type: "png", scale: "css", timeout: 15e3, fullPage: true, clip: { x: 0, y: 0, width, height } }) : await page.screenshot({ type: "png", scale: "css", timeout: 15e3, fullPage: true });
-          return { base64: bytes2.toString("base64"), width, height, fullPage: true, pageHeight: metrics.docHeight, truncated };
-        }
-        const bytes = await page.screenshot({ type: "png", scale: "css" });
-        const viewport = page.viewportSize();
-        const cursor = this.cursor.get(tabId);
-        return {
-          base64: bytes.toString("base64"),
-          width: viewport?.width ?? Number(await page.evaluate(() => window.innerWidth)),
-          height: viewport?.height ?? Number(await page.evaluate(() => window.innerHeight)),
-          cursorX: cursor?.x,
-          cursorY: cursor?.y
-        };
-      }
-      case "move_mouse": {
-        const x = Number(input.x);
-        const y = Number(input.y);
-        if (!Number.isFinite(x) || !Number.isFinite(y)) throw new Error("move_mouse requires numeric x and y coordinates.");
-        await page.mouse.move(x, y);
-        this.cursor.set(tabId, { x, y });
-        return { tabId, x, y };
-      }
-      case "mouse_click": {
-        const button = input.button === "middle" || input.button === "right" ? input.button : "left";
-        const clickCount = input.clickCount === 2 ? 2 : 1;
-        if (input.ref !== void 0) {
-          if (input.x !== void 0 || input.y !== void 0) throw new Error("mouse_click accepts ref or x/y, not both.");
-          const ref = requireRef(input.ref);
-          const locator = this.refLocator(page, ref);
-          try {
-            await locator.click({ button, clickCount, timeout: REF_ACTION_TIMEOUT_MS });
-          } catch (error) {
-            throw refActionError(error, ref, "click");
-          }
-          const box = await locator.boundingBox().catch(() => null);
-          if (box) this.cursor.set(tabId, { x: box.x + box.width / 2, y: box.y + box.height / 2 });
-          return {
-            tabId,
-            ref,
-            button,
-            clickCount,
-            ...box ? { x: Math.round(box.x + box.width / 2), y: Math.round(box.y + box.height / 2) } : {}
-          };
-        }
-        if (input.x !== void 0 || input.y !== void 0) {
-          const x = Number(input.x);
-          const y = Number(input.y);
-          if (!Number.isFinite(x) || !Number.isFinite(y)) throw new Error("mouse_click by coordinates requires numeric x and y.");
-          await page.mouse.move(x, y);
-          this.cursor.set(tabId, { x, y });
-          await page.mouse.click(x, y, { button, clickCount });
-          return { tabId, x, y, button, clickCount };
-        }
-        const cursor = this.cursor.get(tabId);
-        if (!cursor) throw new Error("Pass ref or x/y, or move the mouse in this tab before clicking.");
-        await page.mouse.click(cursor.x, cursor.y, { button, clickCount });
-        return { tabId, ...cursor, button };
-      }
-      case "scroll": {
-        if (input.ref !== void 0) {
-          if (input.direction !== void 0) throw new Error("scroll accepts ref or direction, not both.");
-          const ref = requireRef(input.ref);
-          const locator = this.refLocator(page, ref);
-          try {
-            await locator.scrollIntoViewIfNeeded({ timeout: REF_ACTION_TIMEOUT_MS });
-          } catch (error) {
-            throw refActionError(error, ref, "scroll");
-          }
-          const box = await locator.boundingBox().catch(() => null);
-          if (box) this.cursor.set(tabId, { x: box.x + box.width / 2, y: box.y + box.height / 2 });
-          return { tabId, ref, ...box ? { x: Math.round(box.x + box.width / 2), y: Math.round(box.y + box.height / 2) } : {} };
-        }
-        const direction = input.direction;
-        if (direction !== "up" && direction !== "down" && direction !== "left" && direction !== "right") {
-          throw new Error('scroll requires ref, or direction "up", "down", "left", or "right".');
-        }
-        const amount = clampInt(input.amount, 1, 2e4, 600);
-        let pointer;
-        if (input.x !== void 0 || input.y !== void 0) {
-          const x = Number(input.x);
-          const y = Number(input.y);
-          if (!Number.isFinite(x) || !Number.isFinite(y)) throw new Error("scroll requires numeric x and y when provided.");
-          pointer = { x, y };
-        } else {
-          pointer = this.cursor.get(tabId) ?? await page.evaluate(() => ({ x: Math.round(window.innerWidth / 2), y: Math.round(window.innerHeight / 2) }));
-        }
-        await page.mouse.move(pointer.x, pointer.y);
-        this.cursor.set(tabId, pointer);
-        const deltaX = direction === "left" ? -amount : direction === "right" ? amount : 0;
-        const deltaY = direction === "up" ? -amount : direction === "down" ? amount : 0;
-        await page.mouse.wheel(deltaX, deltaY);
-        return { tabId, direction, amount, ...pointer };
-      }
-      case "wait_for": {
-        const timeout = clampInt(input.timeoutMs, 500, 25e3, 1e4);
-        const provided = ["selector", "text", "url", "loadState"].filter((key) => input[key] !== void 0);
-        const condition = provided[0];
-        if (provided.length !== 1 || condition === void 0) {
-          throw new Error("wait_for requires exactly one of selector, text, url, or loadState.");
-        }
-        const state = input.state === "hidden" ? "hidden" : "visible";
-        const started = Date.now();
-        try {
-          if (typeof input.selector === "string") {
-            await page.locator(input.selector).first().waitFor({ state, timeout });
-          } else if (typeof input.text === "string") {
-            await page.getByText(input.text).first().waitFor({ state, timeout });
-          } else if (typeof input.url === "string") {
-            await page.waitForURL(input.url, { timeout, waitUntil: "domcontentloaded" });
-          } else if (input.loadState === "load" || input.loadState === "domcontentloaded" || input.loadState === "networkidle") {
-            await page.waitForLoadState(input.loadState, { timeout });
-          } else {
-            throw new Error('wait_for loadState must be "load", "domcontentloaded", or "networkidle".');
-          }
-        } catch (error) {
-          const message = error instanceof Error ? error.message : String(error);
-          if (!/Timeout|exceeded/i.test(message)) throw new Error(stripCallLog(message));
-          throw new Error(
-            `wait_for gave up after ${timeout}ms waiting for ${condition} ${JSON.stringify(input[condition])}${condition === "selector" || condition === "text" ? ` to become ${state}` : ""}. Current URL: ${page.url()}. Take a browser_read_page snapshot to see the actual page state.`
-          );
-        }
-        return { tabId, matched: true, elapsedMs: Date.now() - started, url: page.url(), title: await page.title().catch(() => "") };
-      }
-      case "upload_begin": {
-        const target = (0, import_browser_upload.parseUploadTarget)(input);
-        const locator = target.ref ? this.refLocator(page, target.ref) : page.locator(target.selector);
-        const element = await locator.elementHandle({ timeout: REF_ACTION_TIMEOUT_MS });
-        if (!element) throw new Error("File input was not found.");
-        try {
-          const info = await element.evaluate((el) => ({
-            fileInput: el instanceof HTMLInputElement && el.type === "file",
-            directory: el.hasAttribute("webkitdirectory"),
-            multiple: el.hasAttribute("multiple")
-          }));
-          if (!info.fileInput || info.directory) throw new Error("Target must be a file input (directory inputs are not supported).");
-          if (Array.isArray(input.files) && input.files.length > 1 && !info.multiple) throw new Error("This file input does not accept multiple files.");
-          this.uploads.begin(input.uploadId, tabId, input.files, element);
-          return { tabId, uploadId: input.uploadId };
-        } catch (error) {
-          await element.dispose().catch(() => void 0);
-          throw error;
-        }
-      }
-      case "upload_chunk":
-        this.uploads.append(input.uploadId, tabId, input.index, input.offset, input.base64);
-        return { tabId, uploadId: input.uploadId };
-      case "upload_attach": {
-        const upload = this.uploads.ready(input.uploadId, tabId, input.hashes);
-        if (!await upload.target.evaluate((el) => el.isConnected && el instanceof HTMLInputElement && el.type === "file")) {
-          throw new Error("The file input was removed or changed during the upload. Read the page again and retry.");
-        }
-        await upload.target.setInputFiles(upload.paths, { timeout: REF_ACTION_TIMEOUT_MS });
-        this.uploads.attached(input.uploadId, tabId);
-        return { tabId, files: upload.files };
-      }
-      case "form_input": {
-        const ref = requireRef(input.ref);
-        const provided = ["value", "values", "checked"].filter((key) => input[key] !== void 0);
-        if (provided.length !== 1) throw new Error("form_input requires exactly one of value, values, or checked.");
-        const locator = this.refLocator(page, ref);
-        let info;
-        try {
-          info = await locator.evaluate(
-            (el) => {
-              const tag = el.tagName.toLowerCase();
-              if (el instanceof HTMLSelectElement) {
-                return {
-                  kind: el.multiple ? "multiselect" : "select",
-                  tag,
-                  options: [...el.options].map((option) => ({ value: option.value, label: option.label.trim() }))
-                };
-              }
-              if (el instanceof HTMLInputElement && (el.type === "checkbox" || el.type === "radio")) return { kind: "checkable", tag };
-              if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) return { kind: "text", tag };
-              if (el instanceof HTMLElement && el.isContentEditable) return { kind: "contenteditable", tag };
-              return { kind: "other", tag };
-            },
-            void 0,
-            { timeout: REF_ACTION_TIMEOUT_MS }
-          );
-        } catch (error) {
-          throw refActionError(error, ref, "form_input");
-        }
-        const expectField = (field) => {
-          if (provided[0] !== field) throw new Error(`Ref ${ref} is a ${info.kind} (${info.tag}); pass ${field}, not ${provided[0]}.`);
-        };
-        const matchOption = (entry) => {
-          const match = info.options.find((option) => option.value === entry) ?? info.options.find((option) => option.label === entry.trim());
-          if (!match) {
-            const available = info.options.slice(0, 20).map((option) => `${JSON.stringify(option.label)} (value ${JSON.stringify(option.value)})`).join(", ");
-            throw new Error(`No option matches ${JSON.stringify(entry)}. Available: ${available}`);
-          }
-          return match.value;
-        };
-        try {
-          switch (info.kind) {
-            case "select": {
-              expectField("value");
-              await locator.selectOption(matchOption(input.value), { timeout: REF_ACTION_TIMEOUT_MS });
-              break;
-            }
-            case "multiselect": {
-              expectField("values");
-              const entries = input.values;
-              if (!Array.isArray(entries) || entries.some((entry) => typeof entry !== "string")) {
-                throw new Error("form_input values must be an array of strings.");
-              }
-              await locator.selectOption(entries.map((entry) => matchOption(entry)), { timeout: REF_ACTION_TIMEOUT_MS });
-              break;
-            }
-            case "checkable":
-              expectField("checked");
-              await locator.setChecked(input.checked === true, { timeout: REF_ACTION_TIMEOUT_MS });
-              break;
-            case "text":
-            case "contenteditable":
-              expectField("value");
-              await locator.fill(input.value, { timeout: REF_ACTION_TIMEOUT_MS });
-              break;
-            default:
-              throw new Error(
-                `Ref ${ref} (${info.tag}) does not accept direct value input. Click it with browser_mouse_click and type with browser_keyboard_type mode "keys".`
-              );
-          }
-        } catch (error) {
-          if (error instanceof Error && !/Timeout|exceeded|waiting for/i.test(error.message)) throw error;
-          throw refActionError(error, ref, "form_input");
-        }
-        return { tabId, ref, kind: info.kind };
-      }
-      case "keyboard": {
-        const keys = Array.isArray(input.keys) ? input.keys : [];
-        const modifiers = Array.isArray(input.modifiers) ? input.modifiers.filter((value) => typeof value === "string") : [];
-        for (const modifier of modifiers) await page.keyboard.down(modifier);
-        try {
-          for (const key of keys) {
-            if (typeof key !== "string") throw new Error("keyboard keys must all be strings.");
-            await page.keyboard.press(key);
-          }
-        } finally {
-          for (const modifier of modifiers.toReversed()) await page.keyboard.up(modifier);
-        }
-        return { tabId, keys, modifiers };
-      }
-      case "keyboard_type": {
-        if (typeof input.text !== "string") throw new Error("keyboard_type requires text.");
-        if (input.mode === "keys") {
-          if (input.text.length > MAX_TYPED_KEYS_CHARS) {
-            throw new Error(
-              `keyboard_type mode "keys" is limited to ${MAX_TYPED_KEYS_CHARS} characters per call; split the text or use the default insert mode.`
-            );
-          }
-          const delay = clampInt(input.delayMs, 0, 100, 20);
-          if (input.text.length * delay > MAX_TYPED_KEYS_TOTAL_MS) {
-            throw new Error(`text.length x delayMs must stay at or below ${MAX_TYPED_KEYS_TOTAL_MS}ms; lower delayMs or split the text.`);
-          }
-          await page.keyboard.type(input.text, { delay });
-          return { tabId, characters: input.text.length, mode: "keys" };
-        }
-        await page.keyboard.insertText(input.text);
-        return { tabId, characters: input.text.length };
-      }
-      case "run_js": {
-        if (typeof input.code !== "string") throw new Error("run_js requires code.");
-        let evaluated;
-        try {
-          evaluated = await page.evaluate(
-            async ({ code, maxBytes, maxCount }) => {
-              const artifacts = [];
-              let totalBytes = 0;
-              const r5dCreateArtifact = (filename, content) => {
-                if (typeof filename !== "string" || !filename.trim()) {
-                  throw new TypeError("r5dCreateArtifact(filename, content): filename must be a non-empty string.");
-                }
-                if (typeof content !== "string") {
-                  throw new TypeError(
-                    `r5dCreateArtifact(${JSON.stringify(filename)}, content): content must be a string. Use JSON.stringify(value) for objects.`
-                  );
-                }
-                if (artifacts.length >= maxCount) {
-                  throw new RangeError(`r5dCreateArtifact: at most ${maxCount} artifacts can be created in one browser_run_js call.`);
-                }
-                totalBytes += new TextEncoder().encode(content).length;
-                if (totalBytes > maxBytes) {
-                  throw new RangeError(`r5dCreateArtifact: artifact content exceeded the ${maxBytes} byte budget for one browser_run_js call.`);
-                }
-                artifacts.push({ filename, content });
-                return filename;
-              };
-              const invoke = new Function("r5dCreateArtifact", `"use strict"; return (async () => {
-${code}
-})()`);
-              try {
-                return { result: await invoke(r5dCreateArtifact), artifacts };
-              } catch (error) {
-                if (artifacts.length === 0) throw error;
-                return { artifacts, failure: error instanceof Error ? error.message : String(error) };
-              }
-            },
-            { code: input.code, maxBytes: MAX_RUN_JS_ARTIFACT_BYTES, maxCount: MAX_RUN_JS_ARTIFACT_COUNT }
-          );
-        } catch (error) {
-          const message = error instanceof Error ? error.message : String(error);
-          if (isDestroyedContext(message)) {
-            throw new Error(
-              "The page navigated or reloaded while the script was running, destroying its JavaScript context. The script was NOT retried because it may have side effects \u2014 if part of it ran (clicks, submits), verify the page state with browser_read_page before repeating anything. Wait out navigations with browser_wait_for, or restructure the script so navigation-triggering actions come last."
-            );
-          }
-          throw new Error(stripCallLog(message));
-        }
-        const serialized = JSON.stringify(evaluated.result);
-        if (serialized && Buffer.byteLength(serialized) > MAX_RUN_JS_RESULT_BYTES) {
-          throw new Error("Browser JavaScript result exceeded the 1 MiB limit.");
-        }
-        return { tabId, result: evaluated.result, artifacts: evaluated.artifacts, failure: evaluated.failure };
-      }
-      default:
-        throw new Error(`Unsupported browser operation: ${action}`);
-    }
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BrowserRuntime
-});