patchright-core 1.57.0 → 1.59.0

package/lib/server/utils/expectUtils.js

@@ -18,10 +18,16 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var expectUtils_exports = {};
 __export(expectUtils_exports, {
-  serializeExpectedTextValues: () => serializeExpectedTextValues
+  callLogText: () => callLogText,
+  formatMatcherMessage: () => formatMatcherMessage,
+  printReceivedStringContainExpectedResult: () => printReceivedStringContainExpectedResult,
+  printReceivedStringContainExpectedSubstring: () => printReceivedStringContainExpectedSubstring,
+  serializeExpectedTextValues: () => serializeExpectedTextValues,
+  simpleMatcherUtils: () => simpleMatcherUtils
 });
 module.exports = __toCommonJS(expectUtils_exports);
 var import_rtti = require("../../utils/isomorphic/rtti");
+var import_utilsBundle = require("../../utilsBundle");
 function serializeExpectedTextValues(items, options = {}) {
   return items.map((i) => ({
     string: (0, import_rtti.isString)(i) ? i : void 0,
@@ -32,7 +38,86 @@ function serializeExpectedTextValues(items, options = {}) {
     normalizeWhiteSpace: options.normalizeWhiteSpace
   }));
 }
+const printSubstring = (val) => val.replace(/"|\\/g, "\\$&");
+const printReceivedStringContainExpectedSubstring = (utils, received, start, length) => utils.RECEIVED_COLOR(
+  '"' + printSubstring(received.slice(0, start)) + utils.INVERTED_COLOR(printSubstring(received.slice(start, start + length))) + printSubstring(received.slice(start + length)) + '"'
+);
+const printReceivedStringContainExpectedResult = (utils, received, result) => result === null ? utils.printReceived(received) : printReceivedStringContainExpectedSubstring(
+  utils,
+  received,
+  result.index,
+  result[0].length
+);
+function formatMatcherMessage(utils, details) {
+  const receiver = details.receiver ?? (details.locator ? "locator" : "page");
+  let message = utils.DIM_COLOR("expect(") + utils.RECEIVED_COLOR(receiver) + utils.DIM_COLOR(")" + (details.promise ? "." + details.promise : "") + (details.isNot ? ".not" : "") + ".") + details.matcherName + utils.DIM_COLOR("(") + utils.EXPECTED_COLOR(details.expectation) + utils.DIM_COLOR(")") + " failed\n\n";
+  const diffLines = details.printedDiff?.split("\n");
+  if (diffLines?.length === 2) {
+    details.printedExpected = diffLines[0];
+    details.printedReceived = diffLines[1];
+    details.printedDiff = void 0;
+  }
+  const align = !details.errorMessage && details.printedExpected?.startsWith("Expected:") && (!details.printedReceived || details.printedReceived.startsWith("Received:"));
+  if (details.locator)
+    message += `Locator: ${align ? " " : ""}${details.locator}
+`;
+  if (details.printedExpected)
+    message += details.printedExpected + "\n";
+  if (details.printedReceived)
+    message += details.printedReceived + "\n";
+  if (details.timedOut && details.timeout)
+    message += `Timeout: ${align ? " " : ""}${details.timeout}ms
+`;
+  if (details.printedDiff)
+    message += details.printedDiff + "\n";
+  if (details.errorMessage) {
+    message += details.errorMessage;
+    if (!details.errorMessage.endsWith("\n"))
+      message += "\n";
+  }
+  message += callLogText(utils, details.log);
+  return message;
+}
+const callLogText = (utils, log) => {
+  if (!log || !log.some((l) => !!l))
+    return "";
+  return `
+Call log:
+${utils.DIM_COLOR(log.join("\n"))}
+`;
+};
+function printValue(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function printReceived(value) {
+  return import_utilsBundle.colors.red(printValue(value));
+}
+function printExpected(value) {
+  return import_utilsBundle.colors.green(printValue(value));
+}
+const simpleMatcherUtils = {
+  DIM_COLOR: import_utilsBundle.colors.dim,
+  RECEIVED_COLOR: import_utilsBundle.colors.red,
+  EXPECTED_COLOR: import_utilsBundle.colors.green,
+  INVERTED_COLOR: import_utilsBundle.colors.inverse,
+  printReceived,
+  printExpected,
+  printDiffOrStringify: (expected, received, expectedLabel, receivedLabel) => {
+    const maxLength = Math.max(expectedLabel.length, receivedLabel.length) + 2;
+    return `${expectedLabel}: `.padEnd(maxLength) + printExpected(expected) + `
+` + `${receivedLabel}: `.padEnd(maxLength) + printReceived(received);
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  serializeExpectedTextValues
+  callLogText,
+  formatMatcherMessage,
+  printReceivedStringContainExpectedResult,
+  printReceivedStringContainExpectedSubstring,
+  serializeExpectedTextValues,
+  simpleMatcherUtils
 });

package/lib/server/utils/fileUtils.js

@@ -32,6 +32,7 @@ __export(fileUtils_exports, {
   canAccessFile: () => canAccessFile,
   copyFileAndMakeWritable: () => copyFileAndMakeWritable,
   existsAsync: () => existsAsync,
+  makeSocketPath: () => makeSocketPath,
   mkdirIfNeeded: () => mkdirIfNeeded,
   removeFolders: () => removeFolders,
   sanitizeForFilePath: () => sanitizeForFilePath,
@@ -39,9 +40,10 @@ __export(fileUtils_exports, {
 });
 module.exports = __toCommonJS(fileUtils_exports);
 var import_fs = __toESM(require("fs"));
+var import_os = __toESM(require("os"));
 var import_path = __toESM(require("path"));
+var import_crypto = require("./crypto");
 var import_manualPromise = require("../../utils/isomorphic/manualPromise");
-var import_zipBundle = require("../../zipBundle");
 const existsAsync = (path2) => new Promise((resolve) => import_fs.default.stat(path2, (err) => resolve(!err)));
 async function mkdirIfNeeded(filePath) {
   await import_fs.default.promises.mkdir(import_path.default.dirname(filePath), { recursive: true }).catch(() => {
@@ -72,6 +74,16 @@ function sanitizeForFilePath(s) {
 function toPosixPath(aPath) {
   return aPath.split(import_path.default.sep).join(import_path.default.posix.sep);
 }
+function makeSocketPath(domain, name) {
+  const userNameHash = (0, import_crypto.calculateSha1)(process.env.USERNAME || process.env.USER || "default").slice(0, 8);
+  if (process.platform === "win32")
+    return `\\\\.\\pipe\\pw-${userNameHash}-${domain}-${name}`;
+  const baseDir = process.env.PLAYWRIGHT_SOCKETS_DIR || import_path.default.join(import_os.default.tmpdir(), `pw-${userNameHash}`);
+  const dir = import_path.default.join(baseDir, domain);
+  const result = import_path.default.join(dir, `${name}.sock`);
+  import_fs.default.mkdirSync(dir, { recursive: true });
+  return result;
+}
 class SerializedFS {
   constructor() {
     this._buffers = /* @__PURE__ */ new Map();
@@ -165,7 +177,8 @@ class SerializedFS {
         return;
       }
       case "zip": {
-        const zipFile = new import_zipBundle.yazl.ZipFile();
+        const { yazl } = await import("playwright-core/lib/zipBundle");
+        const zipFile = new yazl.ZipFile();
         const result = new import_manualPromise.ManualPromise();
         zipFile.on("error", (error) => result.reject(error));
         for (const entry of op.entries)
@@ -184,6 +197,7 @@ class SerializedFS {
   canAccessFile,
   copyFileAndMakeWritable,
   existsAsync,
+  makeSocketPath,
   mkdirIfNeeded,
   removeFolders,
   sanitizeForFilePath,

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

@@ -36,7 +36,6 @@ var import_path = __toESM(require("path"));
 var import_utilsBundle = require("../../utilsBundle");
 var import_crypto = require("./crypto");
 var import_assert = require("../../utils/isomorphic/assert");
-var import_manualPromise = require("../../utils/isomorphic/manualPromise");
 var import_network = require("./network");
 class HttpServer {
   constructor() {
@@ -59,28 +58,16 @@ class HttpServer {
   port() {
     return this._port;
   }
-  async _tryStart(port, host) {
-    const errorPromise = new import_manualPromise.ManualPromise();
-    const errorListener = (error) => errorPromise.reject(error);
-    this._server.on("error", errorListener);
-    try {
-      this._server.listen(port, host);
-      await Promise.race([
-        new Promise((cb) => this._server.once("listening", cb)),
-        errorPromise
-      ]);
-    } finally {
-      this._server.removeListener("error", errorListener);
-    }
-  }
-  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 {
@@ -100,17 +87,17 @@ class HttpServer {
   async start(options = {}) {
     (0, import_assert.assert)(!this._started, "server already started");
     this._started = true;
-    const host = options.host || "localhost";
+    const host = options.host;
     if (options.preferredPort) {
       try {
-        await this._tryStart(options.preferredPort, host);
+        await (0, import_network.startHttpServer)(this._server, { port: options.preferredPort, host });
       } catch (e) {
         if (!e || !e.message || !e.message.includes("EADDRINUSE"))
           throw e;
-        await this._tryStart(void 0, host);
+        await (0, import_network.startHttpServer)(this._server, { host });
       }
     } else {
-      await this._tryStart(options.port, host);
+      await (0, import_network.startHttpServer)(this._server, { port: options.port, host });
     }
     const address = this._server.address();
     (0, import_assert.assert)(address, "Could not bind server socket");
@@ -121,7 +108,7 @@ class HttpServer {
       this._port = address.port;
       const resolvedHost = address.family === "IPv4" ? address.address : `[${address.address}]`;
       this._urlPrefixPrecise = `http://${resolvedHost}:${address.port}`;
-      this._urlPrefixHumanReadable = `http://${host}:${address.port}`;
+      this._urlPrefixHumanReadable = `http://${host ?? "localhost"}:${address.port}`;
     }
   }
   async stop() {

package/lib/server/utils/network.js

@@ -33,24 +33,23 @@ __export(network_exports, {
   createHttpServer: () => createHttpServer,
   createHttpsServer: () => createHttpsServer,
   createProxyAgent: () => createProxyAgent,
+  decorateServer: () => decorateServer,
   fetchData: () => fetchData,
   httpRequest: () => httpRequest,
-  isURLAvailable: () => isURLAvailable
+  isURLAvailable: () => isURLAvailable,
+  startHttpServer: () => startHttpServer
 });
 module.exports = __toCommonJS(network_exports);
 var import_http = __toESM(require("http"));
 var import_http2 = __toESM(require("http2"));
 var import_https = __toESM(require("https"));
-var import_url = __toESM(require("url"));
 var import_utilsBundle = require("../../utilsBundle");
 var import_happyEyeballs = require("./happyEyeballs");
 var import_manualPromise = require("../../utils/isomorphic/manualPromise");
 const NET_DEFAULT_TIMEOUT = 3e4;
 function httpRequest(params, onResponse, onError) {
-  const parsedUrl = import_url.default.parse(params.url);
-  let options = {
-    ...parsedUrl,
-    agent: parsedUrl.protocol === "https:" ? import_happyEyeballs.httpsHappyEyeballsAgent : import_happyEyeballs.httpHappyEyeballsAgent,
+  let url = new URL(params.url);
+  const options = {
     method: params.method || "GET",
     headers: params.headers
   };
@@ -58,21 +57,15 @@ function httpRequest(params, onResponse, onError) {
     options.rejectUnauthorized = params.rejectUnauthorized;
   const proxyURL = (0, import_utilsBundle.getProxyForUrl)(params.url);
   if (proxyURL) {
+    const parsedProxyURL = normalizeProxyURL(proxyURL);
     if (params.url.startsWith("http:")) {
-      const parsedProxyURL = import_url.default.parse(proxyURL);
-      options = {
-        path: parsedUrl.href,
-        host: parsedProxyURL.hostname,
-        port: parsedProxyURL.port,
-        protocol: parsedProxyURL.protocol || "http:",
-        headers: options.headers,
-        method: options.method
-      };
+      parsedProxyURL.pathname = url.toString();
+      url = parsedProxyURL;
     } else {
-      options.agent = new import_utilsBundle.HttpsProxyAgent(normalizeProxyURL(proxyURL));
-      options.rejectUnauthorized = false;
+      options.agent = new import_utilsBundle.HttpsProxyAgent(parsedProxyURL);
     }
   }
+  options.agent ??= url.protocol === "https:" ? import_happyEyeballs.httpsHappyEyeballsAgent : import_happyEyeballs.httpHappyEyeballsAgent;
   let cancelRequest;
   const requestCallback = (res) => {
     const statusCode = res.statusCode || 0;
@@ -83,7 +76,7 @@ function httpRequest(params, onResponse, onError) {
       onResponse(res);
     }
   };
-  const request = options.protocol === "https:" ? import_https.default.request(options, requestCallback) : import_http.default.request(options, requestCallback);
+  const request = url.protocol === "https:" ? import_https.default.request(url, options, requestCallback) : import_http.default.request(url, options, requestCallback);
   request.on("error", onError);
   if (params.socketTimeout !== void 0) {
     request.setTimeout(params.socketTimeout, () => {
@@ -122,7 +115,7 @@ async function fetchData(progress, params, onError) {
     throw error;
   }
 }
-function shouldBypassProxy(url2, bypass) {
+function shouldBypassProxy(url, bypass) {
   if (!bypass)
     return false;
   const domains = bypass.split(",").map((s) => {
@@ -131,7 +124,7 @@ function shouldBypassProxy(url2, bypass) {
       s = "." + s;
     return s;
   });
-  const domain = "." + url2.hostname;
+  const domain = "." + url.hostname;
   return domains.some((d) => domain.endsWith(d));
 }
 function normalizeProxyURL(proxy) {
@@ -177,20 +170,35 @@ function createHttp2Server(...args) {
   decorateServer(server);
   return server;
 }
-async function isURLAvailable(url2, ignoreHTTPSErrors, onLog, onStdErr) {
-  let statusCode = await httpStatusCode(url2, ignoreHTTPSErrors, onLog, onStdErr);
-  if (statusCode === 404 && url2.pathname === "/") {
-    const indexUrl = new URL(url2);
+async function startHttpServer(server, options) {
+  const { host = "localhost", port = 0 } = options;
+  const errorPromise = new import_manualPromise.ManualPromise();
+  const errorListener = (error) => errorPromise.reject(error);
+  server.on("error", errorListener);
+  try {
+    server.listen(port, host);
+    await Promise.race([
+      new Promise((cb) => server.once("listening", cb)),
+      errorPromise
+    ]);
+  } finally {
+    server.removeListener("error", errorListener);
+  }
+}
+async function isURLAvailable(url, ignoreHTTPSErrors, onLog, onStdErr) {
+  let statusCode = await httpStatusCode(url, ignoreHTTPSErrors, onLog, onStdErr);
+  if (statusCode === 404 && url.pathname === "/") {
+    const indexUrl = new URL(url);
     indexUrl.pathname = "/index.html";
     statusCode = await httpStatusCode(indexUrl, ignoreHTTPSErrors, onLog, onStdErr);
   }
   return statusCode >= 200 && statusCode < 404;
 }
-async function httpStatusCode(url2, ignoreHTTPSErrors, onLog, onStdErr) {
+async function httpStatusCode(url, ignoreHTTPSErrors, onLog, onStdErr) {
   return new Promise((resolve) => {
-    onLog?.(`HTTP GET: ${url2}`);
+    onLog?.(`HTTP GET: ${url}`);
     httpRequest({
-      url: url2.toString(),
+      url: url.toString(),
       headers: { Accept: "*/*" },
       rejectUnauthorized: !ignoreHTTPSErrors
     }, (res) => {
@@ -201,7 +209,7 @@ async function httpStatusCode(url2, ignoreHTTPSErrors, onLog, onStdErr) {
     }, (error) => {
       if (error.code === "DEPTH_ZERO_SELF_SIGNED_CERT")
         onStdErr?.(`[WebServer] Self-signed certificate detected. Try adding ignoreHTTPSErrors: true to config.webServer.`);
-      onLog?.(`Error while checking if ${url2} is available: ${error.message}`);
+      onLog?.(`Error while checking if ${url} is available: ${error.message}`);
       resolve(0);
     });
   });
@@ -227,7 +235,9 @@ function decorateServer(server) {
   createHttpServer,
   createHttpsServer,
   createProxyAgent,
+  decorateServer,
   fetchData,
   httpRequest,
-  isURLAvailable
+  isURLAvailable,
+  startHttpServer
 });

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

@@ -0,0 +1,194 @@
+"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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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,
+  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(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();
+    this._firstFrameTimestamp = 0;
+    this._lastFrame = null;
+    this._lastWriteNodeTime = 0;
+    this._frameQueue = [];
+    this._isStopped = false;
+    if (!outputFile.endsWith(".webm"))
+      throw new Error("File must have .webm extension");
+    this._outputFile = outputFile;
+    this._ffmpegPath = ffmpegPath;
+    this._size = size;
+    this._launchPromise = this._launch().catch((e) => e);
+  }
+  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(this._outputFile);
+    const { launchedProcess, gracefullyClose } = await (0, import_processLauncher.launchProcess)({
+      command: this._ffmpegPath,
+      args,
+      stdio: "stdin",
+      log: (message) => import_utils.debugLogger.log("browser", message),
+      tempDirectories: [],
+      attemptToGracefullyClose: async () => {
+        import_utils.debugLogger.log("browser", "Closing stdin...");
+        launchedProcess.stdin.end();
+      },
+      onExit: (exitCode, signal) => {
+        import_utils.debugLogger.log("browser", `ffmpeg onkill exitCode=${exitCode} signal=${signal}`);
+      }
+    });
+    launchedProcess.stdin.on("finish", () => {
+      import_utils.debugLogger.log("browser", "ffmpeg finished input.");
+    });
+    launchedProcess.stdin.on("error", () => {
+      import_utils.debugLogger.log("browser", "ffmpeg error.");
+    });
+    this._process = launchedProcess;
+    this._gracefullyClose = gracefullyClose;
+  }
+  writeFrame(frame, timestamp) {
+    this._launchPromise.then((error) => {
+      if (error)
+        return;
+      this._writeFrame(frame, timestamp);
+    });
+  }
+  _writeFrame(frame, timestamp) {
+    (0, import_utils.assert)(this._process);
+    if (this._isStopped)
+      return;
+    if (!this._firstFrameTimestamp)
+      this._firstFrameTimestamp = timestamp;
+    const frameNumber = Math.floor((timestamp - this._firstFrameTimestamp) * fps);
+    if (this._lastFrame) {
+      const repeatCount = frameNumber - this._lastFrame.frameNumber;
+      for (let i = 0; i < repeatCount; ++i)
+        this._frameQueue.push(this._lastFrame.buffer);
+      this._lastWritePromise = this._lastWritePromise.then(() => this._sendFrames());
+    }
+    this._lastFrame = { buffer: frame, timestamp, frameNumber };
+    this._lastWriteNodeTime = (0, import_utils.monotonicTime)();
+  }
+  async _sendFrames() {
+    while (this._frameQueue.length)
+      await this._sendFrame(this._frameQueue.shift());
+  }
+  async _sendFrame(frame) {
+    return new Promise((f) => this._process.stdin.write(frame, f)).then((error) => {
+      if (error)
+        import_utils.debugLogger.log("browser", `ffmpeg failed to write: ${String(error)}`);
+    });
+  }
+  async stop() {
+    const error = await this._launchPromise;
+    if (error)
+      throw error;
+    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;
+    try {
+      await this._lastWritePromise;
+      await this._gracefullyClose();
+    } catch (e) {
+      import_utils.debugLogger.log("error", `ffmpeg failed to stop: ${String(e)}`);
+    }
+  }
+}
+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,
+  startAutomaticVideoRecording
+});