wxt 0.17.8 → 0.17.10

package/dist/testing.cjs

@@ -50,184 +50,9 @@ function normalizePath(path8) {
 var CSS_EXTENSIONS = ["css", "scss", "sass", "less", "styl", "stylus"];
 var CSS_EXTENSIONS_PATTERN = `+(${CSS_EXTENSIONS.join("|")})`;
 
-// src/core/utils/entrypoints.ts
-function getEntrypointName(entrypointsDir, inputPath) {
-  const relativePath = import_node_path2.default.relative(entrypointsDir, inputPath);
-  const name = relativePath.split(/[\.\/\\]/, 2)[0];
-  return name;
-}
-function getEntrypointOutputFile(entrypoint, ext) {
-  return (0, import_node_path2.resolve)(entrypoint.outputDir, `${entrypoint.name}${ext}`);
-}
-function getEntrypointBundlePath(entrypoint, outDir, ext) {
-  return normalizePath(
-    (0, import_node_path2.relative)(outDir, getEntrypointOutputFile(entrypoint, ext))
-  );
-}
-function isHtmlEntrypoint(entrypoint) {
-  return entrypoint.inputPath.endsWith(".html");
-}
-
 // src/core/builders/vite/plugins/devHtmlPrerender.ts
 var import_linkedom = require("linkedom");
 var import_node_path3 = require("path");
-var reactRefreshPreamble = "";
-function devHtmlPrerender(config) {
-  const htmlReloadId = "@wxt/reload-html";
-  const resolvedHtmlReloadId = (0, import_node_path3.resolve)(
-    config.wxtModuleDir,
-    "dist/virtual/reload-html.js"
-  );
-  const virtualReactRefreshId = "@wxt/virtual-react-refresh";
-  const resolvedVirtualReactRefreshId = "\0" + virtualReactRefreshId;
-  return [
-    {
-      apply: "build",
-      name: "wxt:dev-html-prerender",
-      config() {
-        return {
-          resolve: {
-            alias: {
-              [htmlReloadId]: resolvedHtmlReloadId
-            }
-          }
-        };
-      },
-      // Convert scripts like src="./main.tsx" -> src="http://localhost:3000/entrypoints/popup/main.tsx"
-      // before the paths are replaced with their bundled path
-      transform(code, id) {
-        const server = config.server;
-        if (config.command !== "serve" || server == null || !id.endsWith(".html"))
-          return;
-        const { document } = (0, import_linkedom.parseHTML)(code);
-        const _pointToDevServer = (querySelector, attr) => pointToDevServer(config, server, id, document, querySelector, attr);
-        _pointToDevServer("script[type=module]", "src");
-        _pointToDevServer("link[rel=stylesheet]", "href");
-        const reloader = document.createElement("script");
-        reloader.src = htmlReloadId;
-        reloader.type = "module";
-        document.head.appendChild(reloader);
-        const newHtml = document.toString();
-        config.logger.debug("transform " + id);
-        config.logger.debug("Old HTML:\n" + code);
-        config.logger.debug("New HTML:\n" + newHtml);
-        return newHtml;
-      },
-      // Pass the HTML through the dev server to add dev-mode specific code
-      async transformIndexHtml(html, ctx) {
-        const server = config.server;
-        if (config.command !== "serve" || server == null)
-          return;
-        const originalUrl = `${server.origin}${ctx.path}`;
-        const name = getEntrypointName(config.entrypointsDir, ctx.filename);
-        const url = `${server.origin}/${name}.html`;
-        const serverHtml = await server.transformHtml(url, html, originalUrl);
-        const { document } = (0, import_linkedom.parseHTML)(serverHtml);
-        const reactRefreshScript = Array.from(
-          document.querySelectorAll("script[type=module]")
-        ).find((script) => script.innerHTML.includes("@react-refresh"));
-        if (reactRefreshScript) {
-          reactRefreshPreamble = reactRefreshScript.innerHTML;
-          const virtualScript = document.createElement("script");
-          virtualScript.type = "module";
-          virtualScript.src = `${server.origin}/${virtualReactRefreshId}`;
-          reactRefreshScript.replaceWith(virtualScript);
-        }
-        const viteClientScript = document.querySelector(
-          "script[src='/@vite/client']"
-        );
-        if (viteClientScript) {
-          viteClientScript.src = `${server.origin}${viteClientScript.src}`;
-        }
-        const newHtml = document.toString();
-        config.logger.debug("transformIndexHtml " + ctx.filename);
-        config.logger.debug("Old HTML:\n" + html);
-        config.logger.debug("New HTML:\n" + newHtml);
-        return newHtml;
-      }
-    },
-    {
-      name: "wxt:virtualize-react-refresh",
-      apply: "serve",
-      resolveId(id) {
-        if (id === `/${virtualReactRefreshId}`) {
-          return resolvedVirtualReactRefreshId;
-        }
-        if (id.startsWith("/chunks/")) {
-          return "\0noop";
-        }
-      },
-      load(id) {
-        if (id === resolvedVirtualReactRefreshId) {
-          return reactRefreshPreamble;
-        }
-        if (id === "\0noop") {
-          return "";
-        }
-      }
-    }
-  ];
-}
-function pointToDevServer(config, server, id, document, querySelector, attr) {
-  document.querySelectorAll(querySelector).forEach((element) => {
-    const src = element.getAttribute(attr);
-    if (!src || isUrl(src))
-      return;
-    let resolvedAbsolutePath;
-    const matchingAlias = Object.entries(config.alias).find(
-      ([key]) => src.startsWith(key)
-    );
-    if (matchingAlias) {
-      const [alias, replacement] = matchingAlias;
-      resolvedAbsolutePath = (0, import_node_path3.resolve)(
-        config.root,
-        src.replace(alias, replacement)
-      );
-    } else {
-      resolvedAbsolutePath = (0, import_node_path3.resolve)((0, import_node_path3.dirname)(id), src);
-    }
-    if (resolvedAbsolutePath) {
-      const relativePath = normalizePath(
-        (0, import_node_path3.relative)(config.root, resolvedAbsolutePath)
-      );
-      if (relativePath.startsWith(".")) {
-        let path8 = normalizePath(resolvedAbsolutePath);
-        if (!path8.startsWith("/"))
-          path8 = "/" + path8;
-        element.setAttribute(attr, `${server.origin}/@fs${path8}`);
-      } else {
-        const url = new URL(relativePath, server.origin);
-        element.setAttribute(attr, url.href);
-      }
-    }
-  });
-}
-function isUrl(str) {
-  try {
-    new URL(str);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/core/builders/vite/plugins/devServerGlobals.ts
-function devServerGlobals(config) {
-  return {
-    name: "wxt:dev-server-globals",
-    config() {
-      if (config.server == null || config.command == "build")
-        return;
-      return {
-        define: {
-          __DEV_SERVER_PROTOCOL__: JSON.stringify("ws:"),
-          __DEV_SERVER_HOSTNAME__: JSON.stringify(config.server.hostname),
-          __DEV_SERVER_PORT__: JSON.stringify(config.server.port)
-        }
-      };
-    }
-  };
-}
 
 // src/core/utils/network.ts
 var import_node_dns = __toESM(require("dns"), 1);
@@ -301,61 +126,6 @@ function download(config) {
 // src/core/builders/vite/plugins/multipageMove.ts
 var import_node_path4 = require("path");
 var import_fs_extra = __toESM(require("fs-extra"), 1);
-function multipageMove(entrypoints, config) {
-  return {
-    name: "wxt:multipage-move",
-    async writeBundle(_, bundle) {
-      for (const oldBundlePath in bundle) {
-        const entrypoint = entrypoints.find(
-          (entry) => !!normalizePath(entry.inputPath).endsWith(oldBundlePath)
-        );
-        if (entrypoint == null) {
-          config.logger.debug(
-            `No entrypoint found for ${oldBundlePath}, leaving in chunks directory`
-          );
-          continue;
-        }
-        const newBundlePath = getEntrypointBundlePath(
-          entrypoint,
-          config.outDir,
-          (0, import_node_path4.extname)(oldBundlePath)
-        );
-        if (newBundlePath === oldBundlePath) {
-          config.logger.debug(
-            "HTML file is already in the correct location",
-            oldBundlePath
-          );
-          continue;
-        }
-        const oldAbsPath = (0, import_node_path4.resolve)(config.outDir, oldBundlePath);
-        const newAbsPath = (0, import_node_path4.resolve)(config.outDir, newBundlePath);
-        await (0, import_fs_extra.ensureDir)((0, import_node_path4.dirname)(newAbsPath));
-        await import_fs_extra.default.move(oldAbsPath, newAbsPath, { overwrite: true });
-        const renamedChunk = {
-          ...bundle[oldBundlePath],
-          fileName: newBundlePath
-        };
-        delete bundle[oldBundlePath];
-        bundle[newBundlePath] = renamedChunk;
-      }
-      removeEmptyDirs(config.outDir);
-    }
-  };
-}
-async function removeEmptyDirs(dir) {
-  const files = await import_fs_extra.default.readdir(dir);
-  for (const file of files) {
-    const filePath = (0, import_node_path4.join)(dir, file);
-    const stats = await import_fs_extra.default.stat(filePath);
-    if (stats.isDirectory()) {
-      await removeEmptyDirs(filePath);
-    }
-  }
-  try {
-    await import_fs_extra.default.rmdir(dir);
-  } catch {
-  }
-}
 
 // src/core/builders/vite/plugins/unimport.ts
 var import_unimport = require("unimport");
@@ -394,31 +164,6 @@ function unimport(config) {
 
 // src/core/builders/vite/plugins/virtualEntrypoint.ts
 var import_fs_extra2 = __toESM(require("fs-extra"), 1);
-var import_path2 = require("path");
-function virtualEntrypoint(type, config) {
-  const virtualId = `virtual:wxt-${type}?`;
-  const resolvedVirtualId = `\0${virtualId}`;
-  return {
-    name: `wxt:virtual-entrypoint`,
-    resolveId(id) {
-      const index = id.indexOf(virtualId);
-      if (index === -1)
-        return;
-      const inputPath = normalizePath(id.substring(index + virtualId.length));
-      return resolvedVirtualId + inputPath;
-    },
-    async load(id) {
-      if (!id.startsWith(resolvedVirtualId))
-        return;
-      const inputPath = id.replace(resolvedVirtualId, "");
-      const template = await import_fs_extra2.default.readFile(
-        (0, import_path2.resolve)(config.wxtModuleDir, `dist/virtual/${type}-entrypoint.js`),
-        "utf-8"
-      );
-      return template.replace(`virtual:user-${type}`, inputPath);
-    }
-  };
-}
 
 // src/core/builders/vite/plugins/tsconfigPaths.ts
 function tsconfigPaths(config) {
@@ -437,62 +182,9 @@ function tsconfigPaths(config) {
 // src/core/utils/constants.ts
 var VIRTUAL_NOOP_BACKGROUND_MODULE_ID = "virtual:user-background";
 
-// src/core/builders/vite/plugins/noopBackground.ts
-function noopBackground() {
-  const virtualModuleId = VIRTUAL_NOOP_BACKGROUND_MODULE_ID;
-  const resolvedVirtualModuleId = "\0" + virtualModuleId;
-  return {
-    name: "wxt:noop-background",
-    resolveId(id) {
-      if (id === virtualModuleId)
-        return resolvedVirtualModuleId;
-    },
-    load(id) {
-      if (id === resolvedVirtualModuleId) {
-        return `import { defineBackground } from 'wxt/sandbox';
-export default defineBackground(() => void 0)`;
-      }
-    }
-  };
-}
-
-// src/core/builders/vite/plugins/cssEntrypoints.ts
-function cssEntrypoints(entrypoint, config) {
-  return {
-    name: "wxt:css-entrypoint",
-    config() {
-      return {
-        build: {
-          rollupOptions: {
-            output: {
-              assetFileNames: () => getEntrypointBundlePath(entrypoint, config.outDir, ".css")
-            }
-          }
-        }
-      };
-    },
-    generateBundle(_, bundle) {
-      Object.keys(bundle).forEach((file) => {
-        if (file.endsWith(".js"))
-          delete bundle[file];
-      });
-    }
-  };
-}
-
 // src/core/builders/vite/plugins/bundleAnalysis.ts
 var import_rollup_plugin_visualizer = require("@aklinker1/rollup-plugin-visualizer");
 var import_node_path5 = __toESM(require("path"), 1);
-var increment = 0;
-function bundleAnalysis(config) {
-  return (0, import_rollup_plugin_visualizer.visualizer)({
-    template: "raw-data",
-    filename: import_node_path5.default.resolve(
-      config.analysis.outputDir,
-      `${config.analysis.outputName}-${increment++}.json`
-    )
-  });
-}
 
 // src/core/utils/globals.ts
 function getGlobals(config) {
@@ -539,15 +231,6 @@ function getGlobals(config) {
     }
   ];
 }
-function getEntrypointGlobals(entrypointName) {
-  return [
-    {
-      name: "ENTRYPOINT",
-      value: entrypointName,
-      type: `string`
-    }
-  ];
-}
 
 // src/core/builders/vite/plugins/globals.ts
 function globals(config) {
@@ -590,62 +273,6 @@ function webextensionPolyfillMock(config) {
   };
 }
 
-// src/core/builders/vite/plugins/excludeBrowserPolyfill.ts
-function excludeBrowserPolyfill(config) {
-  const virtualId = "virtual:wxt-webextension-polyfill-disabled";
-  return {
-    name: "wxt:exclude-browser-polyfill",
-    config() {
-      if (config.experimental.includeBrowserPolyfill)
-        return;
-      return {
-        resolve: {
-          alias: {
-            "webextension-polyfill": virtualId
-          }
-        }
-      };
-    },
-    load(id) {
-      if (id === virtualId) {
-        return "export default chrome";
-      }
-    }
-  };
-}
-
-// src/core/builders/vite/plugins/entrypointGroupGlobals.ts
-function entrypointGroupGlobals(entrypointGroup) {
-  return {
-    name: "wxt:entrypoint-group-globals",
-    config() {
-      const define = {};
-      let name = Array.isArray(entrypointGroup) ? "html" : entrypointGroup.name;
-      for (const global of getEntrypointGlobals(name)) {
-        define[`import.meta.env.${global.name}`] = JSON.stringify(global.value);
-      }
-      return {
-        define
-      };
-    }
-  };
-}
-
-// src/core/builders/vite/plugins/defineImportMeta.ts
-function defineImportMeta() {
-  return {
-    name: "wxt:define",
-    config() {
-      return {
-        define: {
-          // This works for all extension contexts, including background service worker
-          "import.meta.url": "self.location.href"
-        }
-      };
-    }
-  };
-}
-
 // src/core/utils/fs.ts
 var import_fs_extra4 = __toESM(require("fs-extra"), 1);
 var import_fast_glob = __toESM(require("fast-glob"), 1);
@@ -730,13 +357,13 @@ var import_node_path10 = __toESM(require("path"), 1);
 
 // src/core/utils/cache.ts
 var import_fs_extra8 = __toESM(require("fs-extra"), 1);
-var import_path3 = require("path");
+var import_path2 = require("path");
 function createFsCache(wxtDir) {
-  const getPath = (key) => (0, import_path3.resolve)(wxtDir, "cache", encodeURIComponent(key));
+  const getPath = (key) => (0, import_path2.resolve)(wxtDir, "cache", encodeURIComponent(key));
   return {
     async set(key, value) {
       const path8 = getPath(key);
-      await (0, import_fs_extra8.ensureDir)((0, import_path3.dirname)(path8));
+      await (0, import_fs_extra8.ensureDir)((0, import_path2.dirname)(path8));
       await writeFileIfDifferent(path8, value);
     },
     async get(key) {
@@ -752,227 +379,6 @@ function createFsCache(wxtDir) {
 
 // src/core/utils/building/resolve-config.ts
 var import_consola = __toESM(require("consola"), 1);
-
-// src/core/builders/vite/index.ts
-async function createViteBuilder(inlineConfig, userConfig, wxtConfig) {
-  const vite = await import("vite");
-  const getBaseConfig = async () => {
-    const resolvedInlineConfig = await inlineConfig.vite?.(wxtConfig.env) ?? {};
-    const resolvedUserConfig = await userConfig.vite?.(wxtConfig.env) ?? {};
-    const config = vite.mergeConfig(
-      resolvedUserConfig,
-      resolvedInlineConfig
-    );
-    config.root = wxtConfig.root;
-    config.configFile = false;
-    config.logLevel = "warn";
-    config.mode = wxtConfig.mode;
-    config.build ??= {};
-    config.build.outDir = wxtConfig.outDir;
-    config.build.emptyOutDir = false;
-    if (config.build.minify == null && wxtConfig.command === "serve") {
-      config.build.minify = false;
-    }
-    if (config.build.sourcemap == null && wxtConfig.command === "serve") {
-      config.build.sourcemap = "inline";
-    }
-    config.plugins ??= [];
-    config.plugins.push(
-      download(wxtConfig),
-      devHtmlPrerender(wxtConfig),
-      unimport(wxtConfig),
-      virtualEntrypoint("background", wxtConfig),
-      virtualEntrypoint("content-script-isolated-world", wxtConfig),
-      virtualEntrypoint("content-script-main-world", wxtConfig),
-      virtualEntrypoint("unlisted-script", wxtConfig),
-      devServerGlobals(wxtConfig),
-      tsconfigPaths(wxtConfig),
-      noopBackground(),
-      globals(wxtConfig),
-      excludeBrowserPolyfill(wxtConfig),
-      defineImportMeta()
-    );
-    if (wxtConfig.analysis.enabled) {
-      config.plugins.push(bundleAnalysis(wxtConfig));
-    }
-    return config;
-  };
-  const getLibModeConfig = (entrypoint) => {
-    const entry = getRollupEntry(entrypoint);
-    const plugins = [
-      entrypointGroupGlobals(entrypoint)
-    ];
-    if (entrypoint.type === "content-script-style" || entrypoint.type === "unlisted-style") {
-      plugins.push(cssEntrypoints(entrypoint, wxtConfig));
-    }
-    const libMode = {
-      mode: wxtConfig.mode,
-      plugins,
-      build: {
-        lib: {
-          entry,
-          formats: ["iife"],
-          name: "_",
-          fileName: entrypoint.name
-        },
-        rollupOptions: {
-          output: {
-            // There's only a single output for this build, so we use the desired bundle path for the
-            // entry output (like "content-scripts/overlay.js")
-            entryFileNames: getEntrypointBundlePath(
-              entrypoint,
-              wxtConfig.outDir,
-              ".js"
-            ),
-            // Output content script CSS to `content-scripts/`, but all other scripts are written to
-            // `assets/`.
-            assetFileNames: ({ name }) => {
-              if (entrypoint.type === "content-script" && name?.endsWith("css")) {
-                return `content-scripts/${entrypoint.name}.[ext]`;
-              } else {
-                return `assets/${entrypoint.name}.[ext]`;
-              }
-            }
-          }
-        }
-      },
-      define: {
-        // See https://github.com/aklinker1/vite-plugin-web-extension/issues/96
-        "process.env.NODE_ENV": JSON.stringify(wxtConfig.mode)
-      }
-    };
-    return libMode;
-  };
-  const getMultiPageConfig = (entrypoints) => {
-    const htmlEntrypoints = new Set(
-      entrypoints.filter(isHtmlEntrypoint).map((e) => e.name)
-    );
-    return {
-      mode: wxtConfig.mode,
-      plugins: [
-        multipageMove(entrypoints, wxtConfig),
-        entrypointGroupGlobals(entrypoints)
-      ],
-      build: {
-        rollupOptions: {
-          input: entrypoints.reduce((input, entry) => {
-            input[entry.name] = getRollupEntry(entry);
-            return input;
-          }, {}),
-          output: {
-            // Include a hash to prevent conflicts
-            chunkFileNames: "chunks/[name]-[hash].js",
-            entryFileNames: ({ name }) => {
-              if (htmlEntrypoints.has(name))
-                return "chunks/[name]-[hash].js";
-              return "[name].js";
-            },
-            // We can't control the "name", so we need a hash to prevent conflicts
-            assetFileNames: "assets/[name]-[hash].[ext]"
-          }
-        }
-      }
-    };
-  };
-  const getCssConfig = (entrypoint) => {
-    return {
-      mode: wxtConfig.mode,
-      plugins: [entrypointGroupGlobals(entrypoint)],
-      build: {
-        rollupOptions: {
-          input: {
-            [entrypoint.name]: entrypoint.inputPath
-          },
-          output: {
-            assetFileNames: () => {
-              if (entrypoint.type === "content-script-style") {
-                return `content-scripts/${entrypoint.name}.[ext]`;
-              } else {
-                return `assets/${entrypoint.name}.[ext]`;
-              }
-            }
-          }
-        }
-      }
-    };
-  };
-  return {
-    name: "Vite",
-    version: vite.version,
-    async build(group) {
-      let entryConfig;
-      if (Array.isArray(group))
-        entryConfig = getMultiPageConfig(group);
-      else if (group.inputPath.endsWith(".css"))
-        entryConfig = getCssConfig(group);
-      else
-        entryConfig = getLibModeConfig(group);
-      const buildConfig = vite.mergeConfig(await getBaseConfig(), entryConfig);
-      const result = await vite.build(buildConfig);
-      return {
-        entrypoints: group,
-        chunks: getBuildOutputChunks(result)
-      };
-    },
-    async createServer(info) {
-      const serverConfig = {
-        server: {
-          port: info.port,
-          strictPort: true,
-          host: info.hostname,
-          origin: info.origin
-        }
-      };
-      const baseConfig = await getBaseConfig();
-      const viteServer = await vite.createServer(
-        vite.mergeConfig(baseConfig, serverConfig)
-      );
-      const server = {
-        async listen() {
-          await viteServer.listen(info.port);
-        },
-        async close() {
-          await viteServer.close();
-        },
-        transformHtml(...args) {
-          return viteServer.transformIndexHtml(...args);
-        },
-        ws: {
-          send(message, payload) {
-            return viteServer.ws.send(message, payload);
-          },
-          on(message, cb) {
-            viteServer.ws.on(message, cb);
-          }
-        },
-        watcher: viteServer.watcher
-      };
-      return server;
-    }
-  };
-}
-function getBuildOutputChunks(result) {
-  if ("on" in result)
-    throw Error("wxt does not support vite watch mode.");
-  if (Array.isArray(result))
-    return result.flatMap(({ output }) => output);
-  return result.output;
-}
-function getRollupEntry(entrypoint) {
-  let virtualEntrypointType;
-  switch (entrypoint.type) {
-    case "background":
-    case "unlisted-script":
-      virtualEntrypointType = entrypoint.type;
-      break;
-    case "content-script":
-      virtualEntrypointType = entrypoint.options.world === "MAIN" ? "content-script-main-world" : "content-script-isolated-world";
-      break;
-  }
-  return virtualEntrypointType ? `virtual:wxt-${virtualEntrypointType}?${entrypoint.inputPath}` : entrypoint.inputPath;
-}
-
-// src/core/utils/building/resolve-config.ts
 var import_defu = __toESM(require("defu"), 1);
 
 // src/core/utils/package.ts
@@ -985,7 +391,7 @@ function isModuleInstalled(name) {
 // src/core/utils/building/resolve-config.ts
 var import_fs_extra10 = __toESM(require("fs-extra"), 1);
 var import_meta = {};
-async function resolveConfig(inlineConfig, command, server) {
+async function resolveConfig(inlineConfig, command) {
   let userConfig = {};
   let userConfigMetadata;
   if (inlineConfig.configFile !== false) {
@@ -1001,14 +407,14 @@ async function resolveConfig(inlineConfig, command, server) {
     userConfig = loadedConfig ?? {};
     userConfigMetadata = metadata;
   }
-  const mergedConfig = mergeInlineConfig(inlineConfig, userConfig);
+  const mergedConfig = await mergeInlineConfig(inlineConfig, userConfig);
   const debug = mergedConfig.debug ?? false;
   const logger = mergedConfig.logger ?? import_consola.default;
   if (debug)
     logger.level = import_consola.LogLevels.debug;
   const browser = mergedConfig.browser ?? "chrome";
   const manifestVersion = mergedConfig.manifestVersion ?? (browser === "firefox" || browser === "safari" ? 2 : 3);
-  const mode = mergedConfig.mode ?? (command === "build" ? "production" : "development");
+  const mode = mergedConfig.mode ?? COMMAND_MODES[command];
   const env = { browser, command, manifestVersion, mode };
   const root = import_node_path10.default.resolve(
     inlineConfig.root ?? userConfig.root ?? process.cwd()
@@ -1049,13 +455,19 @@ async function resolveConfig(inlineConfig, command, server) {
       "~~": root
     }).map(([key, value]) => [key, import_node_path10.default.resolve(root, value)])
   );
-  const analysisOutputFile = import_node_path10.default.resolve(
-    root,
-    mergedConfig.analysis?.outputFile ?? "stats.html"
-  );
-  const analysisOutputDir = import_node_path10.default.dirname(analysisOutputFile);
-  const analysisOutputName = import_node_path10.default.parse(analysisOutputFile).name;
-  const finalConfig = {
+  let devServerConfig;
+  if (command === "serve") {
+    let port = mergedConfig.dev?.server?.port;
+    if (port == null || !isFinite(port)) {
+      const { default: getPort, portNumbers } = await import("get-port");
+      port = await getPort({ port: portNumbers(3e3, 3010) });
+    }
+    devServerConfig = {
+      port,
+      hostname: "localhost"
+    };
+  }
+  return {
     browser,
     command,
     debug,
@@ -1077,109 +489,47 @@ async function resolveConfig(inlineConfig, command, server) {
     srcDir,
     typesDir,
     wxtDir,
-    zip: resolveInternalZipConfig(root, mergedConfig),
-    transformManifest(manifest) {
-      userConfig.transformManifest?.(manifest);
-      inlineConfig.transformManifest?.(manifest);
-    },
-    analysis: {
-      enabled: mergedConfig.analysis?.enabled ?? false,
-      open: mergedConfig.analysis?.open ?? false,
-      template: mergedConfig.analysis?.template ?? "treemap",
-      outputFile: analysisOutputFile,
-      outputDir: analysisOutputDir,
-      outputName: analysisOutputName,
-      keepArtifacts: mergedConfig.analysis?.keepArtifacts ?? false
-    },
+    zip: resolveZipConfig(root, mergedConfig),
+    transformManifest: mergedConfig.transformManifest,
+    analysis: resolveAnalysisConfig(root, mergedConfig),
     userConfigMetadata: userConfigMetadata ?? {},
     alias,
-    experimental: {
-      includeBrowserPolyfill: mergedConfig.experimental?.includeBrowserPolyfill ?? true
-    },
-    server,
+    experimental: (0, import_defu.default)(mergedConfig.experimental, {
+      includeBrowserPolyfill: true
+    }),
     dev: {
+      server: devServerConfig,
       reloadCommand
     },
-    hooks: mergedConfig.hooks ?? {}
-  };
-  const builder = await createViteBuilder(
-    inlineConfig,
-    userConfig,
-    finalConfig
-  );
-  return {
-    ...finalConfig,
-    builder
+    hooks: mergedConfig.hooks ?? {},
+    vite: mergedConfig.vite ?? (() => ({}))
   };
 }
 async function resolveManifestConfig(env, manifest) {
   return await (typeof manifest === "function" ? manifest(env) : manifest ?? {});
 }
-function mergeInlineConfig(inlineConfig, userConfig) {
-  let imports;
-  if (inlineConfig.imports === false || userConfig.imports === false) {
-    imports = false;
-  } else if (userConfig.imports == null && inlineConfig.imports == null) {
-    imports = void 0;
-  } else {
-    imports = (0, import_defu.default)(inlineConfig.imports ?? {}, userConfig.imports ?? {});
-  }
+async function mergeInlineConfig(inlineConfig, userConfig) {
+  const imports = inlineConfig.imports === false || userConfig.imports === false ? false : userConfig.imports == null && inlineConfig.imports == null ? void 0 : (0, import_defu.default)(inlineConfig.imports ?? {}, userConfig.imports ?? {});
   const manifest = async (env) => {
     const user = await resolveManifestConfig(env, userConfig.manifest);
     const inline = await resolveManifestConfig(env, inlineConfig.manifest);
     return (0, import_defu.default)(inline, user);
   };
-  const runner = (0, import_defu.default)(
-    inlineConfig.runner ?? {},
-    userConfig.runner ?? {}
-  );
-  const zip = (0, import_defu.default)(
-    inlineConfig.zip ?? {},
-    userConfig.zip ?? {}
-  );
-  const hooks = (0, import_defu.default)(
-    inlineConfig.hooks ?? {},
-    userConfig.hooks ?? {}
-  );
+  const transformManifest = (manifest2) => {
+    userConfig.transformManifest?.(manifest2);
+    inlineConfig.transformManifest?.(manifest2);
+  };
+  const builderConfig = await mergeBuilderConfig(inlineConfig, userConfig);
   return {
-    root: inlineConfig.root ?? userConfig.root,
-    browser: inlineConfig.browser ?? userConfig.browser,
-    manifestVersion: inlineConfig.manifestVersion ?? userConfig.manifestVersion,
-    configFile: inlineConfig.configFile,
-    debug: inlineConfig.debug ?? userConfig.debug,
-    entrypointsDir: inlineConfig.entrypointsDir ?? userConfig.entrypointsDir,
-    filterEntrypoints: inlineConfig.filterEntrypoints ?? userConfig.filterEntrypoints,
+    ...(0, import_defu.default)(inlineConfig, userConfig),
+    // Custom merge values
+    transformManifest,
     imports,
-    logger: inlineConfig.logger ?? userConfig.logger,
     manifest,
-    mode: inlineConfig.mode ?? userConfig.mode,
-    publicDir: inlineConfig.publicDir ?? userConfig.publicDir,
-    runner,
-    srcDir: inlineConfig.srcDir ?? userConfig.srcDir,
-    outDir: inlineConfig.outDir ?? userConfig.outDir,
-    zip,
-    analysis: {
-      ...userConfig.analysis,
-      ...inlineConfig.analysis
-    },
-    alias: {
-      ...userConfig.alias,
-      ...inlineConfig.alias
-    },
-    experimental: {
-      ...userConfig.experimental,
-      ...inlineConfig.experimental
-    },
-    vite: void 0,
-    transformManifest: void 0,
-    dev: {
-      ...userConfig.dev,
-      ...inlineConfig.dev
-    },
-    hooks
+    ...builderConfig
   };
 }
-function resolveInternalZipConfig(root, mergedConfig) {
+function resolveZipConfig(root, mergedConfig) {
   const downloadedPackagesDir = import_node_path10.default.resolve(root, ".wxt/local_modules");
   return {
     name: void 0,
@@ -1204,6 +554,23 @@ function resolveInternalZipConfig(root, mergedConfig) {
     downloadedPackagesDir
   };
 }
+function resolveAnalysisConfig(root, mergedConfig) {
+  const analysisOutputFile = import_node_path10.default.resolve(
+    root,
+    mergedConfig.analysis?.outputFile ?? "stats.html"
+  );
+  const analysisOutputDir = import_node_path10.default.dirname(analysisOutputFile);
+  const analysisOutputName = import_node_path10.default.parse(analysisOutputFile).name;
+  return {
+    enabled: mergedConfig.analysis?.enabled ?? false,
+    open: mergedConfig.analysis?.open ?? false,
+    template: mergedConfig.analysis?.template ?? "treemap",
+    outputFile: analysisOutputFile,
+    outputDir: analysisOutputDir,
+    outputName: analysisOutputName,
+    keepArtifacts: mergedConfig.analysis?.keepArtifacts ?? false
+  };
+}
 async function getUnimportOptions(wxtDir, logger, config) {
   if (config.imports === false)
     return false;
@@ -1256,6 +623,23 @@ function logMissingDir(logger, name, expected) {
     )}`
   );
 }
+var COMMAND_MODES = {
+  build: "production",
+  serve: "development"
+};
+async function mergeBuilderConfig(inlineConfig, userConfig) {
+  const vite = await import("vite").catch(() => void 0);
+  if (vite) {
+    return {
+      vite: async (env) => {
+        const resolvedInlineConfig = await inlineConfig.vite?.(env) ?? {};
+        const resolvedUserConfig = await userConfig.vite?.(env) ?? {};
+        return vite.mergeConfig(resolvedUserConfig, resolvedInlineConfig);
+      }
+    };
+  }
+  throw Error("Builder not found. Make sure vite is installed.");
+}
 
 // src/core/utils/building/import-entrypoint.ts
 var import_jiti = __toESM(require("jiti"), 1);