patchright-core 1.57.0 → 1.59.0

package/lib/server/page.js

@@ -31,11 +31,13 @@ __export(page_exports, {
   InitScript: () => InitScript,
   Page: () => Page,
   PageBinding: () => PageBinding,
-  Worker: () => Worker
+  Worker: () => Worker,
+  WorkerEvent: () => WorkerEvent,
+  ariaSnapshotForFrame: () => ariaSnapshotForFrame
 });
 module.exports = __toCommonJS(page_exports);
-var import_pageBinding = require("./pageBinding");
 var import_browserContext = require("./browserContext");
+var import_disposable = require("./disposable");
 var import_console = require("./console");
 var import_errors = require("./errors");
 var import_fileChooser = require("./fileChooser");
@@ -53,11 +55,29 @@ var import_selectorParser = require("../utils/isomorphic/selectorParser");
 var import_manualPromise = require("../utils/isomorphic/manualPromise");
 var import_utilityScriptSerializers = require("../utils/isomorphic/utilityScriptSerializers");
 var import_callLog = require("./callLog");
+var rawBindingsControllerSource = __toESM(require("../generated/bindingsControllerSource"));
+var import_overlay = require("./overlay");
+var import_dom = require("./dom");
+var import_screencast = require("./screencast");
+const PageEvent = {
+  Close: "close",
+  Crash: "crash",
+  Download: "download",
+  EmulatedSizeChanged: "emulatedsizechanged",
+  FileChooser: "filechooser",
+  FrameAttached: "frameattached",
+  FrameDetached: "framedetached",
+  InternalFrameNavigatedToNewDocument: "internalframenavigatedtonewdocument",
+  LocatorHandlerTriggered: "locatorhandlertriggered",
+  WebSocket: "websocket",
+  Worker: "worker"
+};
+const navigationMarkSymbol = Symbol("navigationMark");
 class Page extends import_instrumentation.SdkObject {
   constructor(delegate, browserContext) {
     super(browserContext, "page");
     this._closedState = "open";
-    this._closedPromise = new import_manualPromise.ManualPromise();
+    this.closedPromise = new import_manualPromise.ManualPromise();
     this._initializedPromise = new import_manualPromise.ManualPromise();
     this._consoleMessages = [];
     this._pageErrors = [];
@@ -69,14 +89,10 @@ class Page extends import_instrumentation.SdkObject {
     this.initScripts = [];
     this._workers = /* @__PURE__ */ new Map();
     this.requestInterceptors = [];
-    this.video = null;
     this._locatorHandlers = /* @__PURE__ */ new Map();
     this._lastLocatorHandlerUid = 0;
     this._locatorHandlerRunningCounter = 0;
     this._networkRequests = [];
-    // Aiming at 25 fps by default - each frame is 40ms, but we give some slack with 35ms.
-    // When throttling for tracing, 200ms between frames, except for 10 frames around the action.
-    this._frameThrottler = new FrameThrottler(10, 35, 200);
     this.attribution.page = this;
     this.delegate = delegate;
     this.browserContext = browserContext;
@@ -85,27 +101,15 @@ class Page extends import_instrumentation.SdkObject {
     this.touchscreen = new input.Touchscreen(delegate.rawTouchscreen, this);
     this.screenshotter = new import_screenshotter.Screenshotter(this);
     this.frameManager = new frames.FrameManager(this);
+    this.overlay = new import_overlay.Overlay(this);
+    this.screencast = new import_screencast.Screencast(this);
     if (delegate.pdf)
       this.pdf = delegate.pdf.bind(delegate);
     this.coverage = delegate.coverage ? delegate.coverage() : null;
     this.isStorageStatePage = browserContext.isCreatingStorageStatePage();
   }
   static {
-    this.Events = {
-      Close: "close",
-      Crash: "crash",
-      Download: "download",
-      EmulatedSizeChanged: "emulatedsizechanged",
-      FileChooser: "filechooser",
-      FrameAttached: "frameattached",
-      FrameDetached: "framedetached",
-      InternalFrameNavigatedToNewDocument: "internalframenavigatedtonewdocument",
-      LocatorHandlerTriggered: "locatorhandlertriggered",
-      ScreencastFrame: "screencastframe",
-      Video: "video",
-      WebSocket: "websocket",
-      Worker: "worker"
-    };
+    this.Events = PageEvent;
   }
   async reportAsNew(opener, error) {
     if (opener) {
@@ -158,17 +162,20 @@ class Page extends import_instrumentation.SdkObject {
   }
   _didClose() {
     this.frameManager.dispose();
-    this._frameThrottler.dispose();
+    this.screencast.dispose();
+    this.overlay.dispose();
     (0, import_utils.assert)(this._closedState !== "closed", "Page closed twice");
     this._closedState = "closed";
     this.emit(Page.Events.Close);
-    this._closedPromise.resolve();
+    this.browserContext.emit(import_browserContext.BrowserContext.Events.PageClosed, this);
+    this.closedPromise.resolve();
     this.instrumentation.onPageClose(this);
-    this.openScope.close(new import_errors.TargetClosedError());
+    this.openScope.close(new import_errors.TargetClosedError(this.closeReason()));
   }
   _didCrash() {
     this.frameManager.dispose();
-    this._frameThrottler.dispose();
+    this.screencast.dispose();
+    this.overlay.dispose();
     this.emit(Page.Events.Crash);
     this._crashed = true;
     this.instrumentation.onPageClose(this);
@@ -202,16 +209,25 @@ class Page extends import_instrumentation.SdkObject {
       throw new Error(`Function "${name}" has been already registered`);
     if (this.browserContext._pageBindings.has(name))
       throw new Error(`Function "${name}" has been already registered in the browser context`);
-    const binding = new PageBinding(name, playwrightBinding, needsHandle);
+    await progress.race(this.browserContext.exposePlaywrightBindingIfNeeded());
+    const binding = new PageBinding(this, name, playwrightBinding, needsHandle);
     this._pageBindings.set(name, binding);
-    await this.delegate.exposeBinding(binding);
-  }
-  async removeExposedBindings(bindings) {
-    for (const key of this._pageBindings.keys()) {
-      if (!key.startsWith("__pw"))
-        this._pageBindings.delete(key);
+    try {
+      await progress.race(this.delegate.addInitScript(binding.initScript));
+      await progress.race(this.safeNonStallingEvaluateInAllFrames(binding.initScript.source, "main"));
+      return binding;
+    } catch (error) {
+      this._pageBindings.delete(name);
+      throw error;
     }
-    await this.delegate.removeExposedBindings();
+  }
+  async removeExposedBinding(binding) {
+    if (this._pageBindings.get(binding.name) !== binding)
+      return;
+    this._pageBindings.delete(binding.name);
+    await this.delegate.removeInitScripts([binding.initScript]);
+    const cleanup = `{ ${binding.cleanupScript} };`;
+    await this.safeNonStallingEvaluateInAllFrames(cleanup, "main");
   }
   async setExtraHTTPHeaders(progress, headers) {
     const oldHeaders = this._extraHTTPHeaders;
@@ -240,8 +256,8 @@ class Page extends import_instrumentation.SdkObject {
       return;
     await PageBinding.dispatch(this, payload, context);
   }
-  addConsoleMessage(worker, type, args, location, text) {
-    const message = new import_console.ConsoleMessage(this, worker, type, text, args, location);
+  addConsoleMessage(worker, type, args, location, text, timestamp) {
+    const message = new import_console.ConsoleMessage(this, worker, type, text, args, location, timestamp);
     const intercepted = this.frameManager.interceptConsoleMessage(message);
     if (intercepted) {
       args.forEach((arg) => arg.dispose());
@@ -252,8 +268,14 @@ class Page extends import_instrumentation.SdkObject {
     if (this._initialized)
       this.emitOnContext(import_browserContext.BrowserContext.Events.Console, message);
   }
-  consoleMessages() {
-    return this._consoleMessages;
+  clearConsoleMessages() {
+    this._consoleMessages.length = 0;
+  }
+  consoleMessages(filter) {
+    if (filter === "all")
+      return this._consoleMessages;
+    const marked = this._consoleMessages.findLastIndex((m) => m[navigationMarkSymbol]);
+    return marked === -1 ? this._consoleMessages : this._consoleMessages.slice(marked + 1);
   }
   addPageError(pageError) {
     this._pageErrors.push(pageError);
@@ -261,8 +283,14 @@ class Page extends import_instrumentation.SdkObject {
     if (this._initialized)
       this.emitOnContext(import_browserContext.BrowserContext.Events.PageError, pageError, this);
   }
-  pageErrors() {
-    return this._pageErrors;
+  clearPageErrors() {
+    this._pageErrors.length = 0;
+  }
+  pageErrors(filter) {
+    if (filter === "all")
+      return this._pageErrors;
+    const marked = this._pageErrors.findLastIndex((e) => e[navigationMarkSymbol]);
+    return marked === -1 ? this._pageErrors : this._pageErrors.slice(marked + 1);
   }
   async reload(progress, options) {
     return this.mainFrame().raceNavigationAction(progress, async () => {
@@ -439,21 +467,21 @@ class Page extends import_instrumentation.SdkObject {
   async bringToFront() {
     await this.delegate.bringToFront();
   }
-  async addInitScript(progress, source) {
-    const initScript = new InitScript(source);
+  async addInitScript(source) {
+    const initScript = new InitScript(this, source);
     this.initScripts.push(initScript);
     try {
-      await progress.race(this.delegate.addInitScript(initScript));
+      await this.delegate.addInitScript(initScript);
     } catch (error) {
-      this.removeInitScripts([initScript]).catch(() => {
+      initScript.dispose().catch(() => {
       });
       throw error;
     }
     return initScript;
   }
-  async removeInitScripts(initScripts) {
-    this.initScripts.splice(0, this.initScripts.length);
-    await this.delegate.removeInitScripts();
+  async removeInitScript(initScript) {
+    this.initScripts = this.initScripts.filter((script) => initScript !== script);
+    await this.delegate.removeInitScripts([initScript]);
   }
   needsRequestInterception() {
     return this.requestInterceptors.length > 0 || this.browserContext.requestInterceptors.length > 0;
@@ -567,15 +595,17 @@ class Page extends import_instrumentation.SdkObject {
     if (this._closedState === "closed")
       return;
     if (options.reason)
-      this.closeReason = options.reason;
+      this._closeReason = options.reason;
     const runBeforeUnload = !!options.runBeforeUnload;
+    if (!runBeforeUnload)
+      await this.screencast.handlePageOrContextClose();
     if (this._closedState !== "closing") {
       if (!runBeforeUnload)
         this._closedState = "closing";
       await this.delegate.closePage(runBeforeUnload).catch((e) => import_debugLogger.debugLogger.log("error", e));
     }
     if (!runBeforeUnload)
-      await this._closedPromise;
+      await this.closedPromise;
   }
   isClosed() {
     return this._closedState === "closed";
@@ -617,23 +647,26 @@ class Page extends import_instrumentation.SdkObject {
   }
   frameNavigatedToNewDocument(frame) {
     this.emit(Page.Events.InternalFrameNavigatedToNewDocument, frame);
+    this.browserContext.emit(import_browserContext.BrowserContext.Events.InternalFrameNavigatedToNewDocument, frame, this);
     const origin = frame.origin();
     if (origin)
       this.browserContext.addVisitedOrigin(origin);
+    if (frame === this.mainFrame()) {
+      if (this._consoleMessages.length > 0)
+        this._consoleMessages[this._consoleMessages.length - 1][navigationMarkSymbol] = true;
+      if (this._pageErrors.length > 0)
+        this._pageErrors[this._pageErrors.length - 1][navigationMarkSymbol] = true;
+    }
+  }
+  allInitScripts() {
+    const bindings = [...this.browserContext._pageBindings.values(), ...this._pageBindings.values()].map((binding) => binding.initScript);
+    if (this.browserContext.bindingsInitScript)
+      bindings.unshift(this.browserContext.bindingsInitScript);
+    return [...bindings, ...this.browserContext.initScripts, ...this.initScripts];
   }
   getBinding(name) {
     return this._pageBindings.get(name) || this.browserContext._pageBindings.get(name);
   }
-  setScreencastOptions(options) {
-    this.delegate.setScreencastOptions(options).catch((e) => import_debugLogger.debugLogger.log("error", e));
-    this._frameThrottler.setThrottlingEnabled(!!options);
-  }
-  throttleScreencastFrameAck(ack) {
-    this._frameThrottler.ack(ack);
-  }
-  temporarilyDisableTracingScreencastThrottling() {
-    this._frameThrottler.recharge();
-  }
   async safeNonStallingEvaluateInAllFrames(expression, world, options = {}) {
     await Promise.all(this.frames().map(async (frame) => {
       try {
@@ -648,14 +681,13 @@ class Page extends import_instrumentation.SdkObject {
     await Promise.all(this.frames().map((frame) => frame.hideHighlight().catch(() => {
     })));
   }
-  async snapshotForAI(progress, options) {
-    const snapshot = await snapshotFrameForAI(progress, this.mainFrame(), options);
-    return { full: snapshot.full.join("\n"), incremental: snapshot.incremental?.join("\n") };
-  }
-  allBindings() {
-    return [...this.browserContext._pageBindings.values(), ...this._pageBindings.values()];
+  async setDockTile(image) {
+    await this.delegate.setDockTile(image);
   }
 }
+const WorkerEvent = {
+  Close: "close"
+};
 class Worker extends import_instrumentation.SdkObject {
   constructor(parent, url) {
     super(parent, "worker");
@@ -666,9 +698,7 @@ class Worker extends import_instrumentation.SdkObject {
     this.url = url;
   }
   static {
-    this.Events = {
-      Close: "close"
-    };
+    this.Events = WorkerEvent;
   }
   createExecutionContext(delegate) {
     this.existingExecutionContext = new js.ExecutionContext(this, delegate, "worker");
@@ -681,41 +711,51 @@ class Worker extends import_instrumentation.SdkObject {
     if (this.existingExecutionContext)
       this._executionContextPromise.resolve(this.existingExecutionContext);
   }
+  _prepareContextForRestart() {
+    if (this.existingExecutionContext)
+      this.existingExecutionContext.contextDestroyed("Service worker restarted");
+    this.existingExecutionContext = null;
+    this._workerScriptLoaded = false;
+    this._executionContextPromise = new import_manualPromise.ManualPromise();
+  }
   didClose() {
     if (this.existingExecutionContext)
       this.existingExecutionContext.contextDestroyed("Worker was closed");
     this.emit(Worker.Events.Close, this);
     this.openScope.close(new Error("Worker closed"));
   }
-  async evaluateExpression(expression, isFunction, arg, isolatedContext) {
-    let context = await this._executionContextPromise;
-    if (context.constructor.name === "FrameExecutionContext") {
-      const frame = context.frame;
-      if (frame) {
-        if (isolatedContext) context = await frame._utilityContext();
-        else if (!isolatedContext) context = await frame._mainContext();
-      }
-    }
-    return js.evaluateExpression(context, expression, { returnByValue: true, isFunction }, arg);
-  }
-  async evaluateExpressionHandle(expression, isFunction, arg, isolatedContext) {
-    let context = await this._executionContextPromise;
-    if (context.constructor.name === "FrameExecutionContext") {
-      const frame = this._context.frame;
-      if (frame) {
-        if (isolatedContext) context = await frame._utilityContext();
-        else if (!isolatedContext) context = await frame._mainContext();
-      }
-    }
-    return js.evaluateExpression(context, expression, { returnByValue: false, isFunction }, arg);
+  async evaluateExpression(expression, isFunction, arg) {
+    return js.evaluateExpression(await this._executionContextPromise, expression, { returnByValue: true, isFunction }, arg);
+  }
+  async evaluateExpressionHandle(expression, isFunction, arg) {
+    return js.evaluateExpression(await this._executionContextPromise, expression, { returnByValue: false, isFunction }, arg);
   }
 }
-class PageBinding {
-  constructor(name, playwrightFunction, needsHandle) {
+class PageBinding extends import_disposable.DisposableObject {
+  static {
+    this.kController = "__playwright__binding__controller__";
+  }
+  static {
+    this.kBindingName = "__playwright__binding__";
+  }
+  static createInitScript(browserContext) {
+    return new InitScript(browserContext, `
+      (() => {
+        const module = {};
+        ${rawBindingsControllerSource.source}
+        const property = '${PageBinding.kController}';
+        if (!globalThis[property])
+          globalThis[property] = new (module.exports.BindingsController())(globalThis, '${PageBinding.kBindingName}');
+      })();
+    `);
+  }
+  constructor(parent, name, playwrightFunction, needsHandle) {
+    super(parent);
     this.name = name;
     this.playwrightFunction = playwrightFunction;
-    this.source = (0, import_pageBinding.createPageBindingScript)(name, needsHandle);
+    this.initScript = new InitScript(parent, `globalThis['${PageBinding.kController}'].addBinding(${JSON.stringify(name)}, ${needsHandle})`);
     this.needsHandle = needsHandle;
+    this.cleanupScript = `globalThis['${PageBinding.kController}'].removeBinding(${JSON.stringify(name)})`;
   }
   static async dispatch(page, payload, context) {
     const { name, seq, serializedArgs } = JSON.parse(payload);
@@ -726,87 +766,62 @@ class PageBinding {
         throw new Error(`Function "${name}" is not exposed`);
       let result;
       if (binding.needsHandle) {
-        const handle = await context.evaluateHandle(import_pageBinding.takeBindingHandle, { name, seq }).catch((e) => null);
-        result = await binding.playwrightFunction({ frame: context.frame, page, context: page._browserContext }, handle);
+        const handle = await context.evaluateExpressionHandle(`arg => globalThis['${PageBinding.kController}'].takeBindingHandle(arg)`, { isFunction: true }, { name, seq }).catch((e) => null);
+        result = await binding.playwrightFunction({ frame: context.frame, page, context: page.browserContext }, handle);
       } else {
         if (!Array.isArray(serializedArgs))
           throw new Error(`serializedArgs is not an array. This can happen when Array.prototype.toJSON is defined incorrectly`);
         const args = serializedArgs.map((a) => (0, import_utilityScriptSerializers.parseEvaluationResultValue)(a));
-        result = await binding.playwrightFunction({ frame: context.frame, page, context: page._browserContext }, ...args);
+        result = await binding.playwrightFunction({ frame: context.frame, page, context: page.browserContext }, ...args);
       }
-      context.evaluate(import_pageBinding.deliverBindingResult, { name, seq, result }).catch((e) => import_debugLogger.debugLogger.log("error", e));
+      context.evaluateExpressionHandle(`arg => globalThis['${PageBinding.kController}'].deliverBindingResult(arg)`, { isFunction: true }, { name, seq, result }).catch((e) => import_debugLogger.debugLogger.log("error", e));
     } catch (error) {
-      context.evaluate(import_pageBinding.deliverBindingResult, { name, seq, error }).catch((e) => import_debugLogger.debugLogger.log("error", e));
+      context.evaluateExpressionHandle(`arg => globalThis['${PageBinding.kController}'].deliverBindingResult(arg)`, { isFunction: true }, { name, seq, error }).catch((e) => import_debugLogger.debugLogger.log("error", e));
     }
   }
-}
-class InitScript {
-  constructor(source) {
-    this.source = `(() => { ${source} })();`;
+  async dispose() {
+    await this.parent.removeExposedBinding(this);
   }
 }
-class FrameThrottler {
-  constructor(nonThrottledFrames, defaultInterval, throttlingInterval) {
-    this._acks = [];
-    this._throttlingEnabled = false;
-    this._nonThrottledFrames = nonThrottledFrames;
-    this._budget = nonThrottledFrames;
-    this._defaultInterval = defaultInterval;
-    this._throttlingInterval = throttlingInterval;
-    this._tick();
-  }
-  dispose() {
-    if (this._timeoutId) {
-      clearTimeout(this._timeoutId);
-      this._timeoutId = void 0;
-    }
-  }
-  setThrottlingEnabled(enabled) {
-    this._throttlingEnabled = enabled;
-  }
-  recharge() {
-    for (const ack of this._acks)
-      ack();
-    this._acks = [];
-    this._budget = this._nonThrottledFrames;
-    if (this._timeoutId) {
-      clearTimeout(this._timeoutId);
-      this._tick();
-    }
-  }
-  ack(ack) {
-    if (!this._timeoutId) {
-      ack();
-      return;
-    }
-    this._acks.push(ack);
+class InitScript extends import_disposable.DisposableObject {
+  constructor(owner, source) {
+    super(owner);
+    this.source = `(() => {
+      ${source}
+    })();`;
   }
-  _tick() {
-    const ack = this._acks.shift();
-    if (ack) {
-      --this._budget;
-      ack();
-    }
-    if (this._throttlingEnabled && this._budget <= 0) {
-      this._timeoutId = setTimeout(() => this._tick(), this._throttlingInterval);
-    } else {
-      this._timeoutId = setTimeout(() => this._tick(), this._defaultInterval);
-    }
+  async dispose() {
+    await this.parent.removeInitScript(this);
   }
 }
-async function snapshotFrameForAI(progress, frame, options) {
+async function ariaSnapshotForFrame(progress, frame, options = {}) {
   const snapshot = await frame.retryWithProgressAndTimeouts(progress, [1e3, 2e3, 4e3, 8e3], async (continuePolling) => {
     try {
       const context = await progress.race(frame._utilityContext());
       const injectedScript = await progress.race(context.injectedScript());
       const snapshotOrRetry = await progress.race(injectedScript.evaluate((injected, options2) => {
+        if (options2.info) {
+          const element = injected.querySelector(options2.info.parsed, injected.document, options2.info.strict);
+          if (!element)
+            return false;
+          return injected.incrementalAriaSnapshot(element, options2);
+        }
         const node = injected.document.body;
         if (!node)
           return true;
-        return injected.incrementalAriaSnapshot(node, { mode: "ai", ...options2 });
-      }, { refPrefix: frame.seq ? "f" + frame.seq : "", track: options.track }));
+        return injected.incrementalAriaSnapshot(node, options2);
+      }, {
+        mode: options.mode ?? "default",
+        refPrefix: frame.seq ? "f" + frame.seq : "",
+        track: options.track,
+        doNotRenderActive: options.doNotRenderActive,
+        info: options.info,
+        depth: options.depth
+      }));
       if (snapshotOrRetry === true)
         return continuePolling;
+      if (snapshotOrRetry === false)
+        throw new import_dom.NonRecoverableDOMError(`Selector "${(0, import_selectorParser.stringifySelector)(options.info.parsed)}" does not match any element`);
       return snapshotOrRetry;
     } catch (e) {
       if (frame.isNonRetriableError(e))
@@ -814,18 +829,23 @@ async function snapshotFrameForAI(progress, frame, options) {
       return continuePolling;
     }
   });
-  const childSnapshotPromises = snapshot.iframeRefs.map((ref) => snapshotFrameRefForAI(progress, frame, ref, options));
+  const renderedIframeRefs = snapshot.iframeRefs.filter((ref) => ref in snapshot.iframeDepths);
+  const childSnapshotPromises = renderedIframeRefs.map((ref) => {
+    const iframeDepth = snapshot.iframeDepths[ref];
+    const childDepth = options.depth ? options.depth - iframeDepth - 1 : void 0;
+    return ariaSnapshotFrameRef(progress, frame, ref, { ...options, depth: childDepth });
+  });
   const childSnapshots = await Promise.all(childSnapshotPromises);
   const full = [];
   let incremental;
   if (snapshot.incremental !== void 0) {
     incremental = snapshot.incremental.split("\n");
-    for (let i = 0; i < snapshot.iframeRefs.length; i++) {
+    for (let i = 0; i < renderedIframeRefs.length; i++) {
       const childSnapshot = childSnapshots[i];
       if (childSnapshot.incremental)
         incremental.push(...childSnapshot.incremental);
       else if (childSnapshot.full.length)
-        incremental.push("- <changed> iframe [ref=" + snapshot.iframeRefs[i] + "]:", ...childSnapshot.full.map((l) => "  " + l));
+        incremental.push("- <changed> iframe [ref=" + renderedIframeRefs[i] + "]:", ...childSnapshot.full.map((l) => "  " + l));
     }
   }
   for (const line of snapshot.full.split("\n")) {
@@ -836,20 +856,20 @@ async function snapshotFrameForAI(progress, frame, options) {
     }
     const leadingSpace = match[1];
     const ref = match[2];
-    const childSnapshot = childSnapshots[snapshot.iframeRefs.indexOf(ref)] ?? { full: [] };
+    const childSnapshot = childSnapshots[renderedIframeRefs.indexOf(ref)] ?? { full: [] };
     full.push(childSnapshot.full.length ? line + ":" : line);
     full.push(...childSnapshot.full.map((l) => leadingSpace + "  " + l));
   }
   return { full, incremental };
 }
-async function snapshotFrameRefForAI(progress, parentFrame, frameRef, options) {
+async function ariaSnapshotFrameRef(progress, parentFrame, frameRef, options) {
   const frameSelector = `aria-ref=${frameRef} >> internal:control=enter-frame`;
   const frameBodySelector = `${frameSelector} >> body`;
   const child = await progress.race(parentFrame.selectors.resolveFrameForSelector(frameBodySelector, { strict: true }));
   if (!child)
     return { full: [] };
   try {
-    return await snapshotFrameForAI(progress, child.frame, options);
+    return await ariaSnapshotForFrame(progress, child.frame, { ...options, info: void 0 });
   } catch {
     return { full: [] };
   }
@@ -864,5 +884,7 @@ function ensureArrayLimit(array, limit) {
   InitScript,
   Page,
   PageBinding,
-  Worker
+  Worker,
+  WorkerEvent,
+  ariaSnapshotForFrame
 });

package/lib/server/progress.js

@@ -34,19 +34,41 @@ class ProgressController {
     this.metadata = metadata || { id: "", startTime: 0, endTime: 0, type: "Internal", method: "", params: {}, log: [], internal: true };
     this._onCallLog = onCallLog;
     this._forceAbortPromise.catch((e) => null);
+    this._controller = new AbortController();
+  }
+  static createForSdkObject(sdkObject, callMetadata) {
+    const logName = sdkObject.logName || "api";
+    return new ProgressController(callMetadata, (message) => {
+      if (logName === "api" && sdkObject.attribution.playwright?.options.isInternalPlaywright)
+        return;
+      import_utils.debugLogger.log(logName, message);
+      sdkObject.instrumentation.onCallLog(sdkObject, callMetadata, logName, message);
+    });
+  }
+  static runInternalTask(task, timeout) {
+    const progress = new ProgressController();
+    return progress.run(task, timeout);
   }
   async abort(error) {
     if (this._state === "running") {
       error[kAbortErrorSymbol] = true;
       this._state = { error };
       this._forceAbortPromise.reject(error);
+      this._controller.abort(error);
     }
     await this._donePromise;
   }
   async run(task, timeout) {
+    const deadline = timeout ? (0, import_utils.monotonicTime)() + timeout : 0;
     (0, import_utils.assert)(this._state === "before");
     this._state = "running";
+    let timer;
     const progress = {
+      timeout: timeout ?? 0,
+      deadline,
+      disableTimeout: () => {
+        clearTimeout(timer);
+      },
       log: (message) => {
         if (this._state === "running")
           this.metadata.log.push(message);
@@ -55,24 +77,28 @@ class ProgressController {
       metadata: this.metadata,
       race: (promise) => {
         const promises = Array.isArray(promise) ? promise : [promise];
+        if (!promises.length)
+          return Promise.resolve();
         return Promise.race([...promises, this._forceAbortPromise]);
       },
       wait: async (timeout2) => {
         let timer2;
         const promise = new Promise((f) => timer2 = setTimeout(f, timeout2));
         return progress.race(promise).finally(() => clearTimeout(timer2));
-      }
+      },
+      signal: this._controller.signal
     };
-    let timer;
-    if (timeout) {
+    if (deadline) {
       const timeoutError = new import_errors.TimeoutError(`Timeout ${timeout}ms exceeded.`);
       timer = setTimeout(() => {
+        if (this.metadata.pauseStartTime && !this.metadata.pauseEndTime)
+          return;
         if (this._state === "running") {
-          timeoutError[kAbortErrorSymbol] = true;
           this._state = { error: timeoutError };
           this._forceAbortPromise.reject(timeoutError);
+          this._controller.abort(timeoutError);
         }
-      }, timeout);
+      }, deadline - (0, import_utils.monotonicTime)());
     }
     try {
       const result = await task(progress);
@@ -89,7 +115,7 @@ class ProgressController {
 }
 const kAbortErrorSymbol = Symbol("kAbortError");
 function isAbortError(error) {
-  return !!error[kAbortErrorSymbol];
+  return error instanceof import_errors.TimeoutError || !!error[kAbortErrorSymbol];
 }
 async function raceUncancellableOperationWithCleanup(progress, run, cleanup) {
   let aborted = false;