@pedropaulovc/playwright 1.59.0-next

package/lib/mcp/browser/response.js

@@ -0,0 +1,278 @@
+"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 response_exports = {};
+__export(response_exports, {
+  Response: () => Response,
+  parseResponse: () => parseResponse,
+  renderTabMarkdown: () => renderTabMarkdown,
+  renderTabsMarkdown: () => renderTabsMarkdown,
+  requestDebug: () => requestDebug
+});
+module.exports = __toCommonJS(response_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_utilsBundle = require("playwright-core/lib/utilsBundle");
+var import_tab = require("./tab");
+var import_utils = require("./tools/utils");
+const requestDebug = (0, import_utilsBundle.debug)("pw:mcp:request");
+class Response {
+  constructor(ordinal, context, toolName, toolArgs) {
+    this._results = [];
+    this._errors = [];
+    this._code = [];
+    this._images = [];
+    this._includeSnapshot = "none";
+    this._ordinal = ordinal;
+    this._context = context;
+    this.toolName = toolName;
+    this.toolArgs = toolArgs;
+  }
+  static {
+    this._ordinal = 0;
+  }
+  static create(context, toolName, toolArgs) {
+    return new Response(++Response._ordinal, context, toolName, toolArgs);
+  }
+  addTextResult(result) {
+    this._results.push({ text: result });
+  }
+  async addResult(result) {
+    if (result.data && !result.suggestedFilename)
+      result.suggestedFilename = (0, import_utils.dateAsFileName)(result.ext ?? "bin");
+    if (this._context.config.outputMode === "file") {
+      if (!result.suggestedFilename)
+        result.suggestedFilename = (0, import_utils.dateAsFileName)(result.ext ?? (result.text ? "txt" : "bin"));
+    }
+    const entry = { text: result.text, data: result.data, title: result.title };
+    if (result.suggestedFilename)
+      entry.filename = await this._context.outputFile(result.suggestedFilename, { origin: "llm", title: result.title ?? "Saved result" });
+    this._results.push(entry);
+    return { fileName: entry.filename };
+  }
+  addError(error) {
+    this._errors.push(error);
+  }
+  addCode(code) {
+    this._code.push(code);
+  }
+  addImage(image) {
+    this._images.push(image);
+  }
+  setIncludeSnapshot() {
+    this._includeSnapshot = this._context.config.snapshot.mode;
+  }
+  setIncludeFullSnapshot(includeSnapshotFileName) {
+    this._includeSnapshot = "full";
+    this._includeSnapshotFileName = includeSnapshotFileName;
+  }
+  async build() {
+    const rootPath = this._context.firstRootPath();
+    const sections = [];
+    const addSection = (title) => {
+      const section = { title, content: [] };
+      sections.push(section);
+      return section.content;
+    };
+    if (this._errors.length) {
+      const text = addSection("Error");
+      text.push("### Error");
+      text.push(this._errors.join("\n"));
+    }
+    if (this._results.length) {
+      const text = addSection("Result");
+      for (const result of this._results) {
+        if (result.filename) {
+          text.push(`- [${result.title}](${rootPath ? import_path.default.relative(rootPath, result.filename) : result.filename})`);
+          if (result.data)
+            await import_fs.default.promises.writeFile(result.filename, result.data);
+          else if (result.text)
+            await import_fs.default.promises.writeFile(result.filename, this._redactText(result.text));
+        } else if (result.text) {
+          text.push(result.text);
+        }
+      }
+    }
+    if (this._context.config.codegen !== "none" && this._code.length) {
+      const text = addSection("Ran Playwright code");
+      text.push(...this._code);
+    }
+    const tabSnapshot = this._context.currentTab() ? await this._context.currentTabOrDie().captureSnapshot() : void 0;
+    const tabHeaders = await Promise.all(this._context.tabs().map((tab) => tab.headerSnapshot()));
+    if (tabHeaders.some((header) => header.changed)) {
+      if (tabHeaders.length !== 1) {
+        const text2 = addSection("Open tabs");
+        text2.push(...renderTabsMarkdown(tabHeaders));
+      }
+      const text = addSection("Page");
+      text.push(...renderTabMarkdown(tabHeaders[0]));
+    }
+    if (tabSnapshot?.modalStates.length) {
+      const text = addSection("Modal state");
+      text.push(...(0, import_tab.renderModalStates)(tabSnapshot.modalStates));
+    }
+    if (tabSnapshot && this._includeSnapshot === "full") {
+      let fileName;
+      if (this._includeSnapshotFileName)
+        fileName = await this._context.outputFile(this._includeSnapshotFileName, { origin: "llm", title: "Saved snapshot" });
+      else if (this._context.config.outputMode === "file")
+        fileName = await this._context.outputFile(`snapshot-${this._ordinal}.yml`, { origin: "code", title: "Saved snapshot" });
+      if (fileName) {
+        await import_fs.default.promises.writeFile(fileName, tabSnapshot.ariaSnapshot);
+        const text = addSection("Snapshot");
+        text.push(`- File: ${rootPath ? import_path.default.relative(rootPath, fileName) : fileName}`);
+      } else {
+        const text = addSection("Snapshot");
+        text.push("```yaml");
+        text.push(tabSnapshot.ariaSnapshot);
+        text.push("```");
+      }
+    }
+    if (tabSnapshot && this._includeSnapshot === "incremental") {
+      const text = addSection("Snapshot");
+      text.push("```yaml");
+      if (tabSnapshot.ariaSnapshotDiff !== void 0)
+        text.push(tabSnapshot.ariaSnapshotDiff);
+      else
+        text.push(tabSnapshot.ariaSnapshot);
+      text.push("```");
+    }
+    if (tabSnapshot?.events.filter((event) => event.type !== "request").length) {
+      const text = addSection("Events");
+      for (const event of tabSnapshot.events) {
+        if (event.type === "console") {
+          if ((0, import_tab.shouldIncludeMessage)(this._context.config.console.level, event.message.type))
+            text.push(`- ${trimMiddle(event.message.toString(), 100)}`);
+        } else if (event.type === "download-start") {
+          text.push(`- Downloading file ${event.download.download.suggestedFilename()} ...`);
+        } else if (event.type === "download-finish") {
+          text.push(`- Downloaded file ${event.download.download.suggestedFilename()} to "${rootPath ? import_path.default.relative(rootPath, event.download.outputFile) : event.download.outputFile}"`);
+        }
+      }
+    }
+    const allText = sections.flatMap((section) => {
+      const content2 = [];
+      content2.push(`### ${section.title}`);
+      content2.push(...section.content);
+      content2.push("");
+      return content2;
+    }).join("\n");
+    const content = [
+      {
+        type: "text",
+        text: this._redactText(allText)
+      }
+    ];
+    if (this._context.config.imageResponses !== "omit") {
+      for (const image of this._images)
+        content.push({ type: "image", data: image.data.toString("base64"), mimeType: image.contentType });
+    }
+    return {
+      content,
+      ...this._errors.length > 0 ? { isError: true } : {}
+    };
+  }
+  _redactText(text) {
+    for (const [secretName, secretValue] of Object.entries(this._context.config.secrets ?? {}))
+      text = text.replaceAll(secretValue, `<secret>${secretName}</secret>`);
+    return text;
+  }
+}
+function renderTabMarkdown(tab) {
+  const lines = [`- Page URL: ${tab.url}`];
+  if (tab.title)
+    lines.push(`- Page Title: ${tab.title}`);
+  return lines;
+}
+function renderTabsMarkdown(tabs) {
+  if (!tabs.length)
+    return ['No open tabs. Use the "browser_navigate" tool to navigate to a page first.'];
+  const lines = [];
+  for (let i = 0; i < tabs.length; i++) {
+    const tab = tabs[i];
+    const current = tab.current ? " (current)" : "";
+    lines.push(`- ${i}:${current} [${tab.title}](${tab.url})`);
+  }
+  return lines;
+}
+function trimMiddle(text, maxLength) {
+  if (text.length <= maxLength)
+    return text;
+  return text.slice(0, Math.floor(maxLength / 2)) + "..." + text.slice(-3 - Math.floor(maxLength / 2));
+}
+function parseSections(text) {
+  const sections = /* @__PURE__ */ new Map();
+  const sectionHeaders = text.split(/^### /m).slice(1);
+  for (const section of sectionHeaders) {
+    const firstNewlineIndex = section.indexOf("\n");
+    if (firstNewlineIndex === -1)
+      continue;
+    const sectionName = section.substring(0, firstNewlineIndex);
+    const sectionContent = section.substring(firstNewlineIndex + 1).trim();
+    sections.set(sectionName, sectionContent);
+  }
+  return sections;
+}
+function parseResponse(response) {
+  if (response.content?.[0].type !== "text")
+    return void 0;
+  const text = response.content[0].text;
+  const sections = parseSections(text);
+  const error = sections.get("Error");
+  const result = sections.get("Result");
+  const code = sections.get("Ran Playwright code");
+  const tabs = sections.get("Open tabs");
+  const page = sections.get("Page");
+  const snapshot = sections.get("Snapshot");
+  const events = sections.get("Events");
+  const modalState = sections.get("Modal state");
+  const codeNoFrame = code?.replace(/^```js\n/, "").replace(/\n```$/, "");
+  const isError = response.isError;
+  const attachments = response.content.length > 1 ? response.content.slice(1) : void 0;
+  return {
+    result,
+    error,
+    code: codeNoFrame,
+    tabs,
+    page,
+    snapshot,
+    events,
+    modalState,
+    isError,
+    attachments,
+    text
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Response,
+  parseResponse,
+  renderTabMarkdown,
+  renderTabsMarkdown,
+  requestDebug
+});

package/lib/mcp/browser/sessionLog.js

@@ -0,0 +1,75 @@
+"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 sessionLog_exports = {};
+__export(sessionLog_exports, {
+  SessionLog: () => SessionLog
+});
+module.exports = __toCommonJS(sessionLog_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_config = require("./config");
+var import_response = require("./response");
+class SessionLog {
+  constructor(sessionFolder) {
+    this._sessionFileQueue = Promise.resolve();
+    this._folder = sessionFolder;
+    this._file = import_path.default.join(this._folder, "session.md");
+  }
+  static async create(config, clientInfo) {
+    const sessionFolder = await (0, import_config.outputFile)(config, clientInfo, `session-${Date.now()}`, { origin: "code", title: "Saving session" });
+    await import_fs.default.promises.mkdir(sessionFolder, { recursive: true });
+    console.error(`Session: ${sessionFolder}`);
+    return new SessionLog(sessionFolder);
+  }
+  logResponse(toolName, toolArgs, responseObject) {
+    const parsed = (0, import_response.parseResponse)(responseObject);
+    if (parsed)
+      delete parsed.text;
+    const lines = [""];
+    lines.push(
+      `### Tool call: ${toolName}`,
+      `- Args`,
+      "```json",
+      JSON.stringify(toolArgs, null, 2),
+      "```"
+    );
+    if (parsed) {
+      lines.push(`- Result`);
+      lines.push("```json");
+      lines.push(JSON.stringify(parsed, null, 2));
+      lines.push("```");
+    }
+    lines.push("");
+    this._sessionFileQueue = this._sessionFileQueue.then(() => import_fs.default.promises.appendFile(this._file, lines.join("\n")));
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SessionLog
+});

package/lib/mcp/browser/tab.js

@@ -0,0 +1,351 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tab_exports = {};
+__export(tab_exports, {
+  Tab: () => Tab,
+  TabEvents: () => TabEvents,
+  renderModalStates: () => renderModalStates,
+  shouldIncludeMessage: () => shouldIncludeMessage
+});
+module.exports = __toCommonJS(tab_exports);
+var import_events = require("events");
+var import_utils = require("playwright-core/lib/utils");
+var import_utils2 = require("./tools/utils");
+var import_log = require("../log");
+var import_dialogs = require("./tools/dialogs");
+var import_files = require("./tools/files");
+var import_transform = require("../../transform/transform");
+const TabEvents = {
+  modalState: "modalState"
+};
+class Tab extends import_events.EventEmitter {
+  constructor(context, page, onPageClose) {
+    super();
+    this._lastHeader = { title: "about:blank", url: "about:blank", current: false };
+    this._consoleMessages = [];
+    this._downloads = [];
+    this._requests = /* @__PURE__ */ new Set();
+    this._modalStates = [];
+    this._needsFullSnapshot = false;
+    this._eventEntries = [];
+    this._recentEventEntries = [];
+    this.context = context;
+    this.page = page;
+    this._onPageClose = onPageClose;
+    page.on("console", (event) => this._handleConsoleMessage(messageToConsoleMessage(event)));
+    page.on("pageerror", (error) => this._handleConsoleMessage(pageErrorToConsoleMessage(error)));
+    page.on("request", (request) => this._handleRequest(request));
+    page.on("close", () => this._onClose());
+    page.on("filechooser", (chooser) => {
+      this.setModalState({
+        type: "fileChooser",
+        description: "File chooser",
+        fileChooser: chooser,
+        clearedBy: import_files.uploadFile.schema.name
+      });
+    });
+    page.on("dialog", (dialog) => this._dialogShown(dialog));
+    page.on("download", (download) => {
+      void this._downloadStarted(download);
+    });
+    page.setDefaultNavigationTimeout(this.context.config.timeouts.navigation);
+    page.setDefaultTimeout(this.context.config.timeouts.action);
+    page[tabSymbol] = this;
+    this._initializedPromise = this._initialize();
+  }
+  static forPage(page) {
+    return page[tabSymbol];
+  }
+  static async collectConsoleMessages(page) {
+    const result = [];
+    const messages = await page.consoleMessages().catch(() => []);
+    for (const message of messages)
+      result.push(messageToConsoleMessage(message));
+    const errors = await page.pageErrors().catch(() => []);
+    for (const error of errors)
+      result.push(pageErrorToConsoleMessage(error));
+    return result;
+  }
+  async _initialize() {
+    for (const message of await Tab.collectConsoleMessages(this.page))
+      this._handleConsoleMessage(message);
+    const requests = await this.page.requests().catch(() => []);
+    for (const request of requests)
+      this._requests.add(request);
+    for (const initPage of this.context.config.browser.initPage || []) {
+      try {
+        const { default: func } = await (0, import_transform.requireOrImport)(initPage);
+        await func({ page: this.page });
+      } catch (e) {
+        (0, import_log.logUnhandledError)(e);
+      }
+    }
+  }
+  modalStates() {
+    return this._modalStates;
+  }
+  setModalState(modalState) {
+    this._modalStates.push(modalState);
+    this.emit(TabEvents.modalState, modalState);
+  }
+  clearModalState(modalState) {
+    this._modalStates = this._modalStates.filter((state) => state !== modalState);
+  }
+  _dialogShown(dialog) {
+    this.setModalState({
+      type: "dialog",
+      description: `"${dialog.type()}" dialog with message "${dialog.message()}"`,
+      dialog,
+      clearedBy: import_dialogs.handleDialog.schema.name
+    });
+  }
+  async _downloadStarted(download) {
+    const entry = {
+      download,
+      finished: false,
+      outputFile: await this.context.outputFile(download.suggestedFilename(), { origin: "web", title: "Saving download" })
+    };
+    this._downloads.push(entry);
+    this._addLogEntry({ type: "download-start", wallTime: Date.now(), download: entry });
+    await download.saveAs(entry.outputFile);
+    entry.finished = true;
+    this._addLogEntry({ type: "download-finish", wallTime: Date.now(), download: entry });
+  }
+  _clearCollectedArtifacts() {
+    this._consoleMessages.length = 0;
+    this._downloads.length = 0;
+    this._requests.clear();
+    this._eventEntries.length = 0;
+    this._recentEventEntries.length = 0;
+  }
+  _handleRequest(request) {
+    this._requests.add(request);
+    this._addLogEntry({ type: "request", wallTime: Date.now(), request });
+  }
+  _handleConsoleMessage(message) {
+    this._consoleMessages.push(message);
+    this._addLogEntry({ type: "console", wallTime: Date.now(), message });
+  }
+  _addLogEntry(entry) {
+    this._eventEntries.push(entry);
+    this._recentEventEntries.push(entry);
+  }
+  _onClose() {
+    this._clearCollectedArtifacts();
+    this._onPageClose(this);
+  }
+  async headerSnapshot() {
+    let title;
+    await this._raceAgainstModalStates(async () => {
+      title = await (0, import_utils2.callOnPageNoTrace)(this.page, (page) => page.title());
+    });
+    if (this._lastHeader.title !== title || this._lastHeader.url !== this.page.url() || this._lastHeader.current !== this.isCurrentTab()) {
+      this._lastHeader = { title: title ?? "", url: this.page.url(), current: this.isCurrentTab() };
+      return { ...this._lastHeader, changed: true };
+    }
+    return { ...this._lastHeader, changed: false };
+  }
+  isCurrentTab() {
+    return this === this.context.currentTab();
+  }
+  async waitForLoadState(state, options) {
+    await this._initializedPromise;
+    await (0, import_utils2.callOnPageNoTrace)(this.page, (page) => page.waitForLoadState(state, options).catch(import_log.logUnhandledError));
+  }
+  async navigate(url) {
+    await this._initializedPromise;
+    this._clearCollectedArtifacts();
+    const { promise: downloadEvent, abort: abortDownloadEvent } = (0, import_utils2.eventWaiter)(this.page, "download", 3e3);
+    try {
+      await this.page.goto(url, { waitUntil: "domcontentloaded" });
+      abortDownloadEvent();
+    } catch (_e) {
+      const e = _e;
+      const mightBeDownload = e.message.includes("net::ERR_ABORTED") || e.message.includes("Download is starting");
+      if (!mightBeDownload)
+        throw e;
+      const download = await downloadEvent;
+      if (!download)
+        throw e;
+      await new Promise((resolve) => setTimeout(resolve, 500));
+      return;
+    }
+    await this.waitForLoadState("load", { timeout: 5e3 });
+  }
+  async consoleMessages(level) {
+    await this._initializedPromise;
+    return this._consoleMessages.filter((message) => shouldIncludeMessage(level, message.type));
+  }
+  async clearConsoleMessages() {
+    await this._initializedPromise;
+    this._consoleMessages.length = 0;
+  }
+  async requests() {
+    await this._initializedPromise;
+    return this._requests;
+  }
+  async clearRequests() {
+    await this._initializedPromise;
+    this._requests.clear();
+  }
+  async captureSnapshot() {
+    await this._initializedPromise;
+    let tabSnapshot;
+    const modalStates = await this._raceAgainstModalStates(async () => {
+      const snapshot = await this.page._snapshotForAI({ track: "response" });
+      tabSnapshot = {
+        ariaSnapshot: snapshot.full,
+        ariaSnapshotDiff: this._needsFullSnapshot ? void 0 : snapshot.incremental,
+        modalStates: [],
+        events: []
+      };
+    });
+    if (tabSnapshot) {
+      tabSnapshot.events = this._recentEventEntries;
+      this._recentEventEntries = [];
+    }
+    this._needsFullSnapshot = !tabSnapshot;
+    return tabSnapshot ?? {
+      ariaSnapshot: "",
+      ariaSnapshotDiff: "",
+      modalStates,
+      events: []
+    };
+  }
+  _javaScriptBlocked() {
+    return this._modalStates.some((state) => state.type === "dialog");
+  }
+  async _raceAgainstModalStates(action) {
+    if (this.modalStates().length)
+      return this.modalStates();
+    const promise = new import_utils.ManualPromise();
+    const listener = (modalState) => promise.resolve([modalState]);
+    this.once(TabEvents.modalState, listener);
+    return await Promise.race([
+      action().then(() => {
+        this.off(TabEvents.modalState, listener);
+        return [];
+      }),
+      promise
+    ]);
+  }
+  async waitForCompletion(callback) {
+    await this._initializedPromise;
+    await this._raceAgainstModalStates(() => (0, import_utils2.waitForCompletion)(this, callback));
+  }
+  async refLocator(params) {
+    await this._initializedPromise;
+    return (await this.refLocators([params]))[0];
+  }
+  async refLocators(params) {
+    await this._initializedPromise;
+    return Promise.all(params.map(async (param) => {
+      try {
+        let locator = this.page.locator(`aria-ref=${param.ref}`);
+        if (param.element)
+          locator = locator.describe(param.element);
+        const { resolvedSelector } = await locator._resolveSelector();
+        return { locator, resolved: (0, import_utils.asLocator)("javascript", resolvedSelector) };
+      } catch (e) {
+        throw new Error(`Ref ${param.ref} not found in the current page snapshot. Try capturing new snapshot.`);
+      }
+    }));
+  }
+  async waitForTimeout(time) {
+    if (this._javaScriptBlocked()) {
+      await new Promise((f) => setTimeout(f, time));
+      return;
+    }
+    await (0, import_utils2.callOnPageNoTrace)(this.page, (page) => {
+      return page.evaluate(() => new Promise((f) => setTimeout(f, 1e3))).catch(() => {
+      });
+    });
+  }
+}
+function messageToConsoleMessage(message) {
+  return {
+    type: message.type(),
+    text: message.text(),
+    toString: () => `[${message.type().toUpperCase()}] ${message.text()} @ ${message.location().url}:${message.location().lineNumber}`
+  };
+}
+function pageErrorToConsoleMessage(errorOrValue) {
+  if (errorOrValue instanceof Error) {
+    return {
+      type: "error",
+      text: errorOrValue.message,
+      toString: () => errorOrValue.stack || errorOrValue.message
+    };
+  }
+  return {
+    type: "error",
+    text: String(errorOrValue),
+    toString: () => String(errorOrValue)
+  };
+}
+function renderModalStates(modalStates) {
+  const result = [];
+  if (modalStates.length === 0)
+    result.push("- There is no modal state present");
+  for (const state of modalStates)
+    result.push(`- [${state.description}]: can be handled by the "${state.clearedBy}" tool`);
+  return result;
+}
+const consoleMessageLevels = ["error", "warning", "info", "debug"];
+function shouldIncludeMessage(thresholdLevel, type) {
+  const messageLevel = consoleLevelForMessageType(type);
+  return consoleMessageLevels.indexOf(messageLevel) <= consoleMessageLevels.indexOf(thresholdLevel);
+}
+function consoleLevelForMessageType(type) {
+  switch (type) {
+    case "assert":
+    case "error":
+      return "error";
+    case "warning":
+      return "warning";
+    case "count":
+    case "dir":
+    case "dirxml":
+    case "info":
+    case "log":
+    case "table":
+    case "time":
+    case "timeEnd":
+      return "info";
+    case "clear":
+    case "debug":
+    case "endGroup":
+    case "profile":
+    case "profileEnd":
+    case "startGroup":
+    case "startGroupCollapsed":
+    case "trace":
+      return "debug";
+    default:
+      return "info";
+  }
+}
+const tabSymbol = Symbol("tabSymbol");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Tab,
+  TabEvents,
+  renderModalStates,
+  shouldIncludeMessage
+});