patchright-bun-core 1.58.2 → 1.59.0

package/lib/server/utils/happyEyeballs.js

@@ -166,20 +166,23 @@ async function createConnectionAsync(options, oncreate, useTLS) {
   }
 }
 async function lookupAddresses(hostname) {
-  const addresses = await import_dns.default.promises.lookup(hostname, { all: true, family: 0, verbatim: true });
-  let firstFamily = addresses.filter(({ family }) => family === 6);
-  let secondFamily = addresses.filter(({ family }) => family === 4);
-  if (firstFamily.length && firstFamily[0] !== addresses[0]) {
-    const tmp = firstFamily;
-    firstFamily = secondFamily;
-    secondFamily = tmp;
+  const [v4Result, v6Result] = await Promise.allSettled([
+    import_dns.default.promises.lookup(hostname, { all: true, family: 4 }),
+    import_dns.default.promises.lookup(hostname, { all: true, family: 6 })
+  ]);
+  const v4Addresses = v4Result.status === "fulfilled" ? v4Result.value : [];
+  const v6Addresses = v6Result.status === "fulfilled" ? v6Result.value : [];
+  if (!v4Addresses.length && !v6Addresses.length) {
+    if (v4Result.status === "rejected")
+      throw v4Result.reason;
+    throw v6Result.reason;
   }
   const result = [];
-  for (let i = 0; i < Math.max(firstFamily.length, secondFamily.length); i++) {
-    if (firstFamily[i])
-      result.push(firstFamily[i]);
-    if (secondFamily[i])
-      result.push(secondFamily[i]);
+  for (let i = 0; i < Math.max(v4Addresses.length, v6Addresses.length); i++) {
+    if (v6Addresses[i])
+      result.push(v6Addresses[i]);
+    if (v4Addresses[i])
+      result.push(v4Addresses[i]);
   }
   return result;
 }

package/lib/server/utils/hostPlatform.js

@@ -28,13 +28,11 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var hostPlatform_exports = {};
 __export(hostPlatform_exports, {
-  hasGpuMac: () => hasGpuMac,
   hostPlatform: () => hostPlatform,
   isOfficiallySupportedPlatform: () => isOfficiallySupportedPlatform,
   shortPlatform: () => shortPlatform
 });
 module.exports = __toCommonJS(hostPlatform_exports);
-var import_child_process = require("child_process");
 var import_os = __toESM(require("os"));
 var import_linuxUtils = require("./linuxUtils");
 function calculatePlatform() {
@@ -117,21 +115,8 @@ function toShortPlatform(hostPlatform2) {
   return hostPlatform2.endsWith("arm64") ? "linux-arm64" : "linux-x64";
 }
 const shortPlatform = toShortPlatform(hostPlatform);
-let hasGpuMacValue;
-function hasGpuMac() {
-  try {
-    if (hasGpuMacValue === void 0) {
-      const output = (0, import_child_process.execSync)("system_profiler SPDisplaysDataType", { stdio: ["ignore", "pipe", "ignore"] }).toString();
-      hasGpuMacValue = output.includes("Metal: Supported") || output.includes("Metal Support: Metal");
-    }
-    return hasGpuMacValue;
-  } catch (e) {
-    return false;
-  }
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  hasGpuMac,
   hostPlatform,
   isOfficiallySupportedPlatform,
   shortPlatform

package/lib/server/utils/httpServer.js

@@ -58,14 +58,16 @@ class HttpServer {
   port() {
     return this._port;
   }
-  createWebSocket(transport, guid) {
+  createWebSocket(transportFactory, guid) {
     (0, import_assert.assert)(!this._wsGuid, "can only create one main websocket transport per server");
     this._wsGuid = guid || (0, import_crypto.createGuid)();
     const wss = new import_utilsBundle.wsServer({ server: this._server, path: "/" + this._wsGuid });
-    wss.on("connection", (ws) => {
-      transport.onconnect();
+    wss.on("connection", (ws, request) => {
+      const url = new URL(request.url ?? "/", "http://localhost");
+      const transport = transportFactory(url);
       transport.sendEvent = (method, params) => ws.send(JSON.stringify({ method, params }));
       transport.close = () => ws.close();
+      transport.onconnect();
       ws.on("message", async (message) => {
         const { id, method, params } = JSON.parse(String(message));
         try {

package/lib/server/utils/network.js

@@ -33,6 +33,7 @@ __export(network_exports, {
   createHttpServer: () => createHttpServer,
   createHttpsServer: () => createHttpsServer,
   createProxyAgent: () => createProxyAgent,
+  decorateServer: () => decorateServer,
   fetchData: () => fetchData,
   httpRequest: () => httpRequest,
   isURLAvailable: () => isURLAvailable,
@@ -62,7 +63,6 @@ function httpRequest(params, onResponse, onError) {
       url = parsedProxyURL;
     } else {
       options.agent = new import_utilsBundle.HttpsProxyAgent(parsedProxyURL);
-      options.rejectUnauthorized = false;
     }
   }
   options.agent ??= url.protocol === "https:" ? import_happyEyeballs.httpsHappyEyeballsAgent : import_happyEyeballs.httpHappyEyeballsAgent;
@@ -235,6 +235,7 @@ function decorateServer(server) {
   createHttpServer,
   createHttpsServer,
   createProxyAgent,
+  decorateServer,
   fetchData,
   httpRequest,
   isURLAvailable,

package/lib/server/utils/nodePlatform.js

@@ -42,7 +42,6 @@ var import_utilsBundle = require("../../utilsBundle");
 var import_debugLogger = require("./debugLogger");
 var import_zones = require("./zones");
 var import_debug = require("./debug");
-var import_mcpBundle = require("../../mcpBundle");
 const pipelineAsync = util.promisify(import_stream.pipeline);
 class NodeZone {
   constructor(zone) {
@@ -106,11 +105,6 @@ const nodePlatform = {
   streamWritable: (channel) => {
     return new WritableStreamImpl(channel);
   },
-  zodToJsonSchema: (schema) => {
-    if ("_zod" in schema)
-      return import_mcpBundle.z.toJSONSchema(schema);
-    return (0, import_mcpBundle.zodToJsonSchema)(schema);
-  },
   zones: {
     current: () => new NodeZone((0, import_zones.currentZone)()),
     empty: new NodeZone(import_zones.emptyZone)

package/lib/server/utils/processLauncher.js

@@ -46,11 +46,12 @@ async function gracefullyCloseAll() {
   await Promise.all(Array.from(gracefullyCloseSet).map((gracefullyClose) => gracefullyClose().catch((e) => {
   })));
 }
-function gracefullyProcessExitDoNotHang(code) {
-  setTimeout(() => process.exit(code), 3e4);
-  gracefullyCloseAll().then(() => {
-    process.exit(code);
-  });
+function gracefullyProcessExitDoNotHang(code, onExit) {
+  const beforeExit = onExit ? () => onExit().catch(() => {
+  }) : () => Promise.resolve();
+  const callback = () => beforeExit().then(() => process.exit(code));
+  setTimeout(callback, 3e4);
+  gracefullyCloseAll().then(callback);
 }
 function exitHandler() {
   for (const kill of killSet)
@@ -109,6 +110,7 @@ async function launchProcess(options) {
     // process group, making it possible to kill child process tree with `.kill(-pid)` command.
     // @see https://nodejs.org/api/child_process.html#child_process_options_detached
     detached: process.platform !== "win32",
+    windowsHide: true,
     env: options.env,
     cwd: options.cwd,
     shell: options.shell,
@@ -191,7 +193,7 @@ async function launchProcess(options) {
       options.log(`[pid=${spawnedProcess.pid}] <will force kill>`);
       try {
         if (process.platform === "win32") {
-          const taskkillProcess = childProcess.spawnSync(`taskkill /pid ${spawnedProcess.pid} /T /F`, { shell: true });
+          const taskkillProcess = childProcess.spawnSync(`taskkill /pid ${spawnedProcess.pid} /T /F`, { shell: true, windowsHide: true });
           const [stdout2, stderr2] = [taskkillProcess.stdout.toString(), taskkillProcess.stderr.toString()];
           if (stdout2)
             options.log(`[pid=${spawnedProcess.pid}] taskkill stdout: ${stdout2}`);

package/lib/server/utils/zipFile.js

@@ -21,7 +21,6 @@ __export(zipFile_exports, {
   ZipFile: () => ZipFile
 });
 module.exports = __toCommonJS(zipFile_exports);
-var import_zipBundle = require("../../zipBundle");
 class ZipFile {
   constructor(fileName) {
     this._entries = /* @__PURE__ */ new Map();
@@ -29,8 +28,9 @@ class ZipFile {
     this._openedPromise = this._open();
   }
   async _open() {
+    const { yauzl } = require("../../zipBundle");
     await new Promise((fulfill, reject) => {
-      import_zipBundle.yauzl.open(this._fileName, { autoClose: false }, (e, z) => {
+      yauzl.open(this._fileName, { autoClose: false }, (e, z) => {
         if (e) {
           reject(e);
           return;

package/lib/server/videoRecorder.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,17 +17,75 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var videoRecorder_exports = {};
 __export(videoRecorder_exports, {
-  VideoRecorder: () => VideoRecorder
+  VideoRecorder: () => VideoRecorder,
+  startAutomaticVideoRecording: () => startAutomaticVideoRecording
 });
 module.exports = __toCommonJS(videoRecorder_exports);
+var import_path = __toESM(require("path"));
 var import_utils = require("../utils");
 var import_processLauncher = require("./utils/processLauncher");
+var import_utilsBundle = require("../utilsBundle");
+var import_artifact = require("./artifact");
+var import__ = require(".");
 const fps = 25;
 class VideoRecorder {
-  constructor(ffmpegPath, options) {
+  constructor(screencast) {
+    this._screencast = screencast;
+  }
+  start(options) {
+    (0, import_utils.assert)(!this._artifact);
+    const ffmpegPath = import__.registry.findExecutable("ffmpeg").executablePathOrDie(this._screencast.page.browserContext._browser.sdkLanguage());
+    const outputFile = options.fileName ?? import_path.default.join(this._screencast.page.browserContext._browser.options.artifactsDir, (0, import_utils.createGuid)() + ".webm");
+    this._client = {
+      onFrame: (frame) => this._videoRecorder.writeFrame(frame.buffer, frame.frameSwapWallTime / 1e3),
+      gracefulClose: () => this.stop(),
+      dispose: () => this.stop().catch((e) => import_utils.debugLogger.log("error", `Failed to stop video recorder: ${String(e)}`)),
+      size: options.size
+    };
+    const { size } = this._screencast.addClient(this._client);
+    const videoSize = options.size ?? size;
+    this._videoRecorder = new FfmpegVideoRecorder(ffmpegPath, videoSize, outputFile);
+    this._artifact = new import_artifact.Artifact(this._screencast.page.browserContext, outputFile);
+    return this._artifact;
+  }
+  async stop() {
+    if (!this._artifact)
+      return;
+    const artifact = this._artifact;
+    this._artifact = void 0;
+    const client = this._client;
+    this._client = void 0;
+    const videoRecorder = this._videoRecorder;
+    this._videoRecorder = void 0;
+    this._screencast.removeClient(client);
+    await videoRecorder.stop();
+    await artifact.reportFinished();
+  }
+}
+function startAutomaticVideoRecording(page) {
+  const recordVideo = page.browserContext._options.recordVideo;
+  if (!recordVideo)
+    return;
+  const recorder = new VideoRecorder(page.screencast);
+  if (page.browserContext._options.recordVideo?.showActions)
+    page.screencast.showActions(page.browserContext._options.recordVideo?.showActions);
+  const dir = recordVideo.dir ?? page.browserContext._browser.options.artifactsDir;
+  const artifact = recorder.start({ size: recordVideo.size, fileName: import_path.default.join(dir, page.guid + ".webm") });
+  page.video = artifact;
+}
+class FfmpegVideoRecorder {
+  constructor(ffmpegPath, size, outputFile) {
     this._process = null;
     this._gracefullyClose = null;
     this._lastWritePromise = Promise.resolve();
@@ -34,17 +94,19 @@ class VideoRecorder {
     this._lastWriteNodeTime = 0;
     this._frameQueue = [];
     this._isStopped = false;
-    this._ffmpegPath = ffmpegPath;
-    if (!options.outputFile.endsWith(".webm"))
+    if (!outputFile.endsWith(".webm"))
       throw new Error("File must have .webm extension");
-    this._launchPromise = this._launch(options).catch((e) => e);
+    this._outputFile = outputFile;
+    this._ffmpegPath = ffmpegPath;
+    this._size = size;
+    this._launchPromise = this._launch().catch((e) => e);
   }
-  async _launch(options) {
-    await (0, import_utils.mkdirIfNeeded)(options.outputFile);
-    const w = options.width;
-    const h = options.height;
+  async _launch() {
+    await (0, import_utils.mkdirIfNeeded)(this._outputFile);
+    const w = this._size.width;
+    const h = this._size.height;
     const args = `-loglevel error -f image2pipe -avioflags direct -fpsprobesize 0 -probesize 32 -analyzeduration 0 -c:v mjpeg -i pipe:0 -y -an -r ${fps} -c:v vp8 -qmin 0 -qmax 50 -crf 8 -deadline realtime -speed 8 -b:v 1M -threads 1 -vf pad=${w}:${h}:0:0:gray,crop=${w}:${h}:0:0`.split(" ");
-    args.push(options.outputFile);
+    args.push(this._outputFile);
     const { launchedProcess, gracefullyClose } = await (0, import_processLauncher.launchProcess)({
       command: this._ffmpegPath,
       args,
@@ -105,8 +167,11 @@ class VideoRecorder {
     const error = await this._launchPromise;
     if (error)
       throw error;
-    if (this._isStopped || !this._lastFrame)
+    if (this._isStopped)
       return;
+    if (!this._lastFrame) {
+      this._writeFrame(createWhiteImage(this._size.width, this._size.height), (0, import_utils.monotonicTime)());
+    }
     const addTime = Math.max(((0, import_utils.monotonicTime)() - this._lastWriteNodeTime) / 1e3, 1);
     this._writeFrame(Buffer.from([]), this._lastFrame.timestamp + addTime);
     this._isStopped = true;
@@ -118,7 +183,12 @@ class VideoRecorder {
     }
   }
 }
+function createWhiteImage(width, height) {
+  const data = Buffer.alloc(width * height * 4, 255);
+  return import_utilsBundle.jpegjs.encode({ data, width, height }, 80).data;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  VideoRecorder
+  VideoRecorder,
+  startAutomaticVideoRecording
 });

package/lib/server/webkit/wkBrowser.js

@@ -38,9 +38,8 @@ var import_browserContext = require("../browserContext");
 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 BROWSER_VERSION = "26.4";
 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 {
   constructor(parent, transport, options) {
@@ -77,9 +76,6 @@ class WKBrowser extends import_browser.Browser {
     for (const wkPage of this._wkPages.values())
       wkPage.didClose();
     this._wkPages.clear();
-    for (const video of this._idToVideo.values())
-      video.artifact.reportFinished(new import_errors.TargetClosedError(this.closeReason()));
-    this._idToVideo.clear();
     this._didClose();
   }
   async doCreateNewContext(options) {
@@ -311,7 +307,6 @@ class WKBrowserContext extends import_browserContext.BrowserContext {
   }
   async doClose(reason) {
     if (!this._browserContextId) {
-      await Promise.all(this._wkPages().map((wkPage) => wkPage._page.screencast.stopVideoRecording()));
       await this._browser.close({ reason });
     } else {
       await this._browser._browserSession.send("Playwright.deleteContext", { browserContextId: this._browserContextId });

package/lib/server/webkit/wkPage.js

@@ -37,6 +37,7 @@ var import_eventsHelper = require("../utils/eventsHelper");
 var import_hostPlatform = require("../utils/hostPlatform");
 var import_stackTrace = require("../../utils/isomorphic/stackTrace");
 var import_utilsBundle = require("../../utilsBundle");
+var import_browserContext = require("../browserContext");
 var dialog = __toESM(require("../dialog"));
 var dom = __toESM(require("../dom"));
 var import_errors = require("../errors");
@@ -51,8 +52,9 @@ var import_wkProvisionalPage = require("./wkProvisionalPage");
 var import_wkWorkers = require("./wkWorkers");
 var import_webkit = require("./webkit");
 var import_registry = require("../registry");
+var import_videoRecorder = require("../videoRecorder");
 const UTILITY_WORLD_NAME = "__playwright_utility_world__";
-const enableFrameSessions = !process.env.WK_DISABLE_FRAME_SESSIONS && parseInt(import_registry.registry.findExecutable("webkit").revision, 10) >= 2245;
+const enableFrameSessions = !process.env.WK_DISABLE_FRAME_SESSIONS && parseInt(import_registry.registry.findExecutable("webkit").revision, 10) >= 2245 && parseInt(import_registry.registry.findExecutable("webkit").revision, 10) <= 2255;
 class WKPage {
   constructor(browserContext, pageProxySession, opener) {
     this._provisionalPage = null;
@@ -115,7 +117,7 @@ class WKPage {
       for (const [key, value] of this._browserContext._permissions)
         promises.push(this._grantPermissions(key, value));
     }
-    promises.push(this._initializeVideoRecording());
+    (0, import_videoRecorder.startAutomaticVideoRecording)(this._page);
     await Promise.all(promises);
   }
   _setSession(session) {
@@ -518,7 +520,7 @@ class WKPage {
         columnNumber: (columnNumber || 1) - 1
       }
     };
-    this._onConsoleRepeatCountUpdated({ count: 1 });
+    this._onConsoleRepeatCountUpdated({ count: 1, timestamp: event.message.timestamp });
   }
   _onConsoleRepeatCountUpdated(event) {
     if (this._lastConsoleMessage) {
@@ -529,8 +531,9 @@ class WKPage {
         count,
         location
       } = this._lastConsoleMessage;
+      const timestamp = event.timestamp ? event.timestamp * 1e3 : Date.now();
       for (let i = count; i < event.count; ++i)
-        this._page.addConsoleMessage(null, derivedType, handles, location, handles.length ? void 0 : text);
+        this._page.addConsoleMessage(null, derivedType, handles, location, handles.length ? void 0 : text, timestamp);
       this._lastConsoleMessage.count = event.count;
     }
   }
@@ -645,9 +648,11 @@ class WKPage {
   async updateUserAgent() {
     const contextOptions = this._browserContext._options;
     this._updateState("Page.overrideUserAgent", { value: contextOptions.userAgent });
+    const { navigatorPlatform } = (0, import_browserContext.calculateUserAgentEmulation)(contextOptions);
+    this._updateState("Page.overridePlatform", navigatorPlatform ? { value: navigatorPlatform } : {});
   }
   async bringToFront() {
-    this._pageProxySession.send("Target.activate", {
+    await this._pageProxySession.send("Target.activate", {
       targetId: this._session.sessionId
     });
   }
@@ -773,12 +778,6 @@ class WKPage {
       return import_hostPlatform.hostPlatform === "mac10.15" ? 55 : 59;
     return 0;
   }
-  async _initializeVideoRecording() {
-    const screencast = this._page.screencast;
-    const videoOptions = screencast.launchVideoRecorder();
-    if (videoOptions)
-      await screencast.startVideoRecording(videoOptions);
-  }
   validateScreenshotDimension(side, omitDeviceScaleFactor) {
     if (process.platform === "darwin")
       return;
@@ -845,29 +844,28 @@ class WKPage {
       throw e;
     });
   }
-  async startScreencast(options) {
-    const { generation } = await this._pageProxySession.send("Screencast.startScreencast", {
+  startScreencast(options) {
+    this._pageProxySession.send("Screencast.startScreencast", {
       quality: options.quality,
       width: options.width,
       height: options.height,
       toolbarHeight: this._toolbarHeight()
+    }).then(({ generation }) => this._screencastGeneration = generation).catch(() => {
     });
-    this._screencastGeneration = generation;
   }
-  async stopScreencast() {
-    await this._pageProxySession.sendMayFail("Screencast.stopScreencast");
+  stopScreencast() {
+    this._pageProxySession.sendMayFail("Screencast.stopScreencast");
   }
   _onScreencastFrame(event) {
     const generation = this._screencastGeneration;
-    this._page.screencast.throttleFrameAck(() => {
-      this._pageProxySession.sendMayFail("Screencast.screencastFrameAck", { generation });
-    });
     const buffer = Buffer.from(event.data, "base64");
-    this._page.emit(import_page.Page.Events.ScreencastFrame, {
+    this._page.screencast.onScreencastFrame({
       buffer,
       frameSwapWallTime: event.timestamp ? event.timestamp * 1e3 : Date.now(),
-      width: event.deviceWidth,
-      height: event.deviceHeight
+      viewportWidth: event.deviceWidth,
+      viewportHeight: event.deviceHeight
+    }, () => {
+      this._pageProxySession.sendMayFail("Screencast.screencastFrameAck", { generation });
     });
   }
   rafCountForStablePosition() {
@@ -981,6 +979,7 @@ class WKPage {
   }
   _handleRequestRedirect(request, requestId, responsePayload, timestamp) {
     const response = request.createResponse(responsePayload);
+    response._setHttpVersion(null);
     response._securityDetailsFinished();
     response._serverAddrFinished();
     response.setResponseHeadersSize(null);
@@ -1033,8 +1032,7 @@ class WKPage {
         validFrom: responseReceivedPayload?.response.security?.certificate?.validFrom,
         validTo: responseReceivedPayload?.response.security?.certificate?.validUntil
       });
-      if (event.metrics?.protocol)
-        response._setHttpVersion(event.metrics.protocol);
+      response._setHttpVersion(event.metrics?.protocol ?? null);
       response.setEncodedBodySize(event.metrics?.responseBodyBytesReceived ?? null);
       response.setResponseHeadersSize(event.metrics?.responseHeaderBytesReceived ?? null);
       response._requestFinished(import_helper.helper.secondsToRoundishMillis(event.timestamp - request._timestamp));
@@ -1058,6 +1056,7 @@ class WKPage {
     if (response) {
       response._serverAddrFinished();
       response._securityDetailsFinished();
+      response._setHttpVersion(null);
       response.setResponseHeadersSize(null);
       response.setEncodedBodySize(null);
       response._requestFinished(import_helper.helper.secondsToRoundishMillis(event.timestamp - request._timestamp));
@@ -1072,7 +1071,8 @@ class WKPage {
     const webPermissionToProtocol = /* @__PURE__ */ new Map([
       ["geolocation", "geolocation"],
       ["notifications", "notifications"],
-      ["clipboard-read", "clipboard-read"]
+      ["clipboard-read", "clipboard-read"],
+      ["screen-wake-lock", "screen-wake-lock"]
     ]);
     const filtered = permissions.map((permission) => {
       const protocolPermission = webPermissionToProtocol.get(permission);
@@ -1088,6 +1088,8 @@ class WKPage {
   shouldToggleStyleSheetToSyncAnimations() {
     return true;
   }
+  async setDockTile(image) {
+  }
 }
 class WKFrame {
   constructor(page, session) {

package/lib/server/webkit/wkWorkers.js

@@ -96,7 +96,8 @@ class WKWorkers {
       lineNumber: (lineNumber || 1) - 1,
       columnNumber: (columnNumber || 1) - 1
     };
-    this._page.addConsoleMessage(worker, derivedType, handles, location, handles.length ? void 0 : text);
+    const timestamp = event.message.timestamp ? event.message.timestamp * 1e3 : Date.now();
+    this._page.addConsoleMessage(worker, derivedType, handles, location, handles.length ? void 0 : text, timestamp);
   }
 }
 // Annotate the CommonJS export names for ESM import in node: