playwright-core 1.58.0-alpha-2025-12-07 → 1.58.0-alpha-2025-12-09

package/browsers.json

@@ -31,9 +31,9 @@
     },
     {
       "name": "firefox",
-      "revision": "1502",
+      "revision": "1504",
       "installByDefault": true,
-      "browserVersion": "145.0.1",
+      "browserVersion": "145.0.2",
       "title": "Firefox"
     },
     {
@@ -45,7 +45,7 @@
     },
     {
       "name": "webkit",
-      "revision": "2232",
+      "revision": "2237",
       "installByDefault": true,
       "revisionOverrides": {
         "debian11-x64": "2105",

package/lib/client/browserContext.js

@@ -493,6 +493,7 @@ async function prepareBrowserContextParams(platform, options) {
     network.validateHeaders(options.extraHTTPHeaders);
   const contextParams = {
     ...options,
+    agent: toAgentProtocol(options.agent),
     viewport: options.viewport === null ? void 0 : options.viewport,
     noDefaultViewport: options.viewport === null,
     extraHTTPHeaders: options.extraHTTPHeaders ? (0, import_headers.headersObjectToArray)(options.extraHTTPHeaders) : void 0,
@@ -515,6 +516,12 @@ async function prepareBrowserContextParams(platform, options) {
     contextParams.recordVideo.dir = platform.path().resolve(contextParams.recordVideo.dir);
   return contextParams;
 }
+function toAgentProtocol(agent) {
+  if (!agent)
+    return void 0;
+  const secrets = agent.secrets ? Object.entries(agent.secrets).map(([name, value]) => ({ name, value })) : void 0;
+  return { ...agent, secrets };
+}
 function toAcceptDownloadsProtocol(acceptDownloads) {
   if (acceptDownloads === void 0)
     return void 0;

package/lib/client/page.js

@@ -675,10 +675,11 @@ class Page extends import_channelOwner.ChannelOwner {
     return result.pdf;
   }
   async perform(task, options = {}) {
-    throw new Error("Not implemented in playwright-core");
+    await this._channel.perform({ task, ...options });
   }
-  extract(query, schema, options = {}) {
-    throw new Error("Not implemented in playwright-core");
+  async extract(query, schema, options = {}) {
+    const { result } = await this._channel.extract({ query, schema: this._platform.zodToJsonSchema(schema), ...options });
+    return result;
   }
   async _snapshotForAI(options = {}) {
     return await this._channel.snapshotForAI({ timeout: this._timeoutSettings.timeout(options), track: options.track });

package/lib/client/platform.js

@@ -66,6 +66,9 @@ const emptyPlatform = {
   streamWritable: (channel) => {
     throw new Error("Streams are not available");
   },
+  zodToJsonSchema: (schema) => {
+    throw new Error("Zod is not available");
+  },
   zones: { empty: noopZone, current: () => noopZone }
 };
 // Annotate the CommonJS export names for ESM import in node:

package/lib/protocol/validator.js

@@ -611,8 +611,9 @@ import_validatorPrimitives.scheme.BrowserTypeLaunchPersistentContextParams = (0,
   agent: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({
     provider: import_validatorPrimitives.tString,
     model: import_validatorPrimitives.tString,
-    cacheDir: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
-    cacheMode: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["ignore", "force", "auto"]))
+    cacheFile: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
+    cacheMode: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["ignore", "force", "auto"])),
+    secrets: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tType)("NameValue")))
   })),
   userDataDir: import_validatorPrimitives.tString,
   slowMo: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tFloat)
@@ -709,8 +710,9 @@ import_validatorPrimitives.scheme.BrowserNewContextParams = (0, import_validator
   agent: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({
     provider: import_validatorPrimitives.tString,
     model: import_validatorPrimitives.tString,
-    cacheDir: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
-    cacheMode: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["ignore", "force", "auto"]))
+    cacheFile: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
+    cacheMode: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["ignore", "force", "auto"])),
+    secrets: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tType)("NameValue")))
   })),
   proxy: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({
     server: import_validatorPrimitives.tString,
@@ -786,8 +788,9 @@ import_validatorPrimitives.scheme.BrowserNewContextForReuseParams = (0, import_v
   agent: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({
     provider: import_validatorPrimitives.tString,
     model: import_validatorPrimitives.tString,
-    cacheDir: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
-    cacheMode: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["ignore", "force", "auto"]))
+    cacheFile: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
+    cacheMode: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["ignore", "force", "auto"])),
+    secrets: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tType)("NameValue")))
   })),
   proxy: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({
     server: import_validatorPrimitives.tString,
@@ -908,8 +911,9 @@ import_validatorPrimitives.scheme.BrowserContextInitializer = (0, import_validat
     agent: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({
       provider: import_validatorPrimitives.tString,
       model: import_validatorPrimitives.tString,
-      cacheDir: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
-      cacheMode: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["ignore", "force", "auto"]))
+      cacheFile: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
+      cacheMode: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["ignore", "force", "auto"])),
+      secrets: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tType)("NameValue")))
     }))
   })
 });
@@ -1512,6 +1516,20 @@ import_validatorPrimitives.scheme.PageUpdateSubscriptionParams = (0, import_vali
   enabled: import_validatorPrimitives.tBoolean
 });
 import_validatorPrimitives.scheme.PageUpdateSubscriptionResult = (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({}));
+import_validatorPrimitives.scheme.PagePerformParams = (0, import_validatorPrimitives.tObject)({
+  task: import_validatorPrimitives.tString,
+  key: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
+  maxTurns: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tInt)
+});
+import_validatorPrimitives.scheme.PagePerformResult = (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({}));
+import_validatorPrimitives.scheme.PageExtractParams = (0, import_validatorPrimitives.tObject)({
+  query: import_validatorPrimitives.tString,
+  schema: import_validatorPrimitives.tAny,
+  maxTurns: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tInt)
+});
+import_validatorPrimitives.scheme.PageExtractResult = (0, import_validatorPrimitives.tObject)({
+  result: import_validatorPrimitives.tAny
+});
 import_validatorPrimitives.scheme.FrameInitializer = (0, import_validatorPrimitives.tObject)({
   url: import_validatorPrimitives.tString,
   name: import_validatorPrimitives.tString,
@@ -2803,8 +2821,9 @@ import_validatorPrimitives.scheme.AndroidDeviceLaunchBrowserParams = (0, import_
   agent: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({
     provider: import_validatorPrimitives.tString,
     model: import_validatorPrimitives.tString,
-    cacheDir: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
-    cacheMode: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["ignore", "force", "auto"]))
+    cacheFile: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
+    cacheMode: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["ignore", "force", "auto"])),
+    secrets: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tType)("NameValue")))
   })),
   pkg: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
   args: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)(import_validatorPrimitives.tString)),

package/lib/server/agent/actionRunner.js

@@ -0,0 +1,68 @@
+"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 actionRunner_exports = {};
+__export(actionRunner_exports, {
+  runAction: () => runAction
+});
+module.exports = __toCommonJS(actionRunner_exports);
+async function runAction(progress, page, action, secrets) {
+  const frame = page.mainFrame();
+  switch (action.method) {
+    case "click":
+      await frame.click(progress, action.selector, { ...action.options, ...strictTrue });
+      break;
+    case "drag":
+      await frame.dragAndDrop(progress, action.sourceSelector, action.targetSelector, { ...strictTrue });
+      break;
+    case "hover":
+      await frame.hover(progress, action.selector, { ...action.options, ...strictTrue });
+      break;
+    case "selectOption":
+      await frame.selectOption(progress, action.selector, [], action.labels.map((a) => ({ label: a })), { ...strictTrue });
+      break;
+    case "pressKey":
+      await page.keyboard.press(progress, action.key);
+      break;
+    case "pressSequentially": {
+      const secret = secrets?.find((s) => s.name === action.text)?.value ?? action.text;
+      await frame.type(progress, action.selector, secret, { ...strictTrue });
+      if (action.submit)
+        await page.keyboard.press(progress, "Enter");
+      break;
+    }
+    case "fill": {
+      const secret = secrets?.find((s) => s.name === action.text)?.value ?? action.text;
+      await frame.fill(progress, action.selector, secret, { ...strictTrue });
+      if (action.submit)
+        await page.keyboard.press(progress, "Enter");
+      break;
+    }
+    case "setChecked":
+      if (action.checked)
+        await frame.check(progress, action.selector, { ...strictTrue });
+      else
+        await frame.uncheck(progress, action.selector, { ...strictTrue });
+      break;
+  }
+}
+const strictTrue = { strict: true };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runAction
+});

