brave-real-playwright-core 1.55.1 → 1.56.1-patch.1

package/lib/server/dispatchers/pageDispatcher.js

@@ -103,6 +103,19 @@ class PageDispatcher extends import_dispatcher.Dispatcher {
   page() {
     return this._page;
   }
+  serializeConsoleMessage(message) {
+    return {
+      type: message.type(),
+      text: message.text(),
+      args: message.args().map((a) => {
+        const elementHandle = a.asElement();
+        if (elementHandle)
+          return import_elementHandlerDispatcher.ElementHandleDispatcher.from(import_frameDispatcher.FrameDispatcher.from(this.parentScope(), elementHandle._frame), elementHandle);
+        return import_jsHandleDispatcher.JSHandleDispatcher.fromJSHandle(this, a);
+      }),
+      location: message.location()
+    };
+  }
   async exposeBinding(params, progress) {
     const binding = await this._page.exposeBinding(progress, params.name, !!params.needsHandle, (source, ...args) => {
       if (this._disposed)
@@ -222,6 +235,13 @@ class PageDispatcher extends import_dispatcher.Dispatcher {
   async keyboardPress(params, progress) {
     await this._page.keyboard.press(progress, params.key, params);
   }
+  async consoleMessages(params, progress) {
+    this._subscriptions.add("console");
+    return { messages: this._page.consoleMessages().map((message) => this.serializeConsoleMessage(message)) };
+  }
+  async pageErrors(params, progress) {
+    return { errors: this._page.pageErrors().map((error) => (0, import_errors.serializeError)(error)) };
+  }
   async mouseMove(params, progress) {
     progress.metadata.point = { x: params.x, y: params.y };
     await this._page.mouse.move(progress, params.x, params.y, params);
@@ -258,6 +278,10 @@ class PageDispatcher extends import_dispatcher.Dispatcher {
     const buffer = await progress.race(this._page.pdf(params));
     return { pdf: buffer };
   }
+  async requests(params, progress) {
+    this._subscriptions.add("request");
+    return { requests: this._page.networkRequests().map((request) => import_networkDispatchers.RequestDispatcher.from(this.parentScope(), request)) };
+  }
   async snapshotForAI(params, progress) {
     return { snapshot: await this._page.snapshotForAI(progress) };
   }

package/lib/server/dom.js

@@ -84,6 +84,7 @@ class FrameExecutionContext extends js.ExecutionContext {
         testIdAttributeName: selectorsRegistry.testIdAttributeName(),
         stableRafCount: this.frame._page.delegate.rafCountForStablePosition(),
         browserName: this.frame._page.browserContext._browser.options.name,
+        isUtilityWorld: this.world === "utility",
         customEngines
       };
       const source = `
@@ -635,17 +636,21 @@ class ElementHandle extends js.JSHandle {
       const result2 = await progress.race(this.evaluateInUtility(([injected, node]) => injected.elementState(node, "checked"), {}));
       if (result2 === "error:notconnected" || result2.received === "error:notconnected")
         throwElementIsNotAttached();
-      return result2.matches;
+      return { matches: result2.matches, isRadio: result2.isRadio };
     };
     await this._markAsTargetElement(progress);
-    if (await isChecked() === state)
+    const checkedState = await isChecked();
+    if (checkedState.matches === state)
       return "done";
+    if (!state && checkedState.isRadio)
+      throw new NonRecoverableDOMError("Cannot uncheck radio button. Radio buttons can only be unchecked by selecting another radio button in the same group.");
     const result = await this._click(progress, { ...options, waitAfter: "disabled" });
     if (result !== "done")
       return result;
     if (options.trial)
       return "done";
-    if (await isChecked() !== state)
+    const finalState = await isChecked();
+    if (finalState.matches !== state)
       throw new NonRecoverableDOMError("Clicking the checkbox did not change its state");
     return "done";
   }

package/lib/server/firefox/ffPage.js

@@ -44,7 +44,6 @@ var import_ffInput = require("./ffInput");
 var import_ffNetworkManager = require("./ffNetworkManager");
 var import_debugLogger = require("../utils/debugLogger");
 var import_stackTrace = require("../../utils/isomorphic/stackTrace");
-var import_browserContext = require("../browserContext");
 var import_errors = require("../errors");
 const UTILITY_WORLD_NAME = "__playwright_utility_world__";
 class FFPage {
@@ -195,7 +194,7 @@ class FFPage {
     const error = new Error(message);
     error.stack = params.message + "\n" + params.stack.split("\n").filter(Boolean).map((a) => a.replace(/([^@]*)@(.*)/, "    at $1 ($2)")).join("\n");
     error.name = name;
-    this._page.emitOnContextOnceInitialized(import_browserContext.BrowserContext.Events.PageError, error, this._page);
+    this._page.addPageError(error);
   }
   _onConsole(payload) {
     const { type, args, executionContextId, location } = payload;

package/lib/server/firefox/firefox.js

@@ -67,7 +67,7 @@ Workaround: Set the HOME=/root environment variable${process.env.GITHUB_ACTION ?
     const message = { method: "Browser.close", params: {}, id: import_ffConnection.kBrowserCloseMessageId };
     transport.send(message);
   }
-  defaultArgs(options, isPersistent, userDataDir) {
+  async defaultArgs(options, isPersistent, userDataDir) {
     const { args = [], headless } = options;
     const userDataDirArg = args.find((arg) => arg.startsWith("-profile") || arg.startsWith("--profile"));
     if (userDataDirArg)

package/lib/server/frames.js

@@ -231,6 +231,7 @@ class FrameManager {
       });
       return;
     }
+    this._page.addNetworkRequest(request);
     this._page.emitOnContext(import_browserContext.BrowserContext.Events.Request, request);
     if (route)
       new network.Route(request, route).handle([...this._page.requestInterceptors, ...this._page.browserContext.requestInterceptors]);
@@ -1180,11 +1181,15 @@ class Frame extends import_instrumentation.SdkObject {
       fixupMetadataError(result);
       return result;
     } catch (e) {
-      if (js.isJavaScriptErrorInEvaluate(e) || (0, import_selectorParser.isInvalidSelectorError)(e))
-        throw e;
       const result = { matches: options.isNot, log: (0, import_callLog.compressCallLog)(progress.metadata.log) };
-      if (lastIntermediateResult.isSet)
+      if ((0, import_selectorParser.isInvalidSelectorError)(e)) {
+        result.errorMessage = "Error: " + e.message;
+      } else if (js.isJavaScriptErrorInEvaluate(e)) {
+        result.errorMessage = e.message;
+      } else if (lastIntermediateResult.isSet) {
         result.received = lastIntermediateResult.received;
+        result.errorMessage = lastIntermediateResult.errorMessage;
+      }
       if (e instanceof import_errors.TimeoutError)
         result.timedOut = true;
       fixupMetadataError(result);
@@ -1215,7 +1220,10 @@ class Frame extends import_instrumentation.SdkObject {
     if (log)
       progress.log(log);
     if (matches === options.isNot) {
-      lastIntermediateResult.received = missingReceived ? "<element(s) not found>" : received;
+      if (missingReceived)
+        lastIntermediateResult.errorMessage = "Error: element(s) not found";
+      else
+        lastIntermediateResult.received = received;
       lastIntermediateResult.isSet = true;
       if (!missingReceived && !Array.isArray(received))
         progress.log(`  unexpected value "${renderUnexpectedValue(options.expression, received)}"`);

package/lib/server/har/harTracer.js

@@ -165,7 +165,7 @@ class HarTracer {
   _onAPIRequest(event) {
     if (!this._shouldIncludeEntryWithUrl(event.url.toString()))
       return;
-    const harEntry = createHarEntry(event.method, event.url, void 0, this._options);
+    const harEntry = createHarEntry(void 0, event.method, event.url, void 0, this._options);
     harEntry._apiRequest = true;
     if (!this._options.omitCookies)
       harEntry.request.cookies = event.cookies;
@@ -227,9 +227,7 @@ class HarTracer {
     if (!url)
       return;
     const pageEntry = this._createPageEntryIfNeeded(page);
-    const harEntry = createHarEntry(request.method(), url, request.frame()?.guid, this._options);
-    if (pageEntry)
-      harEntry.pageref = pageEntry.id;
+    const harEntry = createHarEntry(pageEntry?.id, request.method(), url, request.frame()?.guid, this._options);
     this._recordRequestHeadersAndCookies(harEntry, request.headers());
     harEntry.request.postData = this._postDataForRequest(request, this._options.content);
     if (!this._options.omitSizes)
@@ -522,10 +520,9 @@ class HarTracer {
     return result;
   }
 }
-function createHarEntry(method, url, frameref, options) {
+function createHarEntry(pageRef, method, url, frameref, options) {
   const harEntry = {
-    _frameref: options.includeTraceInfo ? frameref : void 0,
-    _monotonicTime: options.includeTraceInfo ? (0, import_utils.monotonicTime)() : void 0,
+    pageref: pageRef,
     startedDateTime: (/* @__PURE__ */ new Date()).toISOString(),
     time: -1,
     request: {
@@ -558,7 +555,9 @@ function createHarEntry(method, url, frameref, options) {
       send: -1,
       wait: -1,
       receive: -1
-    }
+    },
+    _frameref: options.includeTraceInfo ? frameref : void 0,
+    _monotonicTime: options.includeTraceInfo ? (0, import_utils.monotonicTime)() : void 0
   };
   return harEntry;
 }

package/lib/server/network.js

@@ -121,6 +121,11 @@ class Request extends import_instrumentation.SdkObject {
     this._updateHeadersMap();
     this._isFavicon = url.endsWith("/favicon.ico") || !!redirectedFrom?._isFavicon;
   }
+  static {
+    this.Events = {
+      Response: "response"
+    };
+  }
   _setFailureText(failureText) {
     this._failureText = failureText;
     this._waitForResponsePromise.resolve(null);
@@ -172,6 +177,7 @@ class Request extends import_instrumentation.SdkObject {
   _setResponse(response) {
     this._response = response;
     this._waitForResponsePromise.resolve(response);
+    this.emit(Request.Events.Response, response);
   }
   _finalRequest() {
     return this._redirectedTo ? this._redirectedTo._finalRequest() : this;
@@ -264,6 +270,8 @@ class Route extends import_instrumentation.SdkObject {
         body = "";
         isBase64 = false;
       }
+    } else if (!overrides.status || overrides.status < 200 || overrides.status >= 400) {
+      this._request._responseBodyOverride = { body, isBase64 };
     }
     const headers = [...overrides.headers || []];
     this._maybeAddCorsHeaders(headers);
@@ -416,6 +424,10 @@ class Response extends import_instrumentation.SdkObject {
       this._contentPromise = this._finishedPromise.then(async () => {
         if (this._status >= 300 && this._status <= 399)
           throw new Error("Response body is unavailable for redirect responses");
+        if (this._request._responseBodyOverride) {
+          const { body, isBase64 } = this._request._responseBodyOverride;
+          return Buffer.from(body, isBase64 ? "base64" : "utf-8");
+        }
         return this._getResponseBodyCallback();
       });
     }

package/lib/server/page.js

@@ -60,7 +60,8 @@ class Page extends import_instrumentation.SdkObject {
     this._closedState = "open";
     this._closedPromise = new import_manualPromise.ManualPromise();
     this._initializedPromise = new import_manualPromise.ManualPromise();
-    this._eventsToEmitAfterInitialized = [];
+    this._consoleMessages = [];
+    this._pageErrors = [];
     this._crashed = false;
     this.openScope = new import_utils.LongStandingScope();
     this._emulatedMedia = {};
@@ -73,6 +74,7 @@ class Page extends import_instrumentation.SdkObject {
     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);
@@ -108,25 +110,26 @@ class Page extends import_instrumentation.SdkObject {
       Worker: "worker"
     };
   }
-  async reportAsNew(opener, error = void 0, contextEvent = import_browserContext.BrowserContext.Events.Page) {
+  async reportAsNew(opener, error) {
     if (opener) {
       const openerPageOrError = await opener.waitForInitializedOrError();
       if (openerPageOrError instanceof Page && !openerPageOrError.isClosed())
         this._opener = openerPageOrError;
     }
-    this._markInitialized(error, contextEvent);
+    this._markInitialized(error);
   }
-  _markInitialized(error = void 0, contextEvent = import_browserContext.BrowserContext.Events.Page) {
+  _markInitialized(error = void 0) {
     if (error) {
       if (this.browserContext.isClosingOrClosed())
         return;
       this.frameManager.createDummyMainFrameIfNeeded();
     }
     this._initialized = error || this;
-    this.emitOnContext(contextEvent, this);
-    for (const { event, args } of this._eventsToEmitAfterInitialized)
-      this.browserContext.emit(event, ...args);
-    this._eventsToEmitAfterInitialized = [];
+    this.emitOnContext(import_browserContext.BrowserContext.Events.Page, this);
+    for (const pageError of this._pageErrors)
+      this.emitOnContext(import_browserContext.BrowserContext.Events.PageError, pageError, this);
+    for (const message of this._consoleMessages)
+      this.emitOnContext(import_browserContext.BrowserContext.Events.Console, message);
     if (this.isClosed())
       this.emit(Page.Events.Close);
     else
@@ -144,14 +147,6 @@ class Page extends import_instrumentation.SdkObject {
       return;
     this.browserContext.emit(event, ...args);
   }
-  emitOnContextOnceInitialized(event, ...args) {
-    if (this.isStorageStatePage)
-      return;
-    if (this._initialized)
-      this.browserContext.emit(event, ...args);
-    else
-      this._eventsToEmitAfterInitialized.push({ event, args });
-  }
   async resetForReuse(progress) {
     await this.mainFrame().gotoImpl(progress, "about:blank", {});
     this._emulatedSize = void 0;
@@ -246,6 +241,13 @@ class Page extends import_instrumentation.SdkObject {
   extraHTTPHeaders() {
     return this._extraHTTPHeaders;
   }
+  addNetworkRequest(request) {
+    this._networkRequests.push(request);
+    ensureArrayLimit(this._networkRequests, 100);
+  }
+  networkRequests() {
+    return this._networkRequests;
+  }
   async onBindingCalled(payload, context) {
     if (this._closedState === "closed")
       return;
@@ -258,7 +260,22 @@ class Page extends import_instrumentation.SdkObject {
       args.forEach((arg) => arg.dispose());
       return;
     }
-    this.emitOnContextOnceInitialized(import_browserContext.BrowserContext.Events.Console, message);
+    this._consoleMessages.push(message);
+    ensureArrayLimit(this._consoleMessages, 200);
+    if (this._initialized)
+      this.emitOnContext(import_browserContext.BrowserContext.Events.Console, message);
+  }
+  consoleMessages() {
+    return this._consoleMessages;
+  }
+  addPageError(pageError) {
+    this._pageErrors.push(pageError);
+    ensureArrayLimit(this._pageErrors, 200);
+    if (this._initialized)
+      this.emitOnContext(import_browserContext.BrowserContext.Events.PageError, pageError, this);
+  }
+  pageErrors() {
+    return this._pageErrors;
   }
   async reload(progress, options) {
     return this.mainFrame().raceNavigationAction(progress, async () => {
@@ -853,6 +870,11 @@ async function snapshotFrameForAI(progress, frame, frameOrdinal, frameIds) {
   }
   return result;
 }
+function ensureArrayLimit(array, limit) {
+  if (array.length > limit)
+    return array.splice(0, limit / 10);
+  return [];
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   InitScript,

package/lib/server/recorder/chat.js

@@ -85,7 +85,7 @@ async function asString(stream) {
 function iterablePump() {
   let controller;
   const stream = new ReadableStream({ start: (c) => controller = c });
-  const iterable = async function* () {
+  const iterable = (async function* () {
     const reader = stream.getReader();
     while (true) {
       const { done, value } = await reader.read();
@@ -93,7 +93,7 @@ function iterablePump() {
         break;
       yield value;
     }
-  }();
+  })();
   return {
     iterable,
     addChunk: (chunk) => {

package/lib/server/recorder/recorderRunner.js

@@ -50,6 +50,10 @@ async function performActionImpl(progress, mainFrame, actionInContext) {
     await mainFrame.click(progress, selector, { ...options, strict: true });
     return;
   }
+  if (action.name === "hover") {
+    await mainFrame.hover(progress, selector, { position: action.position, strict: true });
+    return;
+  }
   if (action.name === "press") {
     const modifiers = (0, import_language.toKeyboardModifiers)(action.modifiers);
     const shortcut = [...modifiers, action.key].join("+");

package/lib/server/registry/browserFetcher.js

@@ -47,7 +47,8 @@ async function downloadBrowserWithProgressBar(title, browserDirectory, executabl
     import_debugLogger.debugLogger.log("install", `${title} is already downloaded.`);
     return false;
   }
-  const zipPath = import_path.default.join(import_os.default.tmpdir(), downloadFileName);
+  const uniqueTempDir = await import_fs.default.promises.mkdtemp(import_path.default.join(import_os.default.tmpdir(), "playwright-download-"));
+  const zipPath = import_path.default.join(uniqueTempDir, downloadFileName);
   try {
     const retryCount = 5;
     for (let attempt = 1; attempt <= retryCount; ++attempt) {
@@ -73,8 +74,7 @@ async function downloadBrowserWithProgressBar(title, browserDirectory, executabl
     process.exitCode = 1;
     throw e;
   } finally {
-    if (await (0, import_fileUtils.existsAsync)(zipPath))
-      await import_fs.default.promises.unlink(zipPath);
+    await (0, import_fileUtils.removeFolders)([uniqueTempDir]);
   }
   logPolitely(`${title} downloaded to ${browserDirectory}`);
   return true;

package/lib/server/registry/index.js

@@ -749,6 +749,33 @@ ${(0, import_ascii.wrapInASCIIBox)(prettyMessage, 1)}`);
       _dependencyGroup: "webkit",
       _isHermeticInstallation: true
     });
+    this._executables.push({
+      type: "channel",
+      name: "webkit-wsl",
+      browserName: "webkit",
+      directory: webkit.dir,
+      executablePath: () => process.execPath,
+      executablePathOrDie: () => process.execPath,
+      wslExecutablePath: `/home/pwuser/.cache/ms-playwright/webkit-${webkit.revision}/pw_run.sh`,
+      installType: "download-on-demand",
+      _validateHostRequirements: (sdkLanguage) => Promise.resolve(),
+      _isHermeticInstallation: true,
+      _install: async () => {
+        if (process.platform !== "win32")
+          throw new Error(`WebKit via WSL is only supported on Windows`);
+        const script = import_path.default.join(BIN_PATH, "install_webkit_wsl.ps1");
+        const { code } = await (0, import_spawnAsync.spawnAsync)("powershell.exe", [
+          "-ExecutionPolicy",
+          "Bypass",
+          "-File",
+          script
+        ], {
+          stdio: "inherit"
+        });
+        if (code !== 0)
+          throw new Error(`Failed to install WebKit via WSL`);
+      }
+    });
     const ffmpeg = descriptors.find((d) => d.name === "ffmpeg");
     const ffmpegExecutable = findExecutablePath(ffmpeg.dir, "ffmpeg");
     this._executables.push({

package/lib/server/trace/recorder/snapshotter.js

@@ -75,10 +75,20 @@ class Snapshotter {
   dispose() {
     import_eventsHelper.eventsHelper.removeEventListeners(this._eventListeners);
   }
+  async _captureFrameSnapshot(frame) {
+    const needsReset = !!frame[kNeedsResetSymbol];
+    frame[kNeedsResetSymbol] = false;
+    const expression = `window["${this._snapshotStreamer}"].captureSnapshot(${needsReset ? "true" : "false"})`;
+    try {
+      return await frame.nonStallingRawEvaluateInExistingMainContext(expression);
+    } catch (e) {
+      frame[kNeedsResetSymbol] = true;
+      import_debugLogger.debugLogger.log("error", e);
+    }
+  }
   async captureSnapshot(page, callId, snapshotName) {
-    const expression = `window["${this._snapshotStreamer}"].captureSnapshot(${JSON.stringify(snapshotName)})`;
     const snapshots = page.frames().map(async (frame) => {
-      const data = await frame.nonStallingRawEvaluateInExistingMainContext(expression).catch((e) => import_debugLogger.debugLogger.log("error", e));
+      const data = await this._captureFrameSnapshot(frame);
       if (!data || !this._started)
         return;
       const snapshot = {
@@ -130,6 +140,7 @@ class Snapshotter {
     }
   }
 }
+const kNeedsResetSymbol = Symbol("kNeedsReset");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Snapshotter

package/lib/server/trace/recorder/snapshotterInjected.js

@@ -256,9 +256,11 @@ function frameSnapshotStreamer(snapshotStreamer, removeNoScript) {
         this._readingStyleSheet = false;
       }
     }
-    captureSnapshot() {
+    captureSnapshot(needsReset) {
       const timestamp = performance.now();
       const snapshotNumber = ++this._lastSnapshotNumber;
+      if (needsReset)
+        this.reset();
       let nodeCounter = 0;
       let shadowDomNesting = 0;
       let headNesting = 0;

package/lib/server/utils/comparators.js

@@ -101,11 +101,11 @@ function validateBuffer(buffer, mimeType) {
   if (mimeType === "image/png") {
     const pngMagicNumber = [137, 80, 78, 71, 13, 10, 26, 10];
     if (buffer.length < pngMagicNumber.length || !pngMagicNumber.every((byte, index) => buffer[index] === byte))
-      throw new Error("could not decode image as PNG.");
+      throw new Error("Could not decode expected image as PNG.");
   } else if (mimeType === "image/jpeg") {
     const jpegMagicNumber = [255, 216];
     if (buffer.length < jpegMagicNumber.length || !jpegMagicNumber.every((byte, index) => buffer[index] === byte))
-      throw new Error("could not decode image as JPEG.");
+      throw new Error("Could not decode expected image as JPEG.");
   }
 }
 function compareText(actual, expectedBuffer) {

package/lib/server/utils/env.js

@@ -22,7 +22,8 @@ __export(env_exports, {
   getFromENV: () => getFromENV,
   getPackageManager: () => getPackageManager,
   getPackageManagerExecCommand: () => getPackageManagerExecCommand,
-  isLikelyNpxGlobal: () => isLikelyNpxGlobal
+  isLikelyNpxGlobal: () => isLikelyNpxGlobal,
+  setPlaywrightTestProcessEnv: () => setPlaywrightTestProcessEnv
 });
 module.exports = __toCommonJS(env_exports);
 function getFromENV(name) {
@@ -58,11 +59,15 @@ function getPackageManagerExecCommand() {
 function isLikelyNpxGlobal() {
   return process.argv.length >= 2 && process.argv[1].includes("_npx");
 }
+function setPlaywrightTestProcessEnv() {
+  return process.env["PLAYWRIGHT_TEST"] = "1";
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   getAsBooleanFromENV,
   getFromENV,
   getPackageManager,
   getPackageManagerExecCommand,
-  isLikelyNpxGlobal
+  isLikelyNpxGlobal,
+  setPlaywrightTestProcessEnv
 });

package/lib/server/utils/wsServer.js

@@ -85,13 +85,8 @@ class WSServer {
       const url = new URL("http://localhost" + (request.url || ""));
       const id = String(++lastConnectionId);
       import_debugLogger.debugLogger.log("server", `[${id}] serving connection: ${request.url}`);
-      try {
-        const connection = this._delegate.onConnection(request, url, ws, id);
-        ws[kConnectionSymbol] = connection;
-      } catch (error) {
-        import_debugLogger.debugLogger.log("server", `[${id}] connection error: ${error}`);
-        ws.close(1011, String(error));
-      }
+      const connection = this._delegate.onConnection(request, url, ws, id);
+      ws[kConnectionSymbol] = connection;
     });
     return wsEndpoint;
   }

package/lib/server/webkit/webkit.js

@@ -28,7 +28,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var webkit_exports = {};
 __export(webkit_exports, {
-  WebKit: () => WebKit
+  WebKit: () => WebKit,
+  translatePathToWSL: () => translatePathToWSL
 });
 module.exports = __toCommonJS(webkit_exports);
 var import_path = __toESM(require("path"));
@@ -36,6 +37,8 @@ var import_wkConnection = require("./wkConnection");
 var import_ascii = require("../utils/ascii");
 var import_browserType = require("../browserType");
 var import_wkBrowser = require("../webkit/wkBrowser");
+var import_spawnAsync = require("../utils/spawnAsync");
+var import_registry = require("../registry");
 class WebKit extends import_browserType.BrowserType {
   constructor(parent) {
     super(parent, "webkit");
@@ -43,10 +46,11 @@ class WebKit extends import_browserType.BrowserType {
   connectToTransport(transport, options) {
     return import_wkBrowser.WKBrowser.connect(this.attribution.playwright, transport, options);
   }
-  amendEnvironment(env, userDataDir, isPersistent) {
+  amendEnvironment(env, userDataDir, isPersistent, options) {
     return {
       ...env,
-      CURL_COOKIE_JAR_PATH: process.platform === "win32" && isPersistent ? import_path.default.join(userDataDir, "cookiejar.db") : void 0
+      CURL_COOKIE_JAR_PATH: process.platform === "win32" && isPersistent ? import_path.default.join(userDataDir, "cookiejar.db") : void 0,
+      WEBKIT_EXECUTABLE: options.channel === "webkit-wsl" ? import_registry.registry.findExecutable("webkit-wsl").wslExecutablePath : void 0
     };
   }
   doRewriteStartupLog(error) {
@@ -59,7 +63,7 @@ class WebKit extends import_browserType.BrowserType {
   attemptToGracefullyCloseBrowser(transport) {
     transport.send({ method: "Playwright.close", params: {}, id: import_wkConnection.kBrowserCloseMessageId });
   }
-  defaultArgs(options, isPersistent, userDataDir) {
+  async defaultArgs(options, isPersistent, userDataDir) {
     const { args = [], headless } = options;
     const userDataDirArg = args.find((arg) => arg.startsWith("--user-data-dir"));
     if (userDataDirArg)
@@ -67,12 +71,19 @@ class WebKit extends import_browserType.BrowserType {
     if (args.find((arg) => !arg.startsWith("-")))
       throw new Error("Arguments can not specify page to be opened");
     const webkitArguments = ["--inspector-pipe"];
-    if (process.platform === "win32")
+    if (options.channel === "webkit-wsl") {
+      if (options.executablePath)
+        throw new Error('Cannot specify executablePath when using the "webkit-wsl" channel.');
+      webkitArguments.unshift(
+        import_path.default.join(__dirname, "wsl/webkit-wsl-transport-server.js")
+      );
+    }
+    if (process.platform === "win32" && options.channel !== "webkit-wsl")
       webkitArguments.push("--disable-accelerated-compositing");
     if (headless)
       webkitArguments.push("--headless");
     if (isPersistent)
-      webkitArguments.push(`--user-data-dir=${userDataDir}`);
+      webkitArguments.push(`--user-data-dir=${options.channel === "webkit-wsl" ? await translatePathToWSL(userDataDir) : userDataDir}`);
     else
       webkitArguments.push(`--no-startup-window`);
     const proxy = options.proxyOverride || options.proxy;
@@ -81,7 +92,7 @@ class WebKit extends import_browserType.BrowserType {
         webkitArguments.push(`--proxy=${proxy.server}`);
         if (proxy.bypass)
           webkitArguments.push(`--proxy-bypass-list=${proxy.bypass}`);
-      } else if (process.platform === "linux") {
+      } else if (process.platform === "linux" || process.platform === "win32" && options.channel === "webkit-wsl") {
         webkitArguments.push(`--proxy=${proxy.server}`);
         if (proxy.bypass)
           webkitArguments.push(...proxy.bypass.split(",").map((t) => `--ignore-host=${t}`));
@@ -97,7 +108,12 @@ class WebKit extends import_browserType.BrowserType {
     return webkitArguments;
   }
 }
+async function translatePathToWSL(path2) {
+  const { stdout } = await (0, import_spawnAsync.spawnAsync)("wsl.exe", ["-d", "playwright", "--cd", "/home/pwuser", "wslpath", path2.replace(/\\/g, "\\\\")]);
+  return stdout.toString().trim();
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  WebKit
+  WebKit,
+  translatePathToWSL
 });

package/lib/server/webkit/wkBrowser.js

@@ -39,6 +39,7 @@ var network = __toESM(require("../network"));
 var import_wkConnection = require("./wkConnection");
 var import_wkPage = require("./wkPage");
 var import_errors = require("../errors");
+var import_webkit = require("./webkit");
 const BROWSER_VERSION = "26.0";
 const DEFAULT_USER_AGENT = `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/${BROWSER_VERSION} Safari/605.1.15`;
 class WKBrowser extends import_browser.Browser {
@@ -87,7 +88,7 @@ class WKBrowser extends import_browser.Browser {
     const createOptions = proxy ? {
       // Enable socks5 hostname resolution on Windows.
       // See https://github.com/microsoft/playwright/issues/20451
-      proxyServer: process.platform === "win32" ? proxy.server.replace(/^socks5:\/\//, "socks5h://") : proxy.server,
+      proxyServer: process.platform === "win32" && this.attribution.browser?.options.channel !== "webkit-wsl" ? proxy.server.replace(/^socks5:\/\//, "socks5h://") : proxy.server,
       proxyBypassList: proxy.bypass
     } : void 0;
     const { browserContextId } = await this._browserSession.send("Playwright.createContext", createOptions);
@@ -110,7 +111,10 @@ class WKBrowser extends import_browser.Browser {
     const page = this._wkPages.get(payload.pageProxyId);
     if (!page)
       return;
-    page._page.frameManager.frameAbortedNavigation(payload.frameId, "Download is starting");
+    let frameId = payload.frameId;
+    if (!page._page.frameManager.frame(frameId))
+      frameId = page._page.mainFrame()._id;
+    page._page.frameManager.frameAbortedNavigation(frameId, "Download is starting");
     let originPage = page._page.initializedOrUndefined();
     if (!originPage) {
       page._firstNonInitialNavigationCommittedReject(new Error("Starting new page download"));
@@ -189,7 +193,7 @@ class WKBrowserContext extends import_browserContext.BrowserContext {
     const promises = [super._initialize()];
     promises.push(this._browser._browserSession.send("Playwright.setDownloadBehavior", {
       behavior: this._options.acceptDownloads === "accept" ? "allow" : "deny",
-      downloadPath: this._browser.options.downloadsPath,
+      downloadPath: this._browser.options.channel === "webkit-wsl" ? await (0, import_webkit.translatePathToWSL)(this._browser.options.downloadsPath) : this._browser.options.downloadsPath,
       browserContextId
     }));
     if (this._options.ignoreHTTPSErrors || this._options.internalIgnoreHTTPSErrors)