brave-real-playwright-core 1.56.1 → 1.57.0

package/lib/server/registry/index.js

@@ -77,34 +77,72 @@ if (process.env.PW_TEST_CDN_THAT_SHOULD_WORK) {
 }
 const EXECUTABLE_PATHS = {
   "chromium": {
-    "linux": ["chrome-linux", "chrome"],
-    "mac": ["chrome-mac", "Chromium.app", "Contents", "MacOS", "Chromium"],
-    "win": ["chrome-win", "chrome.exe"]
+    "<unknown>": void 0,
+    "linux-x64": ["chrome-linux64", "chrome"],
+    "linux-arm64": ["chrome-linux", "chrome"],
+    // non-cft build
+    "mac-x64": ["chrome-mac-x64", "Google Chrome for Testing.app", "Contents", "MacOS", "Google Chrome for Testing"],
+    "mac-arm64": ["chrome-mac-arm64", "Google Chrome for Testing.app", "Contents", "MacOS", "Google Chrome for Testing"],
+    "win-x64": ["chrome-win64", "chrome.exe"]
   },
   "chromium-headless-shell": {
-    "linux": ["chrome-linux", "headless_shell"],
-    "mac": ["chrome-mac", "headless_shell"],
-    "win": ["chrome-win", "headless_shell.exe"]
+    "<unknown>": void 0,
+    "linux-x64": ["chrome-headless-shell-linux64", "chrome-headless-shell"],
+    "linux-arm64": ["chrome-linux", "headless_shell"],
+    // non-cft build
+    "mac-x64": ["chrome-headless-shell-mac-x64", "chrome-headless-shell"],
+    "mac-arm64": ["chrome-headless-shell-mac-arm64", "chrome-headless-shell"],
+    "win-x64": ["chrome-headless-shell-win64", "chrome-headless-shell.exe"]
+  },
+  "chromium-tip-of-tree": {
+    "<unknown>": void 0,
+    "linux-x64": ["chrome-linux64", "chrome"],
+    "linux-arm64": ["chrome-linux", "chrome"],
+    // non-cft build
+    "mac-x64": ["chrome-mac-x64", "Google Chrome for Testing.app", "Contents", "MacOS", "Google Chrome for Testing"],
+    "mac-arm64": ["chrome-mac-arm64", "Google Chrome for Testing.app", "Contents", "MacOS", "Google Chrome for Testing"],
+    "win-x64": ["chrome-win64", "chrome.exe"]
+  },
+  "chromium-tip-of-tree-headless-shell": {
+    "<unknown>": void 0,
+    "linux-x64": ["chrome-headless-shell-linux64", "chrome-headless-shell"],
+    "linux-arm64": ["chrome-linux", "headless_shell"],
+    // non-cft build
+    "mac-x64": ["chrome-headless-shell-mac-x64", "chrome-headless-shell"],
+    "mac-arm64": ["chrome-headless-shell-mac-arm64", "chrome-headless-shell"],
+    "win-x64": ["chrome-headless-shell-win64", "chrome-headless-shell.exe"]
   },
   "firefox": {
-    "linux": ["firefox", "firefox"],
-    "mac": ["firefox", "Nightly.app", "Contents", "MacOS", "firefox"],
-    "win": ["firefox", "firefox.exe"]
+    "<unknown>": void 0,
+    "linux-x64": ["firefox", "firefox"],
+    "linux-arm64": ["firefox", "firefox"],
+    "mac-x64": ["firefox", "Nightly.app", "Contents", "MacOS", "firefox"],
+    "mac-arm64": ["firefox", "Nightly.app", "Contents", "MacOS", "firefox"],
+    "win-x64": ["firefox", "firefox.exe"]
   },
   "webkit": {
-    "linux": ["pw_run.sh"],
-    "mac": ["pw_run.sh"],
-    "win": ["Playwright.exe"]
+    "<unknown>": void 0,
+    "linux-x64": ["pw_run.sh"],
+    "linux-arm64": ["pw_run.sh"],
+    "mac-x64": ["pw_run.sh"],
+    "mac-arm64": ["pw_run.sh"],
+    "win-x64": ["Playwright.exe"]
   },
   "ffmpeg": {
-    "linux": ["ffmpeg-linux"],
-    "mac": ["ffmpeg-mac"],
-    "win": ["ffmpeg-win64.exe"]
+    "<unknown>": void 0,
+    "linux-x64": ["ffmpeg-linux"],
+    "linux-arm64": ["ffmpeg-linux"],
+    "mac-x64": ["ffmpeg-mac"],
+    "mac-arm64": ["ffmpeg-mac"],
+    "win-x64": ["ffmpeg-win64.exe"]
   },
   "winldd": {
-    "linux": void 0,
-    "mac": void 0,
-    "win": ["PrintDeps.exe"]
+    "<unknown>": void 0,
+    "linux-x64": void 0,
+    "linux-arm64": void 0,
+    "mac-x64": void 0,
+    "mac-arm64": void 0,
+    "win-x64": ["PrintDeps.exe"]
   }
 };
 const DOWNLOAD_PATHS = {
@@ -417,10 +455,7 @@ const DOWNLOAD_PATHS = {
     "mac15": "builds/android/%s/android.zip",
     "mac15-arm64": "builds/android/%s/android.zip",
     "win64": "builds/android/%s/android.zip"
-  },
-  // TODO(bidi): implement downloads.
-  "_bidiFirefox": {},
-  "_bidiChromium": {}
+  }
 };
 const registryDirectory = (() => {
   let result;
@@ -482,13 +517,7 @@ class Registry {
   constructor(browsersJSON) {
     const descriptors = readDescriptors(browsersJSON);
     const findExecutablePath = (dir, name) => {
-      let tokens = void 0;
-      if (process.platform === "linux")
-        tokens = EXECUTABLE_PATHS[name]["linux"];
-      else if (process.platform === "darwin")
-        tokens = EXECUTABLE_PATHS[name]["mac"];
-      else if (process.platform === "win32")
-        tokens = EXECUTABLE_PATHS[name]["win"];
+      const tokens = EXECUTABLE_PATHS[name][import_hostPlatform.shortPlatform];
       return tokens ? import_path.default.join(dir, ...tokens) : void 0;
     };
     const executablePathOrDie = (name, e, installByDefault, sdkLanguage) => {
@@ -555,7 +584,7 @@ ${(0, import_ascii.wrapInASCIIBox)(prettyMessage, 1)}`);
       _isHermeticInstallation: true
     });
     const chromiumTipOfTreeHeadlessShell = descriptors.find((d) => d.name === "chromium-tip-of-tree-headless-shell");
-    const chromiumTipOfTreeHeadlessShellExecutable = findExecutablePath(chromiumTipOfTreeHeadlessShell.dir, "chromium-headless-shell");
+    const chromiumTipOfTreeHeadlessShellExecutable = findExecutablePath(chromiumTipOfTreeHeadlessShell.dir, "chromium-tip-of-tree-headless-shell");
     this._executables.push({
       type: "channel",
       name: "chromium-tip-of-tree-headless-shell",
@@ -572,7 +601,7 @@ ${(0, import_ascii.wrapInASCIIBox)(prettyMessage, 1)}`);
       _isHermeticInstallation: true
     });
     const chromiumTipOfTree = descriptors.find((d) => d.name === "chromium-tip-of-tree");
-    const chromiumTipOfTreeExecutable = findExecutablePath(chromiumTipOfTree.dir, "chromium");
+    const chromiumTipOfTreeExecutable = findExecutablePath(chromiumTipOfTree.dir, "chromium-tip-of-tree");
     this._executables.push({
       type: "tool",
       name: "chromium-tip-of-tree",
@@ -674,9 +703,9 @@ ${(0, import_ascii.wrapInASCIIBox)(prettyMessage, 1)}`);
       "win32": `\\Google\\Chrome SxS\\Application\\chrome.exe`
     }));
     this._executables.push({
-      type: "browser",
-      name: "_bidiChromium",
-      browserName: "_bidiChromium",
+      type: "channel",
+      name: "bidi-chromium",
+      browserName: "chromium",
       directory: chromium.dir,
       executablePath: () => chromiumExecutable,
       executablePathOrDie: (sdkLanguage) => executablePathOrDie("chromium", chromiumExecutable, chromium.installByDefault, sdkLanguage),
@@ -754,9 +783,8 @@ ${(0, import_ascii.wrapInASCIIBox)(prettyMessage, 1)}`);
       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`,
+      executablePath: () => webkitExecutable,
+      executablePathOrDie: (sdkLanguage) => executablePathOrDie("webkit", webkitExecutable, webkit.installByDefault, sdkLanguage),
       installType: "download-on-demand",
       _validateHostRequirements: (sdkLanguage) => Promise.resolve(),
       _isHermeticInstallation: true,
@@ -887,13 +915,14 @@ Run "${buildPlaywrightCLICommand(sdkLanguage, "install " + name)}"` : "";
           return executablePath2;
       }
       if (shouldThrow)
-        throw new Error(`Cannot find Firefox installation for channel '${name}' at the standard system paths.`);
+        throw new Error(`Cannot find Firefox installation for channel '${name}' at the standard system paths. ${`Tried paths:
+  ${prefixes.map((p) => import_path.default.join(p, suffix)).join("\n  ")}`}`);
       return void 0;
     };
     return {
       type: "channel",
       name,
-      browserName: "_bidiFirefox",
+      browserName: "firefox",
       directory: void 0,
       executablePath: (sdkLanguage) => executablePath(sdkLanguage, false),
       executablePathOrDie: (sdkLanguage) => executablePath(sdkLanguage, true),
@@ -934,7 +963,7 @@ Run "${buildPlaywrightCLICommand(sdkLanguage, "install " + name)}"` : "";
     return {
       type: "channel",
       name,
-      browserName: "_bidiChromium",
+      browserName: "chromium",
       directory: void 0,
       executablePath: (sdkLanguage) => executablePath(sdkLanguage, false),
       executablePathOrDie: (sdkLanguage) => executablePath(sdkLanguage, true),
@@ -975,7 +1004,7 @@ Run "${buildPlaywrightCLICommand(sdkLanguage, "install " + name)}"` : "";
     if (import_os.default.platform() === "linux")
       return await (0, import_dependencies2.installDependenciesLinux)(targets, dryRun);
   }
-  async install(executablesToInstall, forceReinstall) {
+  async install(executablesToInstall, options) {
     const executables = this._dedupe(executablesToInstall);
     await import_fs.default.promises.mkdir(registryDirectory, { recursive: true });
     const lockfilePath = import_path.default.join(registryDirectory, "__dirlock");
@@ -1003,7 +1032,7 @@ Run "${buildPlaywrightCLICommand(sdkLanguage, "install " + name)}"` : "";
         if (!executable._install)
           throw new Error(`ERROR: Playwright does not support installing ${executable.name}`);
         const { embedderName } = (0, import_userAgent.getEmbedderName)();
-        if (!(0, import_utils.getAsBooleanFromENV)("CI") && !executable._isHermeticInstallation && !forceReinstall && executable.executablePath(embedderName)) {
+        if (!(0, import_utils.getAsBooleanFromENV)("CI") && !executable._isHermeticInstallation && !options?.force && executable.executablePath(embedderName)) {
           const command = buildPlaywrightCLICommand(embedderName, "install --force " + executable.name);
           process.stderr.write("\n" + (0, import_ascii.wrapInASCIIBox)([
             `ATTENTION: "${executable.name}" is already installed on the system!`,
@@ -1247,6 +1276,47 @@ ${e.stack}`);
       await import_fs.default.promises.unlink(linkPath).catch((e) => {
       });
   }
+  _defaultBrowsersToInstall(options) {
+    let executables = this.defaultExecutables();
+    if (options.shell === "no")
+      executables = executables.filter((e) => e.name !== "chromium-headless-shell");
+    if (options.shell === "only")
+      executables = executables.filter((e) => e.name !== "chromium");
+    return executables;
+  }
+  suggestedBrowsersToInstall() {
+    return this.executables().filter((e) => e.installType !== "none" && e.type !== "tool").map((e) => e.name).join(", ");
+  }
+  resolveBrowsers(aliases, options) {
+    if (aliases.length === 0)
+      return this._defaultBrowsersToInstall(options);
+    const faultyArguments = [];
+    const executables = [];
+    const handleArgument = (arg) => {
+      const executable = this.findExecutable(arg);
+      if (!executable || executable.installType === "none")
+        faultyArguments.push(arg);
+      else
+        executables.push(executable);
+      if (executable?.browserName === "chromium")
+        executables.push(this.findExecutable("ffmpeg"));
+    };
+    for (const alias of aliases) {
+      if (alias === "chromium") {
+        if (options.shell !== "only")
+          handleArgument("chromium");
+        if (options.shell !== "no")
+          handleArgument("chromium-headless-shell");
+      } else {
+        handleArgument(alias);
+      }
+    }
+    if (process.platform === "win32")
+      executables.push(this.findExecutable("winldd"));
+    if (faultyArguments.length)
+      throw new Error(`Invalid installation targets: ${faultyArguments.map((name) => `'${name}'`).join(", ")}. Expecting one of: ${this.suggestedBrowsersToInstall()}`);
+    return executables;
+  }
 }
 function browserDirectoryToMarkerFilePath(browserDirectory) {
   return import_path.default.join(browserDirectory, "INSTALLATION_COMPLETE");
@@ -1279,11 +1349,7 @@ async function installBrowsersForNpmInstall(browsers) {
       throw new Error(`Cannot install ${browserName}`);
     executables.push(executable);
   }
-  await registry.install(
-    executables,
-    false
-    /* forceReinstall */
-  );
+  await registry.install(executables);
 }
 function findChromiumChannelBestEffort(sdkLanguage) {
   let channel = null;

package/lib/server/registry/oopDownloadBrowserMain.js

@@ -41,6 +41,7 @@ function browserDirectoryToMarkerFilePath(browserDirectory) {
 function downloadFile(options) {
   let downloadedBytes = 0;
   let totalBytes = 0;
+  let chunked = false;
   const promise = new import_manualPromise.ManualPromise();
   (0, import_network.httpRequest)({
     url: options.url,
@@ -60,11 +61,13 @@ function downloadFile(options) {
       response.on("data", (chunk) => content += chunk).on("end", handleError).on("error", handleError);
       return;
     }
+    chunked = response.headers["transfer-encoding"] === "chunked";
+    log(`-- is chunked: ${chunked}`);
     totalBytes = parseInt(response.headers["content-length"] || "0", 10);
     log(`-- total bytes: ${totalBytes}`);
     const file = import_fs.default.createWriteStream(options.zipPath);
     file.on("finish", () => {
-      if (downloadedBytes !== totalBytes) {
+      if (!chunked && downloadedBytes !== totalBytes) {
         log(`-- download failed, size mismatch: ${downloadedBytes} != ${totalBytes}`);
         promise.reject(new Error(`Download failed: size mismatch, file size: ${downloadedBytes}, expected size: ${totalBytes} URL: ${options.url}`));
       } else {
@@ -89,7 +92,8 @@ function downloadFile(options) {
   return promise;
   function onData(chunk) {
     downloadedBytes += chunk.length;
-    progress(downloadedBytes, totalBytes);
+    if (!chunked)
+      progress(downloadedBytes, totalBytes);
   }
 }
 async function main(options) {

package/lib/server/socksClientCertificatesInterceptor.js

@@ -82,7 +82,7 @@ class SocksProxyConnection {
   async connect() {
     const proxyAgent = this.socksProxy.getProxyAgent(this.host, this.port);
     if (proxyAgent)
-      this._serverEncrypted = await proxyAgent.callback(new import_events.EventEmitter(), { host: rewriteToLocalhostIfNeeded(this.host), port: this.port, secureEndpoint: false });
+      this._serverEncrypted = await proxyAgent.connect(new import_events.EventEmitter(), { host: rewriteToLocalhostIfNeeded(this.host), port: this.port, secureEndpoint: false });
     else
       this._serverEncrypted = await (0, import_happyEyeballs.createSocket)(rewriteToLocalhostIfNeeded(this.host), this.port);
     this._serverEncrypted.once("close", this._serverCloseEventListener);

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

@@ -40,6 +40,7 @@ var import_assert = require("../../../utils/isomorphic/assert");
 var import_time = require("../../../utils/isomorphic/time");
 var import_eventsHelper = require("../../utils/eventsHelper");
 var import_crypto = require("../../utils/crypto");
+var import_userAgent = require("../../utils/userAgent");
 var import_artifact = require("../../artifact");
 var import_browserContext = require("../../browserContext");
 var import_dispatcher = require("../../dispatchers/dispatcher");
@@ -74,6 +75,7 @@ class Tracing extends import_instrumentation.SdkObject {
       type: "context-options",
       origin: "library",
       browserName: "",
+      playwrightVersion: (0, import_userAgent.getPlaywrightVersion)(),
       options: {},
       platform: process.platform,
       wallTime: 0,

package/lib/server/trace/viewer/traceViewer.js

@@ -46,13 +46,21 @@ var import_launchApp = require("../../launchApp");
 var import_launchApp2 = require("../../launchApp");
 var import_playwright = require("../../playwright");
 var import_progress = require("../../progress");
-function validateTraceUrls(traceUrls) {
-  for (const traceUrl of traceUrls) {
-    let traceFile = traceUrl;
-    if (traceUrl.endsWith(".json"))
-      traceFile = traceUrl.substring(0, traceUrl.length - ".json".length);
-    if (!traceUrl.startsWith("http://") && !traceUrl.startsWith("https://") && !import_fs.default.existsSync(traceFile) && !import_fs.default.existsSync(traceFile + ".trace"))
-      throw new Error(`Trace file ${traceUrl} does not exist!`);
+const tracesDirMarker = "traces.dir";
+function validateTraceUrl(traceUrl) {
+  if (!traceUrl)
+    return traceUrl;
+  if (traceUrl.startsWith("http://") || traceUrl.startsWith("https://"))
+    return traceUrl;
+  if (traceUrl.endsWith(".json"))
+    return traceUrl;
+  try {
+    const stat = import_fs.default.statSync(traceUrl);
+    if (stat.isDirectory())
+      return import_path.default.join(traceUrl, tracesDirMarker);
+    return traceUrl;
+  } catch {
+    throw new Error(`Trace file ${traceUrl} does not exist!`);
   }
 }
 async function startTraceViewerServer(options) {
@@ -60,24 +68,18 @@ async function startTraceViewerServer(options) {
   server.routePrefix("/trace", (request, response) => {
     const url = new URL("http://localhost" + request.url);
     const relativePath = url.pathname.slice("/trace".length);
-    if (process.env.PW_HMR) {
-      response.appendHeader("Access-Control-Allow-Origin", "http://localhost:44223");
-    }
-    if (relativePath.endsWith("/stall.js"))
-      return true;
     if (relativePath.startsWith("/file")) {
       try {
         const filePath = url.searchParams.get("path");
         if (import_fs.default.existsSync(filePath))
           return server.serveFile(request, response, url.searchParams.get("path"));
         if (filePath.endsWith(".json")) {
-          const traceName = filePath.substring(0, filePath.length - ".json".length);
-          response.statusCode = 200;
-          response.setHeader("Content-Type", "application/json");
-          response.end(JSON.stringify(traceDescriptor(traceName)));
-          return true;
+          const fullPrefix = filePath.substring(0, filePath.length - ".json".length);
+          return sendTraceDescriptor(response, import_path.default.dirname(fullPrefix), import_path.default.basename(fullPrefix));
         }
-      } catch (e) {
+        if (filePath.endsWith(tracesDirMarker))
+          return sendTraceDescriptor(response, import_path.default.dirname(filePath));
+      } catch {
       }
       response.statusCode = 404;
       response.end();
@@ -93,11 +95,11 @@ async function startTraceViewerServer(options) {
   await server.start({ preferredPort: port, host });
   return server;
 }
-async function installRootRedirect(server, traceUrls, options) {
+async function installRootRedirect(server, traceUrl, options) {
   const params = new URLSearchParams();
   if (import_path.default.sep !== import_path.default.posix.sep)
     params.set("pathSeparator", import_path.default.sep);
-  for (const traceUrl of traceUrls)
+  if (traceUrl)
     params.append("trace", traceUrl);
   if (server.wsGuid())
     params.append("ws", server.wsGuid());
@@ -115,12 +117,7 @@ async function installRootRedirect(server, traceUrls, options) {
     params.append("project", project);
   for (const reporter of options.reporter || [])
     params.append("reporter", reporter);
-  let baseUrl = ".";
-  if (process.env.PW_HMR) {
-    baseUrl = "http://localhost:44223";
-    params.set("server", server.urlPrefix("precise"));
-  }
-  const urlPath = `${baseUrl}/trace/${options.webApp || "index.html"}?${params.toString()}`;
+  const urlPath = `./trace/${options.webApp || "index.html"}?${params.toString()}`;
   server.routePath("/", (_, response) => {
     response.statusCode = 302;
     response.setHeader("Location", urlPath);
@@ -128,19 +125,19 @@ async function installRootRedirect(server, traceUrls, options) {
     return true;
   });
 }
-async function runTraceViewerApp(traceUrls, browserName, options, exitOnClose) {
-  validateTraceUrls(traceUrls);
+async function runTraceViewerApp(traceUrl, browserName, options, exitOnClose) {
+  traceUrl = validateTraceUrl(traceUrl);
   const server = await startTraceViewerServer(options);
-  await installRootRedirect(server, traceUrls, options);
+  await installRootRedirect(server, traceUrl, options);
   const page = await openTraceViewerApp(server.urlPrefix("precise"), browserName, options);
   if (exitOnClose)
     page.on("close", () => (0, import_utils.gracefullyProcessExitDoNotHang)(0));
   return page;
 }
-async function runTraceInBrowser(traceUrls, options) {
-  validateTraceUrls(traceUrls);
+async function runTraceInBrowser(traceUrl, options) {
+  traceUrl = validateTraceUrl(traceUrl);
   const server = await startTraceViewerServer(options);
-  await installRootRedirect(server, traceUrls, options);
+  await installRootRedirect(server, traceUrl, options);
   await openTraceInBrowser(server.urlPrefix("human-readable"));
 }
 async function openTraceViewerApp(url, browserName, options) {
@@ -212,14 +209,18 @@ class StdinServer {
     }, 500);
   }
 }
-function traceDescriptor(traceName) {
+function sendTraceDescriptor(response, traceDir, tracePrefix) {
+  response.statusCode = 200;
+  response.setHeader("Content-Type", "application/json");
+  response.end(JSON.stringify(traceDescriptor(traceDir, tracePrefix)));
+  return true;
+}
+function traceDescriptor(traceDir, tracePrefix) {
   const result = {
     entries: []
   };
-  const traceDir = import_path.default.dirname(traceName);
-  const traceFile = import_path.default.basename(traceName);
   for (const name of import_fs.default.readdirSync(traceDir)) {
-    if (name.startsWith(traceFile))
+    if (!tracePrefix || name.startsWith(tracePrefix))
       result.entries.push({ name, path: import_path.default.join(traceDir, name) });
   }
   const resourcesDir = import_path.default.join(traceDir, "resources");

package/lib/server/utils/comparators.js

@@ -37,6 +37,7 @@ var import_pixelmatch = __toESM(require("../../third_party/pixelmatch"));
 var import_utilsBundle = require("../../utilsBundle");
 var import_utilsBundle2 = require("../../utilsBundle");
 var import_utilsBundle3 = require("../../utilsBundle");
+var import_imageUtils = require("./imageUtils");
 function getComparator(mimeType) {
   if (mimeType === "image/png")
     return compareImages.bind(null, "image/png");
@@ -66,8 +67,8 @@ function compareImages(mimeType, actualBuffer, expectedBuffer, options = {}) {
   let sizesMismatchError = "";
   if (expected.width !== actual.width || expected.height !== actual.height) {
     sizesMismatchError = `Expected an image ${expected.width}px by ${expected.height}px, received ${actual.width}px by ${actual.height}px. `;
-    actual = resizeImage(actual, size);
-    expected = resizeImage(expected, size);
+    actual = (0, import_imageUtils.padImageToSize)(actual, size);
+    expected = (0, import_imageUtils.padImageToSize)(expected, size);
   }
   const diff2 = new import_utilsBundle3.PNG({ width: size.width, height: size.height });
   let count;
@@ -131,29 +132,6 @@ function compareText(actual, expectedBuffer) {
   const errorMessage = coloredLines.join("\n");
   return { errorMessage };
 }
-function resizeImage(image, size) {
-  if (image.width === size.width && image.height === size.height)
-    return image;
-  const buffer = new Uint8Array(size.width * size.height * 4);
-  for (let y = 0; y < size.height; y++) {
-    for (let x = 0; x < size.width; x++) {
-      const to = (y * size.width + x) * 4;
-      if (y < image.height && x < image.width) {
-        const from = (y * image.width + x) * 4;
-        buffer[to] = image.data[from];
-        buffer[to + 1] = image.data[from + 1];
-        buffer[to + 2] = image.data[from + 2];
-        buffer[to + 3] = image.data[from + 3];
-      } else {
-        buffer[to] = 0;
-        buffer[to + 1] = 0;
-        buffer[to + 2] = 0;
-        buffer[to + 3] = 0;
-      }
-    }
-  }
-  return { data: Buffer.from(buffer), width: size.width, height: size.height };
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   compareBuffersOrStrings,

package/lib/server/utils/hostPlatform.js

@@ -29,7 +29,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var hostPlatform_exports = {};
 __export(hostPlatform_exports, {
   hostPlatform: () => hostPlatform,
-  isOfficiallySupportedPlatform: () => isOfficiallySupportedPlatform
+  isOfficiallySupportedPlatform: () => isOfficiallySupportedPlatform,
+  shortPlatform: () => shortPlatform
 });
 module.exports = __toCommonJS(hostPlatform_exports);
 var import_os = __toESM(require("os"));
@@ -97,15 +98,26 @@ function calculatePlatform() {
       if (distroInfo?.version === "")
         return { hostPlatform: "debian13" + archSuffix, isOfficiallySupportedPlatform: isOfficiallySupportedPlatform2 };
     }
-    return { hostPlatform: "ubuntu20.04" + archSuffix, isOfficiallySupportedPlatform: false };
+    return { hostPlatform: "ubuntu24.04" + archSuffix, isOfficiallySupportedPlatform: false };
   }
   if (platform === "win32")
     return { hostPlatform: "win64", isOfficiallySupportedPlatform: true };
   return { hostPlatform: "<unknown>", isOfficiallySupportedPlatform: false };
 }
 const { hostPlatform, isOfficiallySupportedPlatform } = calculatePlatform();
+function toShortPlatform(hostPlatform2) {
+  if (hostPlatform2 === "<unknown>")
+    return "<unknown>";
+  if (hostPlatform2 === "win64")
+    return "win-x64";
+  if (hostPlatform2.startsWith("mac"))
+    return hostPlatform2.endsWith("arm64") ? "mac-arm64" : "mac-x64";
+  return hostPlatform2.endsWith("arm64") ? "linux-arm64" : "linux-x64";
+}
+const shortPlatform = toShortPlatform(hostPlatform);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   hostPlatform,
-  isOfficiallySupportedPlatform
+  isOfficiallySupportedPlatform,
+  shortPlatform
 });