patchright-core 1.56.1 → 1.58.2

package/lib/server/input.js

@@ -182,9 +182,9 @@ class Mouse {
     await this._raw.up(progress, this._x, this._y, button, this._buttons, this._keyboard._modifiers(), clickCount);
   }
   async click(progress, x, y, options = {}) {
-    const { delay = null, clickCount = 1 } = options;
+    const { delay = null, clickCount = 1, steps } = options;
     if (delay) {
-      this.move(progress, x, y, { forClick: true });
+      await this.move(progress, x, y, { forClick: true, steps });
       for (let cc = 1; cc <= clickCount; ++cc) {
         await this.down(progress, { ...options, clickCount: cc });
         await progress.wait(delay);
@@ -194,7 +194,11 @@ class Mouse {
       }
     } else {
       const promises = [];
-      promises.push(this.move(progress, x, y, { forClick: true }));
+      const movePromise = this.move(progress, x, y, { forClick: true, steps });
+      if (steps !== void 0 && steps > 1)
+        await movePromise;
+      else
+        promises.push(movePromise);
       for (let cc = 1; cc <= clickCount; ++cc) {
         promises.push(this.down(progress, { ...options, clickCount: cc }));
         promises.push(this.up(progress, { ...options, clickCount: cc }));

package/lib/server/instrumentation.js

@@ -33,6 +33,9 @@ class SdkObject extends import_events.EventEmitter {
     this.attribution = { ...parent.attribution };
     this.instrumentation = parent.instrumentation;
   }
+  closeReason() {
+    return this.attribution.page?._closeReason || this.attribution.context?._closeReason || this.attribution.browser?._closeReason;
+  }
 }
 function createRootSdkObject() {
   const fakeParent = { attribution: {}, instrumentation: createInstrumentation() };

package/lib/server/javascript.js

@@ -118,10 +118,12 @@ class JSHandle extends import_instrumentation.SdkObject {
     if (context.constructor.name === "FrameExecutionContext") {
       const frame = context.frame;
       if (frame) {
-        if (isolatedContext) context = await frame._utilityContext();
-        else if (!isolatedContext) context = await frame._mainContext();
+        if (isolatedContext === true) context = await frame._utilityContext();
+        else if (isolatedContext === false) context = await frame._mainContext();
       }
     }
+    if (context !== this._context && context.adoptIfNeeded(this) === null)
+      context = this._context;
     const value = await evaluateExpression(context, expression, { ...options, returnByValue: true }, this, arg);
     await context.doSlowMo();
     return value;
@@ -131,10 +133,12 @@ class JSHandle extends import_instrumentation.SdkObject {
     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();
+        if (isolatedContext === true) context = await frame._utilityContext();
+        else if (isolatedContext === false) context = await frame._mainContext();
       }
     }
+    if (context !== this._context && context.adoptIfNeeded(this) === null)
+      context = this._context;
     const value = await evaluateExpression(context, expression, { ...options, returnByValue: false }, this, arg);
     await context.doSlowMo();
     return value;

package/lib/server/launchApp.js

@@ -114,7 +114,8 @@ async function syncLocalStorageWithSettings(page, appName) {
           return;
         Object.entries(settings2).map(([k, v]) => localStorage[k] = v);
         window.saveSettings = () => {
-          window._saveSerializedSettings(JSON.stringify({ ...localStorage }));
+          if (typeof window._saveSerializedSettings === "function")
+            window._saveSerializedSettings(JSON.stringify({ ...localStorage }));
         };
       })})(${settings});
     `

package/lib/server/localUtils.js

@@ -65,12 +65,8 @@ async function zip(progress, stackSessions, params) {
   const stackSession = params.stacksId ? stackSessions.get(params.stacksId) : void 0;
   if (stackSession?.callStacks.length) {
     await progress.race(stackSession.writer);
-    if (process.env.PW_LIVE_TRACE_STACKS) {
-      zipFile.addFile(stackSession.file, "trace.stacks");
-    } else {
-      const buffer = Buffer.from(JSON.stringify((0, import_traceUtils.serializeClientSideCallMetadata)(stackSession.callStacks)));
-      zipFile.addBuffer(buffer, "trace.stacks");
-    }
+    const buffer = Buffer.from(JSON.stringify((0, import_traceUtils.serializeClientSideCallMetadata)(stackSession.callStacks)));
+    zipFile.addBuffer(buffer, "trace.stacks");
   }
   if (params.includeSources) {
     const sourceFiles = /* @__PURE__ */ new Set();
@@ -188,7 +184,7 @@ async function tracingStarted(progress, stackSessions, params) {
   if (!params.tracesDir)
     tmpDir = await progress.race(import_fs.default.promises.mkdtemp(import_path.default.join(import_os.default.tmpdir(), "playwright-tracing-")));
   const traceStacksFile = import_path.default.join(params.tracesDir || tmpDir, params.traceName + ".stacks");
-  stackSessions.set(traceStacksFile, { callStacks: [], file: traceStacksFile, writer: Promise.resolve(), tmpDir });
+  stackSessions.set(traceStacksFile, { callStacks: [], file: traceStacksFile, writer: Promise.resolve(), tmpDir, live: params.live });
   return { stacksId: traceStacksFile };
 }
 async function traceDiscarded(progress, stackSessions, params) {
@@ -197,7 +193,7 @@ async function traceDiscarded(progress, stackSessions, params) {
 function addStackToTracingNoReply(stackSessions, params) {
   for (const session of stackSessions.values()) {
     session.callStacks.push(params.callData);
-    if (process.env.PW_LIVE_TRACE_STACKS) {
+    if (session.live) {
       session.writer = session.writer.then(() => {
         const buffer = Buffer.from(JSON.stringify((0, import_traceUtils.serializeClientSideCallMetadata)(session.callStacks)));
         return import_fs.default.promises.writeFile(session.file, buffer);

package/lib/server/network.js

@@ -22,6 +22,7 @@ __export(network_exports, {
   Response: () => Response,
   Route: () => Route,
   WebSocket: () => WebSocket,
+  applyHeadersOverrides: () => applyHeadersOverrides,
   filterCookies: () => filterCookies,
   isLocalHostname: () => isLocalHostname,
   kMaxCookieExpiresDateInSeconds: () => kMaxCookieExpiresDateInSeconds,
@@ -61,6 +62,48 @@ function filterCookies(cookies, urls) {
 function isLocalHostname(hostname) {
   return hostname === "localhost" || hostname.endsWith(".localhost");
 }
+const FORBIDDEN_HEADER_NAMES = /* @__PURE__ */ new Set([
+  "accept-charset",
+  "accept-encoding",
+  "access-control-request-headers",
+  "access-control-request-method",
+  "connection",
+  "content-length",
+  "cookie",
+  "date",
+  "dnt",
+  "expect",
+  "host",
+  "keep-alive",
+  "origin",
+  "referer",
+  "set-cookie",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+  "via"
+]);
+const FORBIDDEN_METHODS = /* @__PURE__ */ new Set(["CONNECT", "TRACE", "TRACK"]);
+function isForbiddenHeader(name, value) {
+  const lowerName = name.toLowerCase();
+  if (FORBIDDEN_HEADER_NAMES.has(lowerName))
+    return true;
+  if (lowerName.startsWith("proxy-"))
+    return true;
+  if (lowerName.startsWith("sec-"))
+    return true;
+  if (lowerName === "x-http-method" || lowerName === "x-http-method-override" || lowerName === "x-method-override") {
+    if (value && FORBIDDEN_METHODS.has(value.toUpperCase()))
+      return true;
+  }
+  return false;
+}
+function applyHeadersOverrides(original, overrides) {
+  const forbiddenHeaders = original.filter((header) => isForbiddenHeader(header.name, header.value));
+  const allowedHeaders = overrides.filter((header) => !isForbiddenHeader(header.name, header.value));
+  return mergeHeaders([allowedHeaders, forbiddenHeaders]);
+}
 const kMaxCookieExpiresDateInSeconds = 253402300799;
 function rewriteCookies(cookies) {
   return cookies.map((c) => {
@@ -99,7 +142,6 @@ class Request extends import_instrumentation.SdkObject {
     this._response = null;
     this._redirectedTo = null;
     this._failureText = null;
-    this._headersMap = /* @__PURE__ */ new Map();
     this._frame = null;
     this._serviceWorker = null;
     this._rawRequestHeadersPromise = new import_manualPromise.ManualPromise();
@@ -118,7 +160,6 @@ class Request extends import_instrumentation.SdkObject {
     this._method = method;
     this._postData = postData;
     this._headers = headers;
-    this._updateHeadersMap();
     this._isFavicon = url.endsWith("/favicon.ico") || !!redirectedFrom?._isFavicon;
   }
   static {
@@ -132,13 +173,8 @@ class Request extends import_instrumentation.SdkObject {
   }
   _applyOverrides(overrides) {
     this._overrides = { ...this._overrides, ...overrides };
-    this._updateHeadersMap();
     return this._overrides;
   }
-  _updateHeadersMap() {
-    for (const { name, value } of this.headers())
-      this._headersMap.set(name.toLowerCase(), value);
-  }
   overrides() {
     return this._overrides;
   }
@@ -158,7 +194,8 @@ class Request extends import_instrumentation.SdkObject {
     return this._overrides?.headers || this._headers;
   }
   headerValue(name) {
-    return this._headersMap.get(name);
+    const lowerCaseName = name.toLowerCase();
+    return this.headers().find((h) => h.name.toLowerCase() === lowerCaseName)?.value;
   }
   // "null" means no raw headers available - we'll use provisional headers as raw headers.
   setRawRequestHeaders(headers) {
@@ -309,10 +346,7 @@ class Route extends import_instrumentation.SdkObject {
         throw new Error("New URL must have same protocol as overridden URL");
     }
     if (overrides.headers) {
-      overrides.headers = overrides.headers?.filter((header) => {
-        const headerName = header.name.toLowerCase();
-        return headerName !== "cookie" && headerName !== "host";
-      });
+      overrides.headers = applyHeadersOverrides(this._request._headers, overrides.headers);
     }
     overrides = this._request._applyOverrides(overrides);
     const nextHandler = this._futureHandlers.shift();
@@ -436,6 +470,9 @@ class Response extends import_instrumentation.SdkObject {
   request() {
     return this._request;
   }
+  finished() {
+    return this._finishedPromise;
+  }
   frame() {
     return this._request.frame();
   }
@@ -617,6 +654,7 @@ function mergeHeaders(headers) {
   Response,
   Route,
   WebSocket,
+  applyHeadersOverrides,
   filterCookies,
   isLocalHostname,
   kMaxCookieExpiresDateInSeconds,

package/lib/server/page.js

@@ -31,11 +31,11 @@ __export(page_exports, {
   InitScript: () => InitScript,
   Page: () => Page,
   PageBinding: () => PageBinding,
-  Worker: () => Worker
+  Worker: () => Worker,
+  WorkerEvent: () => WorkerEvent
 });
 module.exports = __toCommonJS(page_exports);
 var import_pageBinding = require("./pageBinding");
-var accessibility = __toESM(require("./accessibility"));
 var import_browserContext = require("./browserContext");
 var import_console = require("./console");
 var import_errors = require("./errors");
@@ -54,6 +54,22 @@ 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 import_screencast = require("./screencast");
+const PageEvent = {
+  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"
+};
 class Page extends import_instrumentation.SdkObject {
   constructor(delegate, browserContext) {
     super(browserContext, "page");
@@ -75,40 +91,22 @@ class Page extends import_instrumentation.SdkObject {
     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.lastSnapshotFrameIds = [];
     this.attribution.page = this;
     this.delegate = delegate;
     this.browserContext = browserContext;
-    this.accessibility = new accessibility.Accessibility(delegate.getAccessibilityTree.bind(delegate));
     this.keyboard = new input.Keyboard(delegate.rawKeyboard, this);
     this.mouse = new input.Mouse(delegate.rawMouse, this);
     this.touchscreen = new input.Touchscreen(delegate.rawTouchscreen, this);
     this.screenshotter = new import_screenshotter.Screenshotter(this);
     this.frameManager = new frames.FrameManager(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) {
@@ -161,17 +159,17 @@ class Page extends import_instrumentation.SdkObject {
   }
   _didClose() {
     this.frameManager.dispose();
-    this._frameThrottler.dispose();
+    this.screencast.stopFrameThrottler();
     (0, import_utils.assert)(this._closedState !== "closed", "Page closed twice");
     this._closedState = "closed";
     this.emit(Page.Events.Close);
     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.stopFrameThrottler();
     this.emit(Page.Events.Crash);
     this._crashed = true;
     this.instrumentation.onPageClose(this);
@@ -243,8 +241,8 @@ class Page extends import_instrumentation.SdkObject {
       return;
     await PageBinding.dispatch(this, payload, context);
   }
-  addConsoleMessage(type, args, location, text) {
-    const message = new import_console.ConsoleMessage(this, type, text, args, location);
+  addConsoleMessage(worker, type, args, location, text) {
+    const message = new import_console.ConsoleMessage(this, worker, type, text, args, location);
     const intercepted = this.frameManager.interceptConsoleMessage(message);
     if (intercepted) {
       args.forEach((arg) => arg.dispose());
@@ -341,6 +339,8 @@ class Page extends import_instrumentation.SdkObject {
     await this._performWaitForNavigationCheck(progress);
   }
   async _performWaitForNavigationCheck(progress) {
+    if (process.env.PLAYWRIGHT_SKIP_NAVIGATION_CHECK)
+      return;
     const mainFrame = this.frameManager.mainFrame();
     if (!mainFrame || !mainFrame.pendingDocument())
       return;
@@ -568,10 +568,11 @@ 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 (this._closedState !== "closing") {
-      this._closedState = "closing";
+      if (!runBeforeUnload)
+        this._closedState = "closing";
       await this.delegate.closePage(runBeforeUnload).catch((e) => import_debugLogger.debugLogger.log("error", e));
     }
     if (!runBeforeUnload)
@@ -624,16 +625,6 @@ class Page extends import_instrumentation.SdkObject {
   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,35 +639,40 @@ class Page extends import_instrumentation.SdkObject {
     await Promise.all(this.frames().map((frame) => frame.hideHighlight().catch(() => {
     })));
   }
-  async snapshotForAI(progress) {
-    this.lastSnapshotFrameIds = [];
-    const snapshot = await snapshotFrameForAI(progress, this.mainFrame(), 0, this.lastSnapshotFrameIds);
-    return snapshot.join("\n");
+  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()];
   }
 }
+const WorkerEvent = {
+  Close: "close"
+};
 class Worker extends import_instrumentation.SdkObject {
   constructor(parent, url) {
     super(parent, "worker");
+    this._executionContextPromise = new import_manualPromise.ManualPromise();
+    this._workerScriptLoaded = false;
     this.existingExecutionContext = null;
     this.openScope = new import_utils.LongStandingScope();
     this.url = url;
-    this._executionContextCallback = () => {
-    };
-    this._executionContextPromise = new Promise((x) => this._executionContextCallback = x);
   }
   static {
-    this.Events = {
-      Close: "close"
-    };
+    this.Events = WorkerEvent;
   }
   createExecutionContext(delegate) {
     this.existingExecutionContext = new js.ExecutionContext(this, delegate, "worker");
-    this._executionContextCallback(this.existingExecutionContext);
+    if (this._workerScriptLoaded)
+      this._executionContextPromise.resolve(this.existingExecutionContext);
     return this.existingExecutionContext;
   }
+  workerScriptLoaded() {
+    this._workerScriptLoaded = true;
+    if (this.existingExecutionContext)
+      this._executionContextPromise.resolve(this.existingExecutionContext);
+  }
   didClose() {
     if (this.existingExecutionContext)
       this.existingExecutionContext.contextDestroyed("Worker was closed");
@@ -715,6 +711,32 @@ class PageBinding {
   }
   static async dispatch(page, payload, context) {
     const { name, seq, serializedArgs } = JSON.parse(payload);
+    const deliver = async (deliverPayload) => {
+      let deliveryError;
+      try {
+        await context.evaluate(import_pageBinding.deliverBindingResult, deliverPayload);
+        return;
+      } catch (e) {
+        deliveryError = e;
+      }
+      const frame = context.frame;
+      if (!frame) {
+        import_debugLogger.debugLogger.log("error", deliveryError);
+        return;
+      }
+      const mainContext = await frame._mainContext().catch(() => null);
+      const utilityContext = await frame._utilityContext().catch(() => null);
+      for (const ctx of [mainContext, utilityContext]) {
+        if (!ctx || ctx === context)
+          continue;
+        try {
+          await ctx.evaluate(import_pageBinding.deliverBindingResult, deliverPayload);
+          return;
+        } catch {
+        }
+      }
+      import_debugLogger.debugLogger.log("error", deliveryError);
+    };
     try {
       (0, import_utils.assert)(context.world);
       const binding = page.getBinding(name);
@@ -730,9 +752,9 @@ class PageBinding {
         const args = serializedArgs.map((a) => (0, import_utilityScriptSerializers.parseEvaluationResultValue)(a));
         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));
+      await deliver({ name, seq, result });
     } catch (error) {
-      context.evaluate(import_pageBinding.deliverBindingResult, { name, seq, error }).catch((e) => import_debugLogger.debugLogger.log("error", e));
+      await deliver({ name, seq, error });
     }
   }
 }
@@ -741,66 +763,17 @@ class InitScript {
     this.source = `(() => { ${source} })();`;
   }
 }
-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);
-  }
-  _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 function snapshotFrameForAI(progress, frame, frameOrdinal, frameIds) {
+async function snapshotFrameForAI(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, refPrefix) => {
+      const snapshotOrRetry = await progress.race(injectedScript.evaluate((injected, options2) => {
         const node = injected.document.body;
         if (!node)
           return true;
-        return injected.ariaSnapshot(node, { mode: "ai", refPrefix });
-      }, frameOrdinal ? "f" + frameOrdinal : ""));
+        return injected.incrementalAriaSnapshot(node, { mode: "ai", ...options2 });
+      }, { refPrefix: frame.seq ? "f" + frame.seq : "", track: options.track, doNotRenderActive: options.doNotRenderActive }));
       if (snapshotOrRetry === true)
         return continuePolling;
       return snapshotOrRetry;
@@ -810,33 +783,45 @@ async function snapshotFrameForAI(progress, frame, frameOrdinal, frameIds) {
       return continuePolling;
     }
   });
-  const lines = snapshot.split("\n");
-  const result = [];
-  for (const line of lines) {
+  const childSnapshotPromises = snapshot.iframeRefs.map((ref) => snapshotFrameRefForAI(progress, frame, ref, options));
+  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++) {
+      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));
+    }
+  }
+  for (const line of snapshot.full.split("\n")) {
     const match = line.match(/^(\s*)- iframe (?:\[active\] )?\[ref=([^\]]*)\]/);
     if (!match) {
-      result.push(line);
+      full.push(line);
       continue;
     }
     const leadingSpace = match[1];
     const ref = match[2];
-    const frameSelector = `aria-ref=${ref} >> internal:control=enter-frame`;
-    const frameBodySelector = `${frameSelector} >> body`;
-    const child = await progress.race(frame.selectors.resolveFrameForSelector(frameBodySelector, { strict: true }));
-    if (!child) {
-      result.push(line);
-      continue;
-    }
-    const frameOrdinal2 = frameIds.length + 1;
-    frameIds.push(child.frame._id);
-    try {
-      const childSnapshot = await snapshotFrameForAI(progress, child.frame, frameOrdinal2, frameIds);
-      result.push(line + ":", ...childSnapshot.map((l) => leadingSpace + "  " + l));
-    } catch {
-      result.push(line);
-    }
+    const childSnapshot = childSnapshots[snapshot.iframeRefs.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) {
+  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);
+  } catch {
+    return { full: [] };
   }
-  return result;
 }
 function ensureArrayLimit(array, limit) {
   if (array.length > limit)
@@ -848,5 +833,6 @@ function ensureArrayLimit(array, limit) {
   InitScript,
   Page,
   PageBinding,
-  Worker
+  Worker,
+  WorkerEvent
 });

package/lib/server/playwright.js

@@ -45,10 +45,8 @@ class Playwright extends import_instrumentation.SdkObject {
       onPageOpen: (page) => this._allPages.add(page),
       onPageClose: (page) => this._allPages.delete(page)
     }, null);
-    this.chromium = new import_chromium.Chromium(this);
-    this._bidiChromium = new import_bidiChromium.BidiChromium(this);
-    this._bidiFirefox = new import_bidiFirefox.BidiFirefox(this);
-    this.firefox = new import_firefox.Firefox(this);
+    this.chromium = new import_chromium.Chromium(this, new import_bidiChromium.BidiChromium(this));
+    this.firefox = new import_firefox.Firefox(this, new import_bidiFirefox.BidiFirefox(this));
     this.webkit = new import_webkit.WebKit(this);
     this.electron = new import_electron.Electron(this);
     this.android = new import_android.Android(this, new import_backendAdb.AdbBackend());