package/lib/server/agent/actions.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 actions_exports = {};
+module.exports = __toCommonJS(actions_exports);

package/lib/server/agent/agent.js

@@ -0,0 +1,122 @@
+"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 agent_exports = {};
+__export(agent_exports, {
+  pageExtract: () => pageExtract,
+  pagePerform: () => pagePerform
+});
+module.exports = __toCommonJS(agent_exports);
+var import_fs = __toESM(require("fs"));
+var import_backend = require("./backend");
+var import_utilsBundle = require("../../utilsBundle");
+var import_mcpBundle = require("../../mcpBundle");
+var import_actionRunner = require("./actionRunner");
+var import_context = require("./context");
+async function pagePerform(progress, page, options) {
+  const context = new import_context.Context(progress, page);
+  if (await cachedPerform(context, options))
+    return;
+  await perform(context, options.task, (0, import_mcpBundle.zodToJsonSchema)(import_mcpBundle.z.object({
+    error: import_mcpBundle.z.string().optional().describe("An error message if the task could not be completed successfully")
+  })), options);
+  await updateCache(context, options);
+}
+async function pageExtract(progress, page, options) {
+  const context = new import_context.Context(progress, page);
+  const task = `
+### Instructions
+Extract the following information from the page. Do not perform any actions, just extract the information.
+
+### Query
+${options.query}`;
+  return await perform(context, task, options.schema, options);
+}
+async function perform(context, userTask, resultSchema, options = {}) {
+  const { progress, page } = context;
+  const browserContext = page.browserContext;
+  if (!browserContext._options.agent)
+    throw new Error(`page.perform() and page.extract() require the agent to be set on the browser context`);
+  const { full } = await page.snapshotForAI(progress);
+  const { tools, callTool } = (0, import_backend.toolsForLoop)(context);
+  const loop = new import_mcpBundle.Loop(browserContext._options.agent.provider, {
+    model: browserContext._options.agent.model,
+    summarize: true,
+    debug: import_utilsBundle.debug,
+    callTool,
+    tools,
+    ...options
+  });
+  const task = `${userTask}
+
+### Page snapshot
+${full}
+`;
+  return await loop.run(task, {
+    resultSchema
+  });
+}
+const allCaches = /* @__PURE__ */ new Map();
+async function cachedPerform(context, options) {
+  if (!context.options?.cacheFile || context.options.cacheMode === "ignore")
+    return false;
+  const cache = await cachedActions(context.options.cacheFile);
+  const cacheKey = options.key ?? options.task;
+  const actions = cache[cacheKey];
+  if (!actions) {
+    if (context.options.cacheMode === "force")
+      throw new Error(`No cached actions for key "${cacheKey}", but cache mode is set to "force"`);
+    return false;
+  }
+  for (const action of actions)
+    await (0, import_actionRunner.runAction)(context.progress, context.page, action, context.options.secrets ?? []);
+  return true;
+}
+async function updateCache(context, options) {
+  const cacheFile = context.options?.cacheFile;
+  if (!cacheFile)
+    return;
+  const cache = await cachedActions(cacheFile);
+  const cacheKey = options.key ?? options.task;
+  cache[cacheKey] = context.actions;
+  await import_fs.default.promises.writeFile(cacheFile, JSON.stringify(cache, void 0, 2));
+}
+async function cachedActions(cacheFile) {
+  let cache = allCaches.get(cacheFile);
+  if (!cache) {
+    const text = await import_fs.default.promises.readFile(cacheFile, "utf-8").catch(() => "{}");
+    cache = JSON.parse(text);
+    allCaches.set(cacheFile, cache);
+  }
+  return cache;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pageExtract,
+  pagePerform
+});

package/lib/server/agent/backend.js

@@ -0,0 +1,77 @@
+"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 backend_exports = {};
+__export(backend_exports, {
+  toolsForLoop: () => toolsForLoop
+});
+module.exports = __toCommonJS(backend_exports);
+var import_tools = __toESM(require("./tools"));
+var import_progress = require("../progress");
+var import_mcpBundle = require("../../mcpBundle");
+function toolsForLoop(context) {
+  const tools = import_tools.default.map((tool) => {
+    const result = {
+      name: tool.schema.name,
+      description: tool.schema.description,
+      inputSchema: (0, import_mcpBundle.zodToJsonSchema)(tool.schema.inputSchema)
+    };
+    return result;
+  });
+  const callTool = async (params) => {
+    const tool = import_tools.default.find((t) => t.schema.name === params.name);
+    if (!tool) {
+      return {
+        content: [{
+          type: "text",
+          text: `Tool ${params.name} not found. Available tools: ${import_tools.default.map((t) => t.schema.name)}`
+        }],
+        isError: true
+      };
+    }
+    const progressController = new import_progress.ProgressController();
+    try {
+      return await progressController.run(async (progress) => {
+        return await tool.handle(context, params.arguments);
+      });
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: error.message }],
+        isError: true
+      };
+    }
+  };
+  return {
+    tools,
+    callTool
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toolsForLoop
+});

package/lib/server/agent/context.js

@@ -0,0 +1,115 @@
+"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 context_exports = {};
+__export(context_exports, {
+  Context: () => Context
+});
+module.exports = __toCommonJS(context_exports);
+var import_browserContext = require("../browserContext");
+var import_actionRunner = require("./actionRunner");
+class Context {
+  constructor(progress, page) {
+    this.actions = [];
+    this.progress = progress;
+    this.page = page;
+    this.options = page.browserContext._options.agent;
+  }
+  async runActionAndWait(action) {
+    return await this.runActionsAndWait([action]);
+  }
+  async runActionsAndWait(action) {
+    await this.waitForCompletion(async () => {
+      for (const a of action) {
+        await (0, import_actionRunner.runAction)(this.progress, this.page, a, this.options?.secrets ?? []);
+        this.actions.push(a);
+      }
+    });
+    return await this.snapshotResult();
+  }
+  async waitForCompletion(callback) {
+    const requests = [];
+    const requestListener = (request) => requests.push(request);
+    const disposeListeners = () => {
+      this.page.browserContext.off(import_browserContext.BrowserContext.Events.Request, requestListener);
+    };
+    this.page.browserContext.on(import_browserContext.BrowserContext.Events.Request, requestListener);
+    let result;
+    try {
+      result = await callback();
+      await this.progress.wait(500);
+    } finally {
+      disposeListeners();
+    }
+    const requestedNavigation = requests.some((request) => request.isNavigationRequest());
+    if (requestedNavigation) {
+      await this.page.mainFrame().waitForLoadState(this.progress, "load");
+      return result;
+    }
+    const promises = [];
+    for (const request of requests) {
+      if (["document", "stylesheet", "script", "xhr", "fetch"].includes(request.resourceType()))
+        promises.push(request.response().then((r) => r?.finished()));
+      else
+        promises.push(request.response());
+    }
+    await this.progress.race(promises, { timeout: 5e3 });
+    if (requests.length)
+      await this.progress.wait(500);
+    return result;
+  }
+  async snapshotResult() {
+    let { full } = await this.page.snapshotForAI(this.progress);
+    full = this._redactText(full);
+    const text = [`# Page snapshot
+${full}`];
+    return {
+      _meta: {
+        "dev.lowire/state": {
+          "Page snapshot": full
+        }
+      },
+      content: [{ type: "text", text: text.join("\n\n") }]
+    };
+  }
+  async refSelectors(params) {
+    return Promise.all(params.map(async (param) => {
+      try {
+        const { resolvedSelector } = await this.page.mainFrame().resolveSelector(this.progress, `aria-ref=${param.ref}`);
+        return resolvedSelector;
+      } catch (e) {
+        throw new Error(`Ref ${param.ref} not found in the current page snapshot. Try capturing new snapshot.`);
+      }
+    }));
+  }
+  _redactText(text) {
+    const secrets = this.options?.secrets;
+    if (!secrets)
+      return text;
+    const redactText = (text2) => {
+      for (const { name, value } of secrets)
+        text2 = text2.replaceAll(value, `<secret>${name}</secret>`);
+      return text2;
+    };
+    return redactText(text);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Context
+});