brave-real-playwright-core 1.56.1 → 1.57.0

package/lib/server/dispatchers/playwrightDispatcher.js

@@ -39,15 +39,11 @@ class PlaywrightDispatcher extends import_dispatcher.Dispatcher {
     const chromium = new import_browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright.chromium, denyLaunch);
     const firefox = new import_browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright.firefox, denyLaunch);
     const webkit = new import_browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright.webkit, denyLaunch);
-    const _bidiChromium = new import_browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright._bidiChromium, denyLaunch);
-    const _bidiFirefox = new import_browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright._bidiFirefox, denyLaunch);
     const android = new import_androidDispatcher.AndroidDispatcher(scope, playwright.android);
     const initializer = {
       chromium,
       firefox,
       webkit,
-      _bidiChromium,
-      _bidiFirefox,
       android,
       electron: new import_electronDispatcher.ElectronDispatcher(scope, playwright.electron, denyLaunch),
       utils: playwright.options.isServer ? void 0 : new import_localUtilsDispatcher.LocalUtilsDispatcher(scope, playwright),

package/lib/server/electron/electron.js

@@ -97,7 +97,7 @@ class ElectronApplication extends import_instrumentation.SdkObject {
     if (!this._nodeExecutionContext)
       return;
     const args = event.args.map((arg) => (0, import_crExecutionContext.createHandle)(this._nodeExecutionContext, arg));
-    const message = new import_console.ConsoleMessage(null, event.type, void 0, args, (0, import_crProtocolHelper.toConsoleMessageLocation)(event.stackTrace));
+    const message = new import_console.ConsoleMessage(null, null, event.type, void 0, args, (0, import_crProtocolHelper.toConsoleMessageLocation)(event.stackTrace));
     this.emit(ElectronApplication.Events.Console, message);
   }
   async initialize() {

package/lib/server/firefox/ffPage.js

@@ -37,7 +37,6 @@ var dialog = __toESM(require("../dialog"));
 var dom = __toESM(require("../dom"));
 var import_page = require("../page");
 var import_page2 = require("../page");
-var import_ffAccessibility = require("./ffAccessibility");
 var import_ffConnection = require("./ffConnection");
 var import_ffExecutionContext = require("./ffExecutionContext");
 var import_ffInput = require("./ffInput");
@@ -201,7 +200,7 @@ class FFPage {
     const context = this._contextIdToContext.get(executionContextId);
     if (!context)
       return;
-    this._page.addConsoleMessage(type === "warn" ? "warning" : type, args.map((arg) => (0, import_ffExecutionContext.createHandle)(context, arg)), location);
+    this._page.addConsoleMessage(null, type === "warn" ? "warning" : type, args.map((arg) => (0, import_ffExecutionContext.createHandle)(context, arg)), location);
   }
   _onDialogOpened(params) {
     this._page.browserContext.dialogManager.dialogDidOpen(new dialog.Dialog(
@@ -246,11 +245,12 @@ class FFPage {
     this._page.addWorker(workerId, worker);
     workerSession.once("Runtime.executionContextCreated", (event2) => {
       worker.createExecutionContext(new import_ffExecutionContext.FFExecutionContext(workerSession, event2.executionContextId));
+      worker.workerScriptLoaded();
     });
     workerSession.on("Runtime.console", (event2) => {
       const { type, args, location } = event2;
       const context = worker.existingExecutionContext;
-      this._page.addConsoleMessage(type, args.map((arg) => (0, import_ffExecutionContext.createHandle)(context, arg)), location);
+      this._page.addConsoleMessage(worker, type, args.map((arg) => (0, import_ffExecutionContext.createHandle)(context, arg)), location);
     });
   }
   _onWorkerDestroyed(event) {
@@ -468,9 +468,6 @@ class FFPage {
       throw new Error(dom.kUnableToAdoptErrorMessage);
     return (0, import_ffExecutionContext.createHandle)(to, result.remoteObject);
   }
-  async getAccessibilityTree(needle) {
-    return (0, import_ffAccessibility.getAccessibilityTree)(this._session, needle);
-  }
   async inputActionEpilogue() {
   }
   async resetForReuse(progress) {

package/lib/server/firefox/firefox.js

@@ -39,8 +39,19 @@ var import_ascii = require("../utils/ascii");
 var import_browserType = require("../browserType");
 var import_manualPromise = require("../../utils/isomorphic/manualPromise");
 class Firefox extends import_browserType.BrowserType {
-  constructor(parent) {
+  constructor(parent, bidiFirefox) {
     super(parent, "firefox");
+    this._bidiFirefox = bidiFirefox;
+  }
+  launch(progress, options, protocolLogger) {
+    if (options.channel?.startsWith("moz-"))
+      return this._bidiFirefox.launch(progress, options, protocolLogger);
+    return super.launch(progress, options, protocolLogger);
+  }
+  async launchPersistentContext(progress, userDataDir, options) {
+    if (options.channel?.startsWith("moz-"))
+      return this._bidiFirefox.launchPersistentContext(progress, userDataDir, options);
+    return super.launchPersistentContext(progress, userDataDir, options);
   }
   connectToTransport(transport, options) {
     return import_ffBrowser.FFBrowser.connect(this.attribution.playwright, transport, options);

package/lib/server/frameSelectors.js

@@ -89,10 +89,8 @@ class FrameSelectors {
     const match = body.match(/^f(\d+)e\d+$/);
     if (!match)
       return frame;
-    const frameIndex = +match[1];
-    const page = this.frame._page;
-    const frameId = page.lastSnapshotFrameIds[frameIndex - 1];
-    const jumptToFrame = frameId ? page.frameManager.frame(frameId) : null;
+    const frameSeq = +match[1];
+    const jumptToFrame = this.frame._page.frameManager.frames().find((frame2) => frame2.seq === frameSeq);
     if (!jumptToFrame)
       throw new import_selectorParser.InvalidSelectorError(`Invalid frame in aria-ref selector "${selector}"`);
     return jumptToFrame;

package/lib/server/frames.js

@@ -65,9 +65,13 @@ class FrameManager {
     this._consoleMessageTags = /* @__PURE__ */ new Map();
     this._signalBarriers = /* @__PURE__ */ new Set();
     this._webSockets = /* @__PURE__ */ new Map();
+    this._nextFrameSeq = 0;
     this._page = page;
     this._mainFrame = void 0;
   }
+  nextFrameSeq() {
+    return this._nextFrameSeq++;
+  }
   createDummyMainFrameIfNeeded() {
     if (!this._mainFrame)
       this.frameAttached(kDummyFrameId, null);
@@ -361,6 +365,7 @@ class Frame extends import_instrumentation.SdkObject {
     this._raceAgainstEvaluationStallingEventsPromises = /* @__PURE__ */ new Set();
     this._redirectedNavigations = /* @__PURE__ */ new Map();
     this.attribution.frame = this;
+    this.seq = page.frameManager.nextFrameSeq();
     this._id = id;
     this._page = page;
     this._parentFrame = parentFrame;
@@ -989,7 +994,7 @@ class Frame extends import_instrumentation.SdkObject {
     }));
     dom.assertDone(await this._retryWithProgressIfNotConnected(progress, target, options.strict, false, async (handle) => {
       return handle._retryPointerAction(progress, "move and up", false, async (point) => {
-        await this._page.mouse.move(progress, point.x, point.y);
+        await this._page.mouse.move(progress, point.x, point.y, { steps: options.steps });
         await this._page.mouse.up(progress);
       }, {
         ...options,
@@ -1220,10 +1225,12 @@ class Frame extends import_instrumentation.SdkObject {
     if (log)
       progress.log(log);
     if (matches === options.isNot) {
-      if (missingReceived)
+      if (missingReceived) {
         lastIntermediateResult.errorMessage = "Error: element(s) not found";
-      else
+      } else {
+        lastIntermediateResult.errorMessage = void 0;
         lastIntermediateResult.received = received;
+      }
       lastIntermediateResult.isSet = true;
       if (!missingReceived && !Array.isArray(received))
         progress.log(`  unexpected value "${renderUnexpectedValue(options.expression, received)}"`);

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/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/page.js

@@ -34,7 +34,6 @@ __export(page_exports, {
   Worker: () => Worker
 });
 module.exports = __toCommonJS(page_exports);
-var accessibility = __toESM(require("./accessibility"));
 var import_browserContext = require("./browserContext");
 var import_console = require("./console");
 var import_errors = require("./errors");
@@ -78,11 +77,9 @@ class Page extends import_instrumentation.SdkObject {
     // 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);
@@ -253,8 +250,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());
@@ -351,6 +348,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;
@@ -582,7 +581,8 @@ class Page extends import_instrumentation.SdkObject {
       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)
@@ -665,23 +665,19 @@ 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") };
   }
 }
 class Worker extends import_instrumentation.SdkObject {
   constructor(parent, url, targetId, session) {
     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);
-    this._targetId = targetId;
-    this._session = session;
   }
   static {
     this.Events = {
@@ -690,9 +686,15 @@ class Worker extends import_instrumentation.SdkObject {
   }
   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");
@@ -822,17 +824,17 @@ class FrameThrottler {
     }
   }
 }
-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 }));
       if (snapshotOrRetry === true)
         return continuePolling;
       return snapshotOrRetry;
@@ -842,33 +844,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)

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());

package/lib/server/recorder/recorderApp.js

@@ -96,7 +96,7 @@ class RecorderApp {
         });
         delete inspectedContext[recorderAppSymbol];
       });
-      await this._page.mainFrame().goto(progress, process.env.PW_HMR ? "http://localhost:44225" : "https://playwright/index.html");
+      await this._page.mainFrame().goto(progress, "https://playwright/index.html");
     });
     const url = this._recorder.url();
     if (url)

package/lib/server/recorder.js

@@ -112,8 +112,9 @@ class Recorder extends import_events.default {
     }
     return recorderPromise;
   }
-  static existingForContext(context) {
-    return context[recorderSymbol];
+  static async existingForContext(context) {
+    const recorderPromise = context[recorderSymbol];
+    return await recorderPromise;
   }
   static async _create(context, params = {}) {
     const recorder = new Recorder(context, params);