wxt 0.10.3 → 0.11.0

package/dist/index.cjs

@@ -40,7 +40,7 @@ var require_windows = __commonJS({
     module2.exports = isexe;
     isexe.sync = sync;
     var fs16 = require("fs");
-    function checkPathExt(path11, options) {
+    function checkPathExt(path10, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
         return true;
@@ -51,25 +51,25 @@ var require_windows = __commonJS({
       }
       for (var i = 0; i < pathext.length; i++) {
         var p = pathext[i].toLowerCase();
-        if (p && path11.substr(-p.length).toLowerCase() === p) {
+        if (p && path10.substr(-p.length).toLowerCase() === p) {
           return true;
         }
       }
       return false;
     }
-    function checkStat(stat, path11, options) {
+    function checkStat(stat, path10, options) {
       if (!stat.isSymbolicLink() && !stat.isFile()) {
         return false;
       }
-      return checkPathExt(path11, options);
+      return checkPathExt(path10, options);
     }
-    function isexe(path11, options, cb) {
-      fs16.stat(path11, function(er, stat) {
-        cb(er, er ? false : checkStat(stat, path11, options));
+    function isexe(path10, options, cb) {
+      fs16.stat(path10, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, path10, options));
       });
     }
-    function sync(path11, options) {
-      return checkStat(fs16.statSync(path11), path11, options);
+    function sync(path10, options) {
+      return checkStat(fs16.statSync(path10), path10, options);
     }
   }
 });
@@ -81,13 +81,13 @@ var require_mode = __commonJS({
     module2.exports = isexe;
     isexe.sync = sync;
     var fs16 = require("fs");
-    function isexe(path11, options, cb) {
-      fs16.stat(path11, function(er, stat) {
+    function isexe(path10, options, cb) {
+      fs16.stat(path10, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
-    function sync(path11, options) {
-      return checkStat(fs16.statSync(path11), options);
+    function sync(path10, options) {
+      return checkStat(fs16.statSync(path10), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -121,7 +121,7 @@ var require_isexe = __commonJS({
     }
     module2.exports = isexe;
     isexe.sync = sync;
-    function isexe(path11, options, cb) {
+    function isexe(path10, options, cb) {
       if (typeof options === "function") {
         cb = options;
         options = {};
@@ -131,7 +131,7 @@ var require_isexe = __commonJS({
           throw new TypeError("callback not provided");
         }
         return new Promise(function(resolve14, reject) {
-          isexe(path11, options || {}, function(er, is) {
+          isexe(path10, options || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
@@ -140,7 +140,7 @@ var require_isexe = __commonJS({
           });
         });
       }
-      core(path11, options || {}, function(er, is) {
+      core(path10, options || {}, function(er, is) {
         if (er) {
           if (er.code === "EACCES" || options && options.ignoreErrors) {
             er = null;
@@ -150,9 +150,9 @@ var require_isexe = __commonJS({
         cb(er, is);
       });
     }
-    function sync(path11, options) {
+    function sync(path10, options) {
       try {
-        return core.sync(path11, options || {});
+        return core.sync(path10, options || {});
       } catch (er) {
         if (options && options.ignoreErrors || er.code === "EACCES") {
           return false;
@@ -169,7 +169,7 @@ var require_which = __commonJS({
   "node_modules/.pnpm/which@2.0.2/node_modules/which/which.js"(exports, module2) {
     "use strict";
     var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-    var path11 = require("path");
+    var path10 = require("path");
     var COLON = isWindows ? ";" : ":";
     var isexe = require_isexe();
     var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
@@ -207,7 +207,7 @@ var require_which = __commonJS({
           return opt.all && found.length ? resolve14(found) : reject(getNotFoundError(cmd));
         const ppRaw = pathEnv[i];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path11.join(pathPart, cmd);
+        const pCmd = path10.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         resolve14(subStep(p, i, 0));
       });
@@ -234,7 +234,7 @@ var require_which = __commonJS({
       for (let i = 0; i < pathEnv.length; i++) {
         const ppRaw = pathEnv[i];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path11.join(pathPart, cmd);
+        const pCmd = path10.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         for (let j = 0; j < pathExt.length; j++) {
           const cur = p + pathExt[j];
@@ -282,7 +282,7 @@ var require_path_key = __commonJS({
 var require_resolveCommand = __commonJS({
   "node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/util/resolveCommand.js"(exports, module2) {
     "use strict";
-    var path11 = require("path");
+    var path10 = require("path");
     var which = require_which();
     var getPathKey = require_path_key();
     function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -300,7 +300,7 @@ var require_resolveCommand = __commonJS({
       try {
         resolved = which.sync(parsed.command, {
           path: env[getPathKey({ env })],
-          pathExt: withoutPathExt ? path11.delimiter : void 0
+          pathExt: withoutPathExt ? path10.delimiter : void 0
         });
       } catch (e) {
       } finally {
@@ -309,7 +309,7 @@ var require_resolveCommand = __commonJS({
         }
       }
       if (resolved) {
-        resolved = path11.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+        resolved = path10.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
       }
       return resolved;
     }
@@ -363,8 +363,8 @@ var require_shebang_command = __commonJS({
       if (!match) {
         return null;
       }
-      const [path11, argument] = match[0].replace(/#! ?/, "").split(" ");
-      const binary = path11.split("/").pop();
+      const [path10, argument] = match[0].replace(/#! ?/, "").split(" ");
+      const binary = path10.split("/").pop();
       if (binary === "env") {
         return argument;
       }
@@ -399,7 +399,7 @@ var require_readShebang = __commonJS({
 var require_parse = __commonJS({
   "node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/parse.js"(exports, module2) {
     "use strict";
-    var path11 = require("path");
+    var path10 = require("path");
     var resolveCommand = require_resolveCommand();
     var escape = require_escape();
     var readShebang = require_readShebang();
@@ -424,7 +424,7 @@ var require_parse = __commonJS({
       const needsShell = !isExecutableRegExp.test(commandFile);
       if (parsed.options.forceShell || needsShell) {
         const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-        parsed.command = path11.normalize(parsed.command);
+        parsed.command = path10.normalize(parsed.command);
         parsed.command = escape.command(parsed.command);
         parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
         const shellCommand = [parsed.command].concat(parsed.args).join(" ");
@@ -590,9 +590,9 @@ function npmRunPath(options = {}) {
 }
 function npmRunPathEnv({ env = import_node_process.default.env, ...options } = {}) {
   env = { ...env };
-  const path11 = pathKey({ env });
-  options.path = env[path11];
-  env[path11] = npmRunPath(options);
+  const path10 = pathKey({ env });
+  options.path = env[path10];
+  env[path10] = npmRunPath(options);
   return env;
 }
 var import_node_process, import_node_path10, import_node_url;
@@ -2001,8 +2001,8 @@ var nativePromisePrototype, descriptors, mergePromise, getSpawnedPromise;
 var init_promise = __esm({
   "node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/promise.js"() {
     "use strict";
-    nativePromisePrototype = (/* @__PURE__ */ (async () => {
-    })()).constructor.prototype;
+    nativePromisePrototype = (async () => {
+    })().constructor.prototype;
     descriptors = ["then", "catch", "finally"].map((property) => [
       property,
       Reflect.getOwnPropertyDescriptor(nativePromisePrototype, property)
@@ -2415,9 +2415,9 @@ var init_execa = __esm({
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  build: () => build2,
+  build: () => build,
   clean: () => clean,
-  createServer: () => createServer2,
+  createServer: () => createServer,
   defineConfig: () => defineConfig,
   defineRunnerConfig: () => defineRunnerConfig,
   initialize: () => initialize,
@@ -2427,25 +2427,171 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/core/utils/building/build-entrypoints.ts
-var vite = __toESM(require("vite"), 1);
-
-// src/core/utils/entrypoints.ts
-var import_node_path2 = __toESM(require("path"), 1);
+// src/core/utils/fs.ts
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_fast_glob = __toESM(require("fast-glob"), 1);
 
 // src/core/utils/paths.ts
 var import_node_path = __toESM(require("path"), 1);
 var import_normalize_path = __toESM(require("normalize-path"), 1);
-function normalizePath(path11) {
-  return (0, import_normalize_path.default)(path11);
+function normalizePath(path10) {
+  return (0, import_normalize_path.default)(path10);
 }
-function unnormalizePath(path11) {
-  return import_node_path.default.normalize(path11);
+function unnormalizePath(path10) {
+  return import_node_path.default.normalize(path10);
 }
 var CSS_EXTENSIONS = ["css", "scss", "sass", "less", "styl", "stylus"];
 var CSS_EXTENSIONS_PATTERN = `+(${CSS_EXTENSIONS.join("|")})`;
 
+// src/core/utils/fs.ts
+async function writeFileIfDifferent(file, newContents) {
+  const existingContents = await import_fs_extra.default.readFile(file, "utf-8").catch(() => void 0);
+  if (existingContents !== newContents) {
+    await import_fs_extra.default.writeFile(file, newContents);
+  }
+}
+async function getPublicFiles(config) {
+  if (!await import_fs_extra.default.exists(config.publicDir))
+    return [];
+  const files = await (0, import_fast_glob.default)("**/*", { cwd: config.publicDir });
+  return files.map(unnormalizePath);
+}
+
+// src/core/utils/building/build-entrypoints.ts
+var import_fs_extra2 = __toESM(require("fs-extra"), 1);
+var import_path = require("path");
+var import_picocolors = __toESM(require("picocolors"), 1);
+async function buildEntrypoints(groups, config, spinner) {
+  const steps = [];
+  for (let i = 0; i < groups.length; i++) {
+    const group = groups[i];
+    const groupNames = [group].flat().map((e) => e.name).join(import_picocolors.default.dim(", "));
+    spinner.text = import_picocolors.default.dim(`[${i + 1}/${groups.length}]`) + ` ${groupNames}`;
+    steps.push(await config.builder.build(group));
+  }
+  const publicAssets = await copyPublicDirectory(config);
+  return { publicAssets, steps };
+}
+async function copyPublicDirectory(config) {
+  const files = await getPublicFiles(config);
+  if (files.length === 0)
+    return [];
+  const publicAssets = [];
+  for (const file of files) {
+    const srcPath = (0, import_path.resolve)(config.publicDir, file);
+    const outPath = (0, import_path.resolve)(config.outDir, file);
+    await import_fs_extra2.default.ensureDir((0, import_path.dirname)(outPath));
+    await import_fs_extra2.default.copyFile(srcPath, outPath);
+    publicAssets.push({
+      type: "asset",
+      fileName: file
+    });
+  }
+  return publicAssets;
+}
+
+// src/core/utils/arrays.ts
+function every(array, predicate) {
+  for (let i = 0; i < array.length; i++)
+    if (!predicate(array[i], i))
+      return false;
+  return true;
+}
+
+// src/core/utils/building/detect-dev-changes.ts
+function detectDevChanges(changedFiles, currentOutput) {
+  if (currentOutput == null)
+    return { type: "no-change" };
+  const changedSteps = new Set(
+    changedFiles.flatMap(
+      (changedFile) => findEffectedSteps(changedFile, currentOutput)
+    )
+  );
+  if (changedSteps.size === 0)
+    return { type: "no-change" };
+  const unchangedOutput = {
+    manifest: currentOutput.manifest,
+    steps: [],
+    publicAssets: []
+  };
+  const changedOutput = {
+    manifest: currentOutput.manifest,
+    steps: [],
+    publicAssets: []
+  };
+  for (const step of currentOutput.steps) {
+    if (changedSteps.has(step)) {
+      changedOutput.steps.push(step);
+    } else {
+      unchangedOutput.steps.push(step);
+    }
+  }
+  for (const asset of currentOutput.publicAssets) {
+    if (changedSteps.has(asset)) {
+      changedOutput.publicAssets.push(asset);
+    } else {
+      unchangedOutput.publicAssets.push(asset);
+    }
+  }
+  const isOnlyHtmlChanges = changedFiles.length > 0 && every(changedFiles, ([_, file]) => file.endsWith(".html"));
+  if (isOnlyHtmlChanges) {
+    return {
+      type: "html-reload",
+      cachedOutput: unchangedOutput,
+      rebuildGroups: changedOutput.steps.map((step) => step.entrypoints)
+    };
+  }
+  const isOnlyContentScripts = changedOutput.steps.length > 0 && every(
+    changedOutput.steps.flatMap((step) => step.entrypoints),
+    (entry) => entry.type === "content-script"
+  );
+  if (isOnlyContentScripts) {
+    return {
+      type: "content-script-reload",
+      cachedOutput: unchangedOutput,
+      changedSteps: changedOutput.steps,
+      rebuildGroups: changedOutput.steps.map((step) => step.entrypoints)
+    };
+  }
+  return {
+    type: "extension-reload",
+    cachedOutput: unchangedOutput,
+    rebuildGroups: changedOutput.steps.map((step) => step.entrypoints)
+  };
+}
+function findEffectedSteps(changedFile, currentOutput) {
+  const changes = [];
+  const changedPath = normalizePath(changedFile[1]);
+  const isChunkEffected = (chunk) => (
+    // If it's an HTML file with the same path, is is effected because HTML files need to be pre-rendered
+    // fileName is normalized, relative bundle path
+    chunk.type === "asset" && changedPath.endsWith(chunk.fileName) || // If it's a chunk that depends on the changed file, it is effected
+    // moduleIds are absolute, normalized paths
+    chunk.type === "chunk" && chunk.moduleIds.includes(changedPath)
+  );
+  for (const step of currentOutput.steps) {
+    const effectedChunk = step.chunks.find((chunk) => isChunkEffected(chunk));
+    if (effectedChunk)
+      changes.push(step);
+  }
+  const effectedAsset = currentOutput.publicAssets.find(
+    (chunk) => isChunkEffected(chunk)
+  );
+  if (effectedAsset)
+    changes.push(effectedAsset);
+  return changes;
+}
+
+// src/core/utils/building/find-entrypoints.ts
+var import_path2 = require("path");
+var import_fs_extra3 = __toESM(require("fs-extra"), 1);
+var import_minimatch = require("minimatch");
+var import_linkedom = require("linkedom");
+var import_json5 = __toESM(require("json5"), 1);
+var import_fast_glob2 = __toESM(require("fast-glob"), 1);
+
 // src/core/utils/entrypoints.ts
+var import_node_path2 = __toESM(require("path"), 1);
 function getEntrypointName(entrypointsDir, inputPath) {
   const relativePath = import_node_path2.default.relative(entrypointsDir, inputPath);
   const name = relativePath.split(/[\.\/\\]/, 2)[0];
@@ -2465,423 +2611,332 @@ function resolvePerBrowserOption(option, browser) {
   return option;
 }
 
-// src/core/vite-plugins/devHtmlPrerender.ts
-var import_linkedom = require("linkedom");
-var import_path = require("path");
-var reactRefreshPreamble = "";
-function devHtmlPrerender(config) {
-  const htmlReloadId = "@wxt/reload-html";
-  const resolvedHtmlReloadId = (0, import_path.resolve)(
-    config.root,
-    "node_modules/wxt/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) => {
-          document.querySelectorAll(querySelector).forEach((element) => {
-            const src = element.getAttribute(attr);
-            if (!src)
-              return;
-            if ((0, import_path.isAbsolute)(src)) {
-              element.setAttribute(attr, server.origin + src);
-            } else if (src.startsWith(".")) {
-              const abs = (0, import_path.resolve)((0, import_path.dirname)(id), src);
-              const pathname = (0, import_path.relative)(config.root, abs);
-              element.setAttribute(attr, `${server.origin}/${pathname}`);
-            }
-          });
-        };
-        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 url2 = `${server.origin}/${name}.html`;
-        const serverHtml = await server.transformIndexHtml(
-          url2,
-          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']"
+// src/core/utils/constants.ts
+var VIRTUAL_NOOP_BACKGROUND_MODULE_ID = "virtual:user-background";
+
+// src/core/utils/building/find-entrypoints.ts
+async function findEntrypoints(config) {
+  const relativePaths = await (0, import_fast_glob2.default)("**/*", {
+    cwd: config.entrypointsDir
+  });
+  relativePaths.sort();
+  const pathGlobs = Object.keys(PATH_GLOB_TO_TYPE_MAP);
+  let hasBackground = false;
+  const possibleEntrypoints = await Promise.all(
+    relativePaths.map(async (relativePath) => {
+      const path10 = (0, import_path2.resolve)(config.entrypointsDir, relativePath);
+      const matchingGlob = pathGlobs.find(
+        (glob5) => (0, import_minimatch.minimatch)(relativePath, glob5)
+      );
+      if (matchingGlob == null) {
+        config.logger.warn(
+          `${relativePath} does not match any known entrypoint. Known entrypoints:
+${JSON.stringify(
+            PATH_GLOB_TO_TYPE_MAP,
+            null,
+            2
+          )}`
         );
-        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;
+        return;
       }
-    },
-    {
-      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 "";
-        }
-      }
-    }
-  ];
-}
-
-// src/core/vite-plugins/devServerGlobals.ts
-function devServerGlobals(internalConfig) {
-  return {
-    name: "wxt:dev-server-globals",
-    config() {
-      if (internalConfig.server == null || internalConfig.command == "build")
+      const type = PATH_GLOB_TO_TYPE_MAP[matchingGlob];
+      if (type === "ignored")
         return;
-      return {
-        define: {
-          __DEV_SERVER_PROTOCOL__: JSON.stringify("ws:"),
-          __DEV_SERVER_HOSTNAME__: JSON.stringify(
-            internalConfig.server.hostname
-          ),
-          __DEV_SERVER_PORT__: JSON.stringify(internalConfig.server.port)
-        }
-      };
+      switch (type) {
+        case "popup":
+          return await getPopupEntrypoint(config, path10);
+        case "options":
+          return await getOptionsEntrypoint(config, path10);
+        case "background":
+          hasBackground = true;
+          return await getBackgroundEntrypoint(config, path10);
+        case "content-script":
+          return await getContentScriptEntrypoint(config, path10);
+        case "unlisted-page":
+          return await getUnlistedPageEntrypoint(config, path10);
+        case "unlisted-script":
+          return await getUnlistedScriptEntrypoint(config, path10);
+        case "content-script-style":
+          return {
+            type,
+            name: getEntrypointName(config.entrypointsDir, path10),
+            inputPath: path10,
+            outputDir: (0, import_path2.resolve)(config.outDir, CONTENT_SCRIPT_OUT_DIR),
+            options: {
+              include: void 0,
+              exclude: void 0
+            }
+          };
+        default:
+          return {
+            type,
+            name: getEntrypointName(config.entrypointsDir, path10),
+            inputPath: path10,
+            outputDir: config.outDir,
+            options: {
+              include: void 0,
+              exclude: void 0
+            }
+          };
+      }
+    })
+  );
+  const entrypoints = possibleEntrypoints.filter(
+    (entry) => !!entry
+  );
+  const existingNames = {};
+  entrypoints.forEach((entrypoint) => {
+    const withSameName = existingNames[entrypoint.name];
+    if (withSameName) {
+      throw Error(
+        `Multiple entrypoints with the name "${entrypoint.name}" detected, but only one is allowed: ${[
+          (0, import_path2.relative)(config.root, withSameName.inputPath),
+          (0, import_path2.relative)(config.root, entrypoint.inputPath)
+        ].join(", ")}`
+      );
     }
-  };
-}
-
-// src/core/utils/network.ts
-var import_node_dns = __toESM(require("dns"), 1);
-
-// src/core/utils/time.ts
-function formatDuration(duration) {
-  if (duration < 1e3)
-    return `${duration} ms`;
-  if (duration < 1e4)
-    return `${(duration / 1e3).toFixed(3)} s`;
-  if (duration < 6e4)
-    return `${(duration / 1e3).toFixed(1)} s`;
-  return `${(duration / 1e3).toFixed(0)} s`;
-}
-function withTimeout(promise, duration) {
-  return new Promise((res, rej) => {
-    const timeout = setTimeout(() => {
-      rej(`Promise timed out after ${duration}ms`);
-    }, duration);
-    promise.then(res).catch(rej).finally(() => clearTimeout(timeout));
+    existingNames[entrypoint.name] = entrypoint;
   });
-}
-
-// src/core/utils/network.ts
-function isOffline() {
-  const isOffline2 = new Promise((res) => {
-    import_node_dns.default.resolve("google.com", (err) => {
-      if (err == null) {
-        res(false);
-      } else {
-        res(true);
-      }
-    });
+  if (config.command === "serve" && !hasBackground) {
+    entrypoints.push(
+      await getBackgroundEntrypoint(config, VIRTUAL_NOOP_BACKGROUND_MODULE_ID)
+    );
+  }
+  config.logger.debug("All entrypoints:", entrypoints);
+  const targetEntrypoints = entrypoints.filter((entry) => {
+    const { include, exclude } = entry.options;
+    if (include?.length && exclude?.length) {
+      config.logger.warn(
+        `The ${entry.name} entrypoint lists both include and exclude, but only one can be used per entrypoint. Entrypoint ignored.`
+      );
+      return false;
+    }
+    if (exclude?.length && !include?.length) {
+      return !exclude.includes(config.browser);
+    }
+    if (include?.length && !exclude?.length) {
+      return include.includes(config.browser);
+    }
+    return true;
   });
-  return withTimeout(isOffline2, 1e3).catch(() => true);
+  config.logger.debug(`${config.browser} entrypoints:`, targetEntrypoints);
+  return targetEntrypoints;
 }
-async function isOnline() {
-  const offline = await isOffline();
-  return !offline;
+function getHtmlBaseOptions(document) {
+  const options = {};
+  const includeContent = document.querySelector("meta[name='manifest.include']")?.getAttribute("content");
+  if (includeContent) {
+    options.include = import_json5.default.parse(includeContent);
+  }
+  const excludeContent = document.querySelector("meta[name='manifest.exclude']")?.getAttribute("content");
+  if (excludeContent) {
+    options.exclude = import_json5.default.parse(excludeContent);
+  }
+  return options;
 }
-async function fetchCached(url2, config) {
-  let content = "";
-  if (await isOnline()) {
-    const res = await fetch(url2);
-    if (res.status < 300) {
-      content = await res.text();
-      await config.fsCache.set(url2, content);
-    } else {
-      config.logger.debug(
-        `Failed to download "${url2}", falling back to cache...`
+async function getPopupEntrypoint(config, path10) {
+  const content = await import_fs_extra3.default.readFile(path10, "utf-8");
+  const { document } = (0, import_linkedom.parseHTML)(content);
+  const options = getHtmlBaseOptions(document);
+  const title = document.querySelector("title");
+  if (title != null)
+    options.defaultTitle = title.textContent ?? void 0;
+  const defaultIconContent = document.querySelector("meta[name='manifest.default_icon']")?.getAttribute("content");
+  if (defaultIconContent) {
+    try {
+      options.defaultIcon = import_json5.default.parse(defaultIconContent);
+    } catch (err) {
+      config.logger.fatal(
+        `Failed to parse default_icon meta tag content as JSON5. content=${defaultIconContent}`,
+        err
       );
     }
   }
-  if (!content)
-    content = await config.fsCache.get(url2) ?? "";
-  if (!content)
-    throw Error(
-      `Offline and "${url2}" has not been cached. Try again when online.`
-    );
-  return content;
+  const mv2TypeContent = document.querySelector("meta[name='manifest.type']")?.getAttribute("content");
+  if (mv2TypeContent) {
+    options.mv2Key = mv2TypeContent === "page_action" ? "page_action" : "browser_action";
+  }
+  const browserStyleContent = document.querySelector("meta[name='manifest.browser_style']")?.getAttribute("content");
+  if (browserStyleContent) {
+    options.browserStyle = browserStyleContent === "true";
+  }
+  return {
+    type: "popup",
+    name: "popup",
+    options,
+    inputPath: path10,
+    outputDir: config.outDir
+  };
 }
-
-// src/core/vite-plugins/download.ts
-function download(config) {
+async function getOptionsEntrypoint(config, path10) {
+  const content = await import_fs_extra3.default.readFile(path10, "utf-8");
+  const { document } = (0, import_linkedom.parseHTML)(content);
+  const options = getHtmlBaseOptions(document);
+  const openInTabContent = document.querySelector("meta[name='manifest.open_in_tab']")?.getAttribute("content");
+  if (openInTabContent) {
+    options.openInTab = openInTabContent === "true";
+  }
+  const chromeStyleContent = document.querySelector("meta[name='manifest.chrome_style']")?.getAttribute("content");
+  if (chromeStyleContent) {
+    options.chromeStyle = chromeStyleContent === "true";
+  }
+  const browserStyleContent = document.querySelector("meta[name='manifest.browser_style']")?.getAttribute("content");
+  if (browserStyleContent) {
+    options.browserStyle = browserStyleContent === "true";
+  }
   return {
-    name: "wxt:download",
-    resolveId(id) {
-      if (id.startsWith("url:"))
-        return "\0" + id;
-    },
-    async load(id) {
-      if (!id.startsWith("\0url:"))
-        return;
-      const url2 = id.replace("\0url:", "");
-      return await fetchCached(url2, config);
-    }
+    type: "options",
+    name: "options",
+    options,
+    inputPath: path10,
+    outputDir: config.outDir
   };
 }
-
-// src/core/vite-plugins/multipageMove.ts
-var import_node_path3 = require("path");
-var import_fs_extra = __toESM(require("fs-extra"), 1);
-function multipageMove(entrypoints, config) {
+async function getUnlistedPageEntrypoint(config, path10) {
+  const content = await import_fs_extra3.default.readFile(path10, "utf-8");
+  const { document } = (0, import_linkedom.parseHTML)(content);
   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_path3.extname)(oldBundlePath)
-        );
-        if (newBundlePath === oldBundlePath) {
-          config.logger.debug(
-            "HTML file is already in the correct location",
-            oldBundlePath
-          );
-          continue;
-        }
-        const oldAbsPath = (0, import_node_path3.resolve)(config.outDir, oldBundlePath);
-        const newAbsPath = (0, import_node_path3.resolve)(config.outDir, newBundlePath);
-        await (0, import_fs_extra.ensureDir)((0, import_node_path3.dirname)(newAbsPath));
-        await import_fs_extra.default.move(oldAbsPath, newAbsPath, { overwrite: true });
-        const renamedChunk = {
-          ...bundle[oldBundlePath],
-          fileName: newBundlePath
-        };
-        delete bundle[oldBundlePath];
-        bundle[newBundlePath] = renamedChunk;
-      }
-    }
+    type: "unlisted-page",
+    name: getEntrypointName(config.entrypointsDir, path10),
+    inputPath: path10,
+    outputDir: config.outDir,
+    options: getHtmlBaseOptions(document)
   };
 }
-
-// src/core/vite-plugins/unimport.ts
-var import_unimport = require("unimport");
-
-// src/core/utils/unimport.ts
-var import_vite = require("vite");
-function getUnimportOptions(config) {
-  if (config.imports === false)
-    return false;
-  const defaultOptions = {
-    debugLog: config.logger.debug,
-    imports: [
-      { name: "defineConfig", from: "wxt" },
-      { name: "fakeBrowser", from: "wxt/testing" }
-    ],
-    presets: [
-      { package: "wxt/client" },
-      { package: "wxt/browser" },
-      { package: "wxt/sandbox" },
-      { package: "wxt/storage" }
-    ],
-    warn: config.logger.warn,
-    dirs: ["components", "composables", "hooks", "utils"]
-  };
-  return (0, import_vite.mergeConfig)(
-    defaultOptions,
-    config.imports
+async function getUnlistedScriptEntrypoint(config, path10) {
+  const name = getEntrypointName(config.entrypointsDir, path10);
+  const defaultExport = await importEntrypointFile(
+    path10,
+    config
   );
-}
-
-// src/core/vite-plugins/unimport.ts
-var import_path2 = require("path");
-var ENABLED_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".js",
-  ".jsx",
-  ".ts",
-  ".tsx",
-  ".vue",
-  ".svelte"
-]);
-function unimport(config) {
-  const options = getUnimportOptions(config);
-  if (options === false)
-    return [];
-  const unimport2 = (0, import_unimport.createUnimport)(options);
+  if (defaultExport == null) {
+    throw Error(
+      `${name}: Default export not found, did you forget to call "export default defineUnlistedScript(...)"?`
+    );
+  }
+  const { main: _, ...moduleOptions } = defaultExport;
+  const options = moduleOptions;
   return {
-    name: "wxt:unimport",
-    async config() {
-      await unimport2.scanImportsFromDir(void 0, { cwd: config.srcDir });
-    },
-    async transform(code, id) {
-      if (id.includes("node_modules"))
-        return;
-      if (!ENABLED_EXTENSIONS.has((0, import_path2.extname)(id)))
-        return;
-      return unimport2.injectImports(code, id);
-    }
+    type: "unlisted-script",
+    name,
+    inputPath: path10,
+    outputDir: config.outDir,
+    options
   };
 }
-
-// src/core/vite-plugins/virtualEntrypoint.ts
-var import_fs_extra2 = __toESM(require("fs-extra"), 1);
-var import_path3 = 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_path3.resolve)(
-          config.root,
-          `node_modules/wxt/dist/virtual/${type}-entrypoint.js`
-        ),
-        "utf-8"
+async function getBackgroundEntrypoint(config, path10) {
+  const name = "background";
+  let options = {};
+  if (path10 !== VIRTUAL_NOOP_BACKGROUND_MODULE_ID) {
+    const defaultExport = await importEntrypointFile(
+      path10,
+      config
+    );
+    if (defaultExport == null) {
+      throw Error(
+        `${name}: Default export not found, did you forget to call "export default defineBackground(...)"?`
       );
-      return template.replace(`virtual:user-${type}`, inputPath);
     }
-  };
-}
-
-// src/core/vite-plugins/tsconfigPaths.ts
-function tsconfigPaths(config) {
+    const { main: _, ...moduleOptions } = defaultExport;
+    options = moduleOptions;
+  }
   return {
-    name: "wxt:aliases",
-    async config() {
-      return {
-        resolve: {
-          alias: config.alias
-        }
-      };
+    type: "background",
+    name,
+    inputPath: path10,
+    outputDir: config.outDir,
+    options: {
+      ...options,
+      type: resolvePerBrowserOption(options.type, config.browser),
+      persistent: resolvePerBrowserOption(options.persistent, config.browser)
     }
   };
 }
-
-// src/core/vite-plugins/noopBackground.ts
-function noopBackground() {
-  const virtualModuleId = VIRTUAL_NOOP_BACKGROUND_MODULE_ID;
-  const resolvedVirtualModuleId = "\0" + virtualModuleId;
+async function getContentScriptEntrypoint(config, path10) {
+  const name = getEntrypointName(config.entrypointsDir, path10);
+  const { main: _, ...options } = await importEntrypointFile(path10, config);
+  if (options == null) {
+    throw Error(
+      `${name}: Default export not found, did you forget to call "export default defineContentScript(...)"?`
+    );
+  }
   return {
-    name: "wxt:noop-background",
-    resolveId(id) {
-      if (id === virtualModuleId)
-        return resolvedVirtualModuleId;
-    },
-    load(id) {
-      if (id === resolvedVirtualModuleId) {
-        return `import { defineBackground } from 'wxt/client';
-export default defineBackground(() => void 0)`;
-      }
-    }
+    type: "content-script",
+    name,
+    inputPath: path10,
+    outputDir: (0, import_path2.resolve)(config.outDir, CONTENT_SCRIPT_OUT_DIR),
+    options
   };
 }
-var VIRTUAL_NOOP_BACKGROUND_MODULE_ID = "virtual:user-background";
+var PATH_GLOB_TO_TYPE_MAP = {
+  "sandbox.html": "sandbox",
+  "sandbox/index.html": "sandbox",
+  "*.sandbox.html": "sandbox",
+  "*.sandbox/index.html": "sandbox",
+  "bookmarks.html": "bookmarks",
+  "bookmarks/index.html": "bookmarks",
+  "history.html": "history",
+  "history/index.html": "history",
+  "newtab.html": "newtab",
+  "newtab/index.html": "newtab",
+  "sidepanel.html": "sidepanel",
+  "sidepanel/index.html": "sidepanel",
+  "*.sidepanel.html": "sidepanel",
+  "*.sidepanel/index.html": "sidepanel",
+  "devtools.html": "devtools",
+  "devtools/index.html": "devtools",
+  "background.[jt]s": "background",
+  "background/index.[jt]s": "background",
+  [VIRTUAL_NOOP_BACKGROUND_MODULE_ID]: "background",
+  "content.[jt]s?(x)": "content-script",
+  "content/index.[jt]s?(x)": "content-script",
+  "*.content.[jt]s?(x)": "content-script",
+  "*.content/index.[jt]s?(x)": "content-script",
+  [`content.${CSS_EXTENSIONS_PATTERN}`]: "content-script-style",
+  [`*.content.${CSS_EXTENSIONS_PATTERN}`]: "content-script-style",
+  [`content/index.${CSS_EXTENSIONS_PATTERN}`]: "content-script-style",
+  [`*.content/index.${CSS_EXTENSIONS_PATTERN}`]: "content-script-style",
+  "popup.html": "popup",
+  "popup/index.html": "popup",
+  "options.html": "options",
+  "options/index.html": "options",
+  "*.html": "unlisted-page",
+  "*/index.html": "unlisted-page",
+  "*.[jt]s": "unlisted-script",
+  "*/index.ts": "unlisted-script",
+  [`*.${CSS_EXTENSIONS_PATTERN}`]: "unlisted-style",
+  [`*/index.${CSS_EXTENSIONS_PATTERN}`]: "unlisted-style",
+  // Don't warn about any files in subdirectories, like CSS or JS entrypoints for HTML files or tests
+  "*/**": "ignored"
+};
+var CONTENT_SCRIPT_OUT_DIR = "content-scripts";
 
-// src/core/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/utils/building/generate-wxt-dir.ts
+var import_unimport = require("unimport");
+var import_fs_extra4 = __toESM(require("fs-extra"), 1);
+var import_path3 = require("path");
 
-// src/core/vite-plugins/bundleAnalysis.ts
-var import_rollup_plugin_visualizer = require("rollup-plugin-visualizer");
-var increment = 0;
-function bundleAnalysis() {
-  return (0, import_rollup_plugin_visualizer.visualizer)({
-    emitFile: true,
-    template: "raw-data",
-    filename: `stats-${increment++}.json`
-  });
+// src/core/utils/unimport.ts
+var import_defu = require("defu");
+function getUnimportOptions(config) {
+  if (config.imports === false)
+    return false;
+  const defaultOptions = {
+    debugLog: config.logger.debug,
+    imports: [
+      { name: "defineConfig", from: "wxt" },
+      { name: "fakeBrowser", from: "wxt/testing" }
+    ],
+    presets: [
+      { package: "wxt/client" },
+      { package: "wxt/browser" },
+      { package: "wxt/sandbox" },
+      { package: "wxt/storage" }
+    ],
+    warn: config.logger.warn,
+    dirs: ["components", "composables", "hooks", "utils"]
+  };
+  return (0, import_defu.defu)(config.imports, defaultOptions);
 }
 
 // src/core/utils/globals.ts
@@ -2929,7 +2984,7 @@ function getGlobals(config) {
     }
   ];
 }
-function getEntrypointGlobals(config, entrypointName) {
+function getEntrypointGlobals(entrypointName) {
   return [
     {
       name: surroundInUnderscore("ENTRYPOINT"),
@@ -2942,859 +2997,902 @@ function surroundInUnderscore(name) {
   return `__${name}__`;
 }
 
-// src/core/vite-plugins/globals.ts
-function globals(config) {
-  return {
-    name: "wxt:globals",
-    config() {
-      const define = {};
-      for (const global3 of getGlobals(config)) {
-        define[global3.name] = JSON.stringify(global3.value);
-      }
-      return {
-        define
-      };
-    }
-  };
-}
-
-// src/core/vite-plugins/webextensionPolyfillAlias.ts
-var import_node_path4 = __toESM(require("path"), 1);
+// src/core/utils/building/generate-wxt-dir.ts
+var import_node_path3 = __toESM(require("path"), 1);
 
-// src/core/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/utils/i18n.ts
+var predefinedMessages = {
+  "@@extension_id": {
+    message: "<browser.runtime.id>",
+    description: "The extension or app ID; you might use this string to construct URLs for resources inside the extension. Even unlocalized extensions can use this message.\nNote: You can't use this message in a manifest file."
+  },
+  "@@ui_locale": {
+    message: "<browser.i18n.getUiLocale()>",
+    description: ""
+  },
+  "@@bidi_dir": {
+    message: "<ltr|rtl>",
+    description: 'The text direction for the current locale, either "ltr" for left-to-right languages such as English or "rtl" for right-to-left languages such as Japanese.'
+  },
+  "@@bidi_reversed_dir": {
+    message: "<rtl|ltr>",
+    description: `If the @@bidi_dir is "ltr", then this is "rtl"; otherwise, it's "ltr".`
+  },
+  "@@bidi_start_edge": {
+    message: "<left|right>",
+    description: `If the @@bidi_dir is "ltr", then this is "left"; otherwise, it's "right".`
+  },
+  "@@bidi_end_edge": {
+    message: "<right|left>",
+    description: `If the @@bidi_dir is "ltr", then this is "right"; otherwise, it's "left".`
+  }
+};
+function parseI18nMessages(messagesJson) {
+  return Object.entries({
+    ...predefinedMessages,
+    ...messagesJson
+  }).map(([name, details]) => ({
+    name,
+    ...details
+  }));
 }
 
-// src/core/utils/fs.ts
-var import_fs_extra3 = __toESM(require("fs-extra"), 1);
-var import_fast_glob = __toESM(require("fast-glob"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
-async function writeFileIfDifferent(file, newContents) {
-  const existingContents = await import_fs_extra3.default.readFile(file, "utf-8").catch(() => void 0);
-  if (existingContents !== newContents) {
-    await import_fs_extra3.default.writeFile(file, newContents);
+// src/core/utils/building/generate-wxt-dir.ts
+async function generateTypesDir(entrypoints, config) {
+  await import_fs_extra4.default.ensureDir(config.typesDir);
+  const references = [];
+  const imports = getUnimportOptions(config);
+  if (imports !== false) {
+    references.push(await writeImportsDeclarationFile(config, imports));
   }
+  references.push(await writePathsDeclarationFile(entrypoints, config));
+  references.push(await writeI18nDeclarationFile(config));
+  references.push(await writeGlobalsDeclarationFile(config));
+  const mainReference = await writeMainDeclarationFile(references, config);
+  await writeTsConfigFile(mainReference, config);
 }
-async function getPublicFiles(config) {
-  if (!await import_fs_extra3.default.exists(config.publicDir))
-    return [];
-  const files = await (0, import_fast_glob.default)("**/*", { cwd: config.publicDir });
-  return files.map(unnormalizePath);
+async function writeImportsDeclarationFile(config, unimportOptions) {
+  const filePath = (0, import_path3.resolve)(config.typesDir, "imports.d.ts");
+  const unimport2 = (0, import_unimport.createUnimport)(unimportOptions);
+  await unimport2.scanImportsFromDir(void 0, { cwd: config.srcDir });
+  await writeFileIfDifferent(
+    filePath,
+    ["// Generated by wxt", await unimport2.generateTypeDeclarations()].join(
+      "\n"
+    ) + "\n"
+  );
+  return filePath;
 }
-async function removeEmptyDirs(dir) {
-  const files = await import_fs_extra3.default.readdir(dir);
-  for (const file of files) {
-    const filePath = import_node_path5.default.join(dir, file);
-    const stats = await import_fs_extra3.default.stat(filePath);
-    if (stats.isDirectory()) {
-      await removeEmptyDirs(filePath);
-    }
-  }
-  try {
-    await import_fs_extra3.default.rmdir(dir);
-  } catch {
+async function writePathsDeclarationFile(entrypoints, config) {
+  const filePath = (0, import_path3.resolve)(config.typesDir, "paths.d.ts");
+  const unions = entrypoints.map(
+    (entry) => getEntrypointBundlePath(
+      entry,
+      config.outDir,
+      entry.inputPath.endsWith(".html") ? ".html" : ".js"
+    )
+  ).concat(await getPublicFiles(config)).map(normalizePath).map((path10) => `    | "/${path10}"`).sort().join("\n");
+  const template = `// Generated by wxt
+import "wxt/browser";
+
+declare module "wxt/browser" {
+  export type PublicPath =
+{{ union }}
+  export interface WxtRuntime extends Runtime.Static {
+    getURL(path: PublicPath): string;
   }
 }
+`;
+  await writeFileIfDifferent(
+    filePath,
+    template.replace("{{ union }}", unions || "    | never")
+  );
+  return filePath;
+}
+async function writeI18nDeclarationFile(config) {
+  const filePath = (0, import_path3.resolve)(config.typesDir, "i18n.d.ts");
+  const defaultLocale = config.manifest.default_locale;
+  const template = `// Generated by wxt
+import "wxt/browser";
 
-// src/core/utils/building/build-entrypoints.ts
-var import_fs_extra4 = __toESM(require("fs-extra"), 1);
-var import_path4 = require("path");
-var import_picocolors = __toESM(require("picocolors"), 1);
-async function buildEntrypoints(groups, config, spinner) {
-  const steps = [];
-  for (let i = 0; i < groups.length; i++) {
-    const group = groups[i];
-    spinner.text = import_picocolors.default.dim(`[${i + 1}/${groups.length}]`) + ` ${[group].flat().map((e) => e.name).join(import_picocolors.default.dim(", "))}`;
-    const step = Array.isArray(group) ? await buildMultipleEntrypoints(group, config) : await buildSingleEntrypoint(group, config);
-    steps.push(step);
+declare module "wxt/browser" {
+  /**
+   * See https://developer.chrome.com/docs/extensions/reference/i18n/#method-getMessage
+   */
+  interface GetMessageOptions {
+    /**
+     * See https://developer.chrome.com/docs/extensions/reference/i18n/#method-getMessage
+     */
+    escapeLt?: boolean
   }
-  const publicAssets = await copyPublicDirectory(config);
-  await removeEmptyDirs(config.outDir);
-  return { publicAssets, steps };
-}
-async function buildSingleEntrypoint(entrypoint, config) {
-  const isVirtual = [
-    "background",
-    "content-script",
-    "unlisted-script"
-  ].includes(entrypoint.type);
-  const entry = isVirtual ? `virtual:wxt-${entrypoint.type}?${entrypoint.inputPath}` : entrypoint.inputPath;
-  const plugins = [];
-  if (entrypoint.type === "content-script-style" || entrypoint.type === "unlisted-style") {
-    plugins.push(cssEntrypoints(entrypoint, config));
+
+  export interface WxtI18n extends I18n.Static {
+{{ overrides }}
   }
-  const libMode = {
-    mode: config.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,
-            config.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(config.mode)
-    }
-  };
-  for (const global3 of getEntrypointGlobals(config, entrypoint.name)) {
-    libMode.define[global3.name] = JSON.stringify(global3.value);
+}
+`;
+  let messages;
+  if (defaultLocale) {
+    const defaultLocalePath = import_node_path3.default.resolve(
+      config.publicDir,
+      "_locales",
+      defaultLocale,
+      "messages.json"
+    );
+    const content = JSON.parse(await import_fs_extra4.default.readFile(defaultLocalePath, "utf-8"));
+    messages = parseI18nMessages(content);
+  } else {
+    messages = parseI18nMessages({});
   }
-  const entryConfig = vite.mergeConfig(
-    libMode,
-    await config.vite(config.env)
+  const overrides = messages.map((message) => {
+    return `    /**
+     * ${message.description ?? "No message description."}
+     *
+     * "${message.message}"
+     */
+    getMessage(
+      messageName: "${message.name}",
+      substitutions?: string | string[],
+      options?: GetMessageOptions,
+    ): string;`;
+  });
+  await writeFileIfDifferent(
+    filePath,
+    template.replace("{{ overrides }}", overrides.join("\n"))
   );
-  const result = await vite.build(entryConfig);
-  return {
-    entrypoints: entrypoint,
-    chunks: getBuildOutputChunks(result)
-  };
+  return filePath;
 }
-async function buildMultipleEntrypoints(entrypoints, config) {
-  const multiPage = {
-    mode: config.mode,
-    plugins: [multipageMove(entrypoints, config)],
-    build: {
-      rollupOptions: {
-        input: entrypoints.reduce((input, entry) => {
-          input[entry.name] = entry.inputPath;
-          return input;
-        }, {}),
-        output: {
-          // Include a hash to prevent conflicts
-          chunkFileNames: "chunks/[name]-[hash].js",
-          // Include a hash to prevent conflicts
-          entryFileNames: "chunks/[name]-[hash].js",
-          // We can't control the "name", so we need a hash to prevent conflicts
-          assetFileNames: "assets/[name]-[hash].[ext]"
-        }
-      }
-    },
-    define: {}
-  };
-  for (const global3 of getEntrypointGlobals(config, "html")) {
-    multiPage.define[global3.name] = JSON.stringify(global3.value);
-  }
-  const entryConfig = vite.mergeConfig(
-    multiPage,
-    await config.vite(config.env)
+async function writeGlobalsDeclarationFile(config) {
+  const filePath = (0, import_path3.resolve)(config.typesDir, "globals.d.ts");
+  const globals2 = [...getGlobals(config), ...getEntrypointGlobals("")];
+  await writeFileIfDifferent(
+    filePath,
+    [
+      "// Generated by wxt",
+      "export {}",
+      "declare global {",
+      ...globals2.map((global3) => `  const ${global3.name}: ${global3.type};`),
+      "}"
+    ].join("\n") + "\n"
   );
-  const result = await vite.build(entryConfig);
-  return {
-    entrypoints,
-    chunks: getBuildOutputChunks(result)
-  };
+  return filePath;
 }
-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;
+async function writeMainDeclarationFile(references, config) {
+  const dir = config.wxtDir;
+  const filePath = (0, import_path3.resolve)(dir, "wxt.d.ts");
+  await writeFileIfDifferent(
+    filePath,
+    [
+      "// Generated by wxt",
+      `/// <reference types="vite/client" />`,
+      ...references.map(
+        (ref) => `/// <reference types="./${normalizePath((0, import_path3.relative)(dir, ref))}" />`
+      )
+    ].join("\n") + "\n"
+  );
+  return filePath;
 }
-async function copyPublicDirectory(config) {
-  const files = await getPublicFiles(config);
-  if (files.length === 0)
-    return [];
-  const publicAssets = [];
-  for (const file of files) {
-    const srcPath = (0, import_path4.resolve)(config.publicDir, file);
-    const outPath = (0, import_path4.resolve)(config.outDir, file);
-    await import_fs_extra4.default.ensureDir((0, import_path4.dirname)(outPath));
-    await import_fs_extra4.default.copyFile(srcPath, outPath);
-    publicAssets.push({
-      type: "asset",
-      fileName: file,
-      name: file,
-      needsCodeReference: false,
-      source: await import_fs_extra4.default.readFile(srcPath)
-    });
-  }
-  return publicAssets;
+async function writeTsConfigFile(mainReference, config) {
+  const dir = config.wxtDir;
+  const getTsconfigPath = (path10) => normalizePath((0, import_path3.relative)(dir, path10));
+  const paths = Object.entries(config.alias).flatMap(([alias, absolutePath]) => {
+    const aliasPath = getTsconfigPath(absolutePath);
+    return [
+      `      "${alias}": ["${aliasPath}"]`,
+      `      "${alias}/*": ["${aliasPath}/*"]`
+    ];
+  }).join(",\n");
+  await writeFileIfDifferent(
+    (0, import_path3.resolve)(dir, "tsconfig.json"),
+    `{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "noEmit": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "paths": {
+${paths}
+    }
+  },
+  "include": [
+    "${getTsconfigPath(config.root)}/**/*",
+    "./${getTsconfigPath(mainReference)}"
+  ],
+  "exclude": ["${getTsconfigPath(config.outBaseDir)}"]
+}`
+  );
 }
 
-// src/core/utils/arrays.ts
-function every(array, predicate) {
-  for (let i = 0; i < array.length; i++)
-    if (!predicate(array[i], i))
-      return false;
-  return true;
-}
+// src/core/utils/building/get-internal-config.ts
+var import_c12 = require("c12");
+var import_node_path7 = __toESM(require("path"), 1);
 
-// src/core/utils/building/detect-dev-changes.ts
-function detectDevChanges(changedFiles, currentOutput) {
-  if (currentOutput == null)
-    return { type: "no-change" };
-  const changedSteps = new Set(
-    changedFiles.flatMap(
-      (changedFile) => findEffectedSteps(changedFile, currentOutput)
-    )
-  );
-  if (changedSteps.size === 0)
-    return { type: "no-change" };
-  const unchangedOutput = {
-    manifest: currentOutput.manifest,
-    steps: [],
-    publicAssets: []
-  };
-  const changedOutput = {
-    manifest: currentOutput.manifest,
-    steps: [],
-    publicAssets: []
-  };
-  for (const step of currentOutput.steps) {
-    if (changedSteps.has(step)) {
-      changedOutput.steps.push(step);
-    } else {
-      unchangedOutput.steps.push(step);
-    }
-  }
-  for (const asset of currentOutput.publicAssets) {
-    if (changedSteps.has(asset)) {
-      changedOutput.publicAssets.push(asset);
-    } else {
-      unchangedOutput.publicAssets.push(asset);
-    }
-  }
-  const isOnlyHtmlChanges = changedFiles.length > 0 && every(changedFiles, ([_, file]) => file.endsWith(".html"));
-  if (isOnlyHtmlChanges) {
-    return {
-      type: "html-reload",
-      cachedOutput: unchangedOutput,
-      rebuildGroups: changedOutput.steps.map((step) => step.entrypoints)
-    };
-  }
-  const isOnlyContentScripts = changedOutput.steps.length > 0 && every(
-    changedOutput.steps.flatMap((step) => step.entrypoints),
-    (entry) => entry.type === "content-script"
-  );
-  if (isOnlyContentScripts) {
-    return {
-      type: "content-script-reload",
-      cachedOutput: unchangedOutput,
-      changedSteps: changedOutput.steps,
-      rebuildGroups: changedOutput.steps.map((step) => step.entrypoints)
-    };
-  }
-  return {
-    type: "extension-reload",
-    cachedOutput: unchangedOutput,
-    rebuildGroups: changedOutput.steps.map((step) => step.entrypoints)
-  };
-}
-function findEffectedSteps(changedFile, currentOutput) {
-  const changes = [];
-  const changedPath = normalizePath(changedFile[1]);
-  const isChunkEffected = (chunk) => (
-    // If it's an HTML file with the same path, is is effected because HTML files need to be pre-rendered
-    // fileName is normalized, relative bundle path
-    chunk.type === "asset" && changedPath.endsWith(chunk.fileName) || // If it's a chunk that depends on the changed file, it is effected
-    // moduleIds are absolute, normalized paths
-    chunk.type === "chunk" && chunk.moduleIds.includes(changedPath)
-  );
-  for (const step of currentOutput.steps) {
-    const effectedChunk = step.chunks.find((chunk) => isChunkEffected(chunk));
-    if (effectedChunk)
-      changes.push(step);
-  }
-  const effectedAsset = currentOutput.publicAssets.find(
-    (chunk) => isChunkEffected(chunk)
-  );
-  if (effectedAsset)
-    changes.push(effectedAsset);
-  return changes;
-}
-
-// src/core/utils/building/find-entrypoints.ts
-var import_path5 = require("path");
+// src/core/utils/cache.ts
 var import_fs_extra5 = __toESM(require("fs-extra"), 1);
-var import_minimatch = require("minimatch");
-var import_linkedom2 = require("linkedom");
-var import_json5 = __toESM(require("json5"), 1);
-var import_fast_glob2 = __toESM(require("fast-glob"), 1);
-async function findEntrypoints(config) {
-  const relativePaths = await (0, import_fast_glob2.default)("**/*", {
-    cwd: config.entrypointsDir
-  });
-  relativePaths.sort();
-  const pathGlobs = Object.keys(PATH_GLOB_TO_TYPE_MAP);
-  let hasBackground = false;
-  const possibleEntrypoints = await Promise.all(
-    relativePaths.map(async (relativePath) => {
-      const path11 = (0, import_path5.resolve)(config.entrypointsDir, relativePath);
-      const matchingGlob = pathGlobs.find(
-        (glob5) => (0, import_minimatch.minimatch)(relativePath, glob5)
-      );
-      if (matchingGlob == null) {
-        config.logger.warn(
-          `${relativePath} does not match any known entrypoint. Known entrypoints:
-${JSON.stringify(
-            PATH_GLOB_TO_TYPE_MAP,
-            null,
-            2
-          )}`
-        );
-        return;
-      }
-      const type = PATH_GLOB_TO_TYPE_MAP[matchingGlob];
-      if (type === "ignored")
-        return;
-      switch (type) {
-        case "popup":
-          return await getPopupEntrypoint(config, path11);
-        case "options":
-          return await getOptionsEntrypoint(config, path11);
-        case "background":
-          hasBackground = true;
-          return await getBackgroundEntrypoint(config, path11);
-        case "content-script":
-          return await getContentScriptEntrypoint(config, path11);
-        case "unlisted-page":
-          return await getUnlistedPageEntrypoint(config, path11);
-        case "unlisted-script":
-          return await getUnlistedScriptEntrypoint(config, path11);
-        case "content-script-style":
-          return {
-            type,
-            name: getEntrypointName(config.entrypointsDir, path11),
-            inputPath: path11,
-            outputDir: (0, import_path5.resolve)(config.outDir, CONTENT_SCRIPT_OUT_DIR),
-            options: {
-              include: void 0,
-              exclude: void 0
-            }
-          };
-        default:
-          return {
-            type,
-            name: getEntrypointName(config.entrypointsDir, path11),
-            inputPath: path11,
-            outputDir: config.outDir,
-            options: {
-              include: void 0,
-              exclude: void 0
-            }
-          };
-      }
-    })
-  );
-  const entrypoints = possibleEntrypoints.filter(
-    (entry) => !!entry
-  );
-  const existingNames = {};
-  entrypoints.forEach((entrypoint) => {
-    const withSameName = existingNames[entrypoint.name];
-    if (withSameName) {
-      throw Error(
-        `Multiple entrypoints with the name "${entrypoint.name}" detected, but only one is allowed: ${[
-          (0, import_path5.relative)(config.root, withSameName.inputPath),
-          (0, import_path5.relative)(config.root, entrypoint.inputPath)
-        ].join(", ")}`
-      );
-    }
-    existingNames[entrypoint.name] = entrypoint;
-  });
-  if (config.command === "serve" && !hasBackground) {
-    entrypoints.push(
-      await getBackgroundEntrypoint(config, VIRTUAL_NOOP_BACKGROUND_MODULE_ID)
-    );
-  }
-  config.logger.debug("All entrypoints:", entrypoints);
-  const targetEntrypoints = entrypoints.filter((entry) => {
-    const { include, exclude } = entry.options;
-    if (include?.length && exclude?.length) {
-      config.logger.warn(
-        `The ${entry.name} entrypoint lists both include and exclude, but only one can be used per entrypoint. Entrypoint ignored.`
-      );
-      return false;
-    }
-    if (exclude?.length && !include?.length) {
-      return !exclude.includes(config.browser);
-    }
-    if (include?.length && !exclude?.length) {
-      return include.includes(config.browser);
-    }
-    return true;
-  });
-  config.logger.debug(`${config.browser} entrypoints:`, targetEntrypoints);
-  return targetEntrypoints;
-}
-function getHtmlBaseOptions(document) {
-  const options = {};
-  const includeContent = document.querySelector("meta[name='manifest.include']")?.getAttribute("content");
-  if (includeContent) {
-    options.include = import_json5.default.parse(includeContent);
-  }
-  const excludeContent = document.querySelector("meta[name='manifest.exclude']")?.getAttribute("content");
-  if (excludeContent) {
-    options.exclude = import_json5.default.parse(excludeContent);
-  }
-  return options;
-}
-async function getPopupEntrypoint(config, path11) {
-  const content = await import_fs_extra5.default.readFile(path11, "utf-8");
-  const { document } = (0, import_linkedom2.parseHTML)(content);
-  const options = getHtmlBaseOptions(document);
-  const title = document.querySelector("title");
-  if (title != null)
-    options.defaultTitle = title.textContent ?? void 0;
-  const defaultIconContent = document.querySelector("meta[name='manifest.default_icon']")?.getAttribute("content");
-  if (defaultIconContent) {
-    try {
-      options.defaultIcon = import_json5.default.parse(defaultIconContent);
-    } catch (err) {
-      config.logger.fatal(
-        `Failed to parse default_icon meta tag content as JSON5. content=${defaultIconContent}`,
-        err
-      );
-    }
-  }
-  const mv2TypeContent = document.querySelector("meta[name='manifest.type']")?.getAttribute("content");
-  if (mv2TypeContent) {
-    options.mv2Key = mv2TypeContent === "page_action" ? "page_action" : "browser_action";
-  }
-  const browserStyleContent = document.querySelector("meta[name='manifest.browser_style']")?.getAttribute("content");
-  if (browserStyleContent) {
-    options.browserStyle = browserStyleContent === "true";
-  }
-  return {
-    type: "popup",
-    name: "popup",
-    options,
-    inputPath: path11,
-    outputDir: config.outDir
-  };
-}
-async function getOptionsEntrypoint(config, path11) {
-  const content = await import_fs_extra5.default.readFile(path11, "utf-8");
-  const { document } = (0, import_linkedom2.parseHTML)(content);
-  const options = getHtmlBaseOptions(document);
-  const openInTabContent = document.querySelector("meta[name='manifest.open_in_tab']")?.getAttribute("content");
-  if (openInTabContent) {
-    options.openInTab = openInTabContent === "true";
-  }
-  const chromeStyleContent = document.querySelector("meta[name='manifest.chrome_style']")?.getAttribute("content");
-  if (chromeStyleContent) {
-    options.chromeStyle = chromeStyleContent === "true";
-  }
-  const browserStyleContent = document.querySelector("meta[name='manifest.browser_style']")?.getAttribute("content");
-  if (browserStyleContent) {
-    options.browserStyle = browserStyleContent === "true";
-  }
-  return {
-    type: "options",
-    name: "options",
-    options,
-    inputPath: path11,
-    outputDir: config.outDir
-  };
-}
-async function getUnlistedPageEntrypoint(config, path11) {
-  const content = await import_fs_extra5.default.readFile(path11, "utf-8");
-  const { document } = (0, import_linkedom2.parseHTML)(content);
-  return {
-    type: "unlisted-page",
-    name: getEntrypointName(config.entrypointsDir, path11),
-    inputPath: path11,
-    outputDir: config.outDir,
-    options: getHtmlBaseOptions(document)
-  };
-}
-async function getUnlistedScriptEntrypoint(config, path11) {
-  const name = getEntrypointName(config.entrypointsDir, path11);
-  const defaultExport = await importEntrypointFile(
-    path11,
-    config
-  );
-  if (defaultExport == null) {
-    throw Error(
-      `${name}: Default export not found, did you forget to call "export default defineUnlistedScript(...)"?`
-    );
-  }
-  const { main: _, ...moduleOptions } = defaultExport;
-  const options = moduleOptions;
-  return {
-    type: "unlisted-script",
-    name,
-    inputPath: path11,
-    outputDir: config.outDir,
-    options
-  };
-}
-async function getBackgroundEntrypoint(config, path11) {
-  const name = "background";
-  let options = {};
-  if (path11 !== VIRTUAL_NOOP_BACKGROUND_MODULE_ID) {
-    const defaultExport = await importEntrypointFile(
-      path11,
-      config
-    );
-    if (defaultExport == null) {
-      throw Error(
-        `${name}: Default export not found, did you forget to call "export default defineBackground(...)"?`
-      );
-    }
-    const { main: _, ...moduleOptions } = defaultExport;
-    options = moduleOptions;
-  }
+var import_path4 = require("path");
+function createFsCache(wxtDir) {
+  const getPath = (key) => (0, import_path4.resolve)(wxtDir, "cache", encodeURIComponent(key));
   return {
-    type: "background",
-    name,
-    inputPath: path11,
-    outputDir: config.outDir,
-    options: {
-      ...options,
-      type: resolvePerBrowserOption(options.type, config.browser),
-      persistent: resolvePerBrowserOption(options.persistent, config.browser)
+    async set(key, value) {
+      const path10 = getPath(key);
+      await (0, import_fs_extra5.ensureDir)((0, import_path4.dirname)(path10));
+      await writeFileIfDifferent(path10, value);
+    },
+    async get(key) {
+      const path10 = getPath(key);
+      try {
+        return await import_fs_extra5.default.readFile(path10, "utf-8");
+      } catch {
+        return void 0;
+      }
     }
   };
 }
-async function getContentScriptEntrypoint(config, path11) {
-  const name = getEntrypointName(config.entrypointsDir, path11);
-  const { main: _, ...options } = await importEntrypointFile(path11, config);
-  if (options == null) {
-    throw Error(
-      `${name}: Default export not found, did you forget to call "export default defineContentScript(...)"?`
-    );
-  }
+
+// src/core/utils/building/get-internal-config.ts
+var import_consola = __toESM(require("consola"), 1);
+
+// src/core/builders/vite/plugins/devHtmlPrerender.ts
+var import_linkedom2 = require("linkedom");
+var import_node_path4 = require("path");
+var reactRefreshPreamble = "";
+function devHtmlPrerender(config) {
+  const htmlReloadId = "@wxt/reload-html";
+  const resolvedHtmlReloadId = (0, import_node_path4.resolve)(
+    config.root,
+    "node_modules/wxt/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_linkedom2.parseHTML)(code);
+        const pointToDevServer = (querySelector, attr) => {
+          document.querySelectorAll(querySelector).forEach((element) => {
+            const src = element.getAttribute(attr);
+            if (!src)
+              return;
+            if ((0, import_node_path4.isAbsolute)(src)) {
+              element.setAttribute(attr, server.origin + src);
+            } else if (src.startsWith(".")) {
+              const abs = (0, import_node_path4.resolve)((0, import_node_path4.dirname)(id), src);
+              const pathname = (0, import_node_path4.relative)(config.root, abs);
+              element.setAttribute(attr, `${server.origin}/${pathname}`);
+            }
+          });
+        };
+        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 url2 = `${server.origin}/${name}.html`;
+        const serverHtml = await server.transformHtml(url2, html, originalUrl);
+        const { document } = (0, import_linkedom2.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 "";
+        }
+      }
+    }
+  ];
+}
+
+// src/core/builders/vite/plugins/devServerGlobals.ts
+function devServerGlobals(config) {
   return {
-    type: "content-script",
-    name,
-    inputPath: path11,
-    outputDir: (0, import_path5.resolve)(config.outDir, CONTENT_SCRIPT_OUT_DIR),
-    options
+    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)
+        }
+      };
+    }
   };
 }
-var PATH_GLOB_TO_TYPE_MAP = {
-  "sandbox.html": "sandbox",
-  "sandbox/index.html": "sandbox",
-  "*.sandbox.html": "sandbox",
-  "*.sandbox/index.html": "sandbox",
-  "bookmarks.html": "bookmarks",
-  "bookmarks/index.html": "bookmarks",
-  "history.html": "history",
-  "history/index.html": "history",
-  "newtab.html": "newtab",
-  "newtab/index.html": "newtab",
-  "sidepanel.html": "sidepanel",
-  "sidepanel/index.html": "sidepanel",
-  "*.sidepanel.html": "sidepanel",
-  "*.sidepanel/index.html": "sidepanel",
-  "devtools.html": "devtools",
-  "devtools/index.html": "devtools",
-  "background.[jt]s": "background",
-  "background/index.[jt]s": "background",
-  [VIRTUAL_NOOP_BACKGROUND_MODULE_ID]: "background",
-  "content.[jt]s?(x)": "content-script",
-  "content/index.[jt]s?(x)": "content-script",
-  "*.content.[jt]s?(x)": "content-script",
-  "*.content/index.[jt]s?(x)": "content-script",
-  [`content.${CSS_EXTENSIONS_PATTERN}`]: "content-script-style",
-  [`*.content.${CSS_EXTENSIONS_PATTERN}`]: "content-script-style",
-  [`content/index.${CSS_EXTENSIONS_PATTERN}`]: "content-script-style",
-  [`*.content/index.${CSS_EXTENSIONS_PATTERN}`]: "content-script-style",
-  "popup.html": "popup",
-  "popup/index.html": "popup",
-  "options.html": "options",
-  "options/index.html": "options",
-  "*.html": "unlisted-page",
-  "*/index.html": "unlisted-page",
-  "*.[jt]s": "unlisted-script",
-  "*/index.ts": "unlisted-script",
-  [`*.${CSS_EXTENSIONS_PATTERN}`]: "unlisted-style",
-  [`*/index.${CSS_EXTENSIONS_PATTERN}`]: "unlisted-style",
-  // Don't warn about any files in subdirectories, like CSS or JS entrypoints for HTML files or tests
-  "*/**": "ignored"
-};
-var CONTENT_SCRIPT_OUT_DIR = "content-scripts";
 
-// src/core/utils/building/generate-wxt-dir.ts
-var import_unimport3 = require("unimport");
-var import_fs_extra6 = __toESM(require("fs-extra"), 1);
-var import_path6 = require("path");
-var import_node_path6 = __toESM(require("path"), 1);
+// src/core/utils/network.ts
+var import_node_dns = __toESM(require("dns"), 1);
 
-// src/core/utils/i18n.ts
-var predefinedMessages = {
-  "@@extension_id": {
-    message: "<browser.runtime.id>",
-    description: "The extension or app ID; you might use this string to construct URLs for resources inside the extension. Even unlocalized extensions can use this message.\nNote: You can't use this message in a manifest file."
-  },
-  "@@ui_locale": {
-    message: "<browser.i18n.getUiLocale()>",
-    description: ""
-  },
-  "@@bidi_dir": {
-    message: "<ltr|rtl>",
-    description: 'The text direction for the current locale, either "ltr" for left-to-right languages such as English or "rtl" for right-to-left languages such as Japanese.'
-  },
-  "@@bidi_reversed_dir": {
-    message: "<rtl|ltr>",
-    description: `If the @@bidi_dir is "ltr", then this is "rtl"; otherwise, it's "ltr".`
-  },
-  "@@bidi_start_edge": {
-    message: "<left|right>",
-    description: `If the @@bidi_dir is "ltr", then this is "left"; otherwise, it's "right".`
-  },
-  "@@bidi_end_edge": {
-    message: "<right|left>",
-    description: `If the @@bidi_dir is "ltr", then this is "right"; otherwise, it's "left".`
-  }
-};
-function parseI18nMessages(messagesJson) {
-  return Object.entries({
-    ...predefinedMessages,
-    ...messagesJson
-  }).map(([name, details]) => ({
-    name,
-    ...details
-  }));
+// src/core/utils/time.ts
+function formatDuration(duration) {
+  if (duration < 1e3)
+    return `${duration} ms`;
+  if (duration < 1e4)
+    return `${(duration / 1e3).toFixed(3)} s`;
+  if (duration < 6e4)
+    return `${(duration / 1e3).toFixed(1)} s`;
+  return `${(duration / 1e3).toFixed(0)} s`;
+}
+function withTimeout(promise, duration) {
+  return new Promise((res, rej) => {
+    const timeout = setTimeout(() => {
+      rej(`Promise timed out after ${duration}ms`);
+    }, duration);
+    promise.then(res).catch(rej).finally(() => clearTimeout(timeout));
+  });
+}
+
+// src/core/utils/network.ts
+function isOffline() {
+  const isOffline2 = new Promise((res) => {
+    import_node_dns.default.resolve("google.com", (err) => {
+      if (err == null) {
+        res(false);
+      } else {
+        res(true);
+      }
+    });
+  });
+  return withTimeout(isOffline2, 1e3).catch(() => true);
+}
+async function isOnline() {
+  const offline = await isOffline();
+  return !offline;
 }
-
-// src/core/utils/building/generate-wxt-dir.ts
-async function generateTypesDir(entrypoints, config) {
-  await import_fs_extra6.default.ensureDir(config.typesDir);
-  const references = [];
-  const imports = getUnimportOptions(config);
-  if (imports !== false) {
-    references.push(await writeImportsDeclarationFile(config, imports));
+async function fetchCached(url2, config) {
+  let content = "";
+  if (await isOnline()) {
+    const res = await fetch(url2);
+    if (res.status < 300) {
+      content = await res.text();
+      await config.fsCache.set(url2, content);
+    } else {
+      config.logger.debug(
+        `Failed to download "${url2}", falling back to cache...`
+      );
+    }
   }
-  references.push(await writePathsDeclarationFile(entrypoints, config));
-  references.push(await writeI18nDeclarationFile(config));
-  references.push(await writeGlobalsDeclarationFile(config));
-  const mainReference = await writeMainDeclarationFile(references, config);
-  await writeTsConfigFile(mainReference, config);
+  if (!content)
+    content = await config.fsCache.get(url2) ?? "";
+  if (!content)
+    throw Error(
+      `Offline and "${url2}" has not been cached. Try again when online.`
+    );
+  return content;
 }
-async function writeImportsDeclarationFile(config, unimportOptions) {
-  const filePath = (0, import_path6.resolve)(config.typesDir, "imports.d.ts");
-  const unimport2 = (0, import_unimport3.createUnimport)(unimportOptions);
-  await unimport2.scanImportsFromDir(void 0, { cwd: config.srcDir });
-  await writeFileIfDifferent(
-    filePath,
-    ["// Generated by wxt", await unimport2.generateTypeDeclarations()].join(
-      "\n"
-    ) + "\n"
-  );
-  return filePath;
+
+// src/core/builders/vite/plugins/download.ts
+function download(config) {
+  return {
+    name: "wxt:download",
+    resolveId(id) {
+      if (id.startsWith("url:"))
+        return "\0" + id;
+    },
+    async load(id) {
+      if (!id.startsWith("\0url:"))
+        return;
+      const url2 = id.replace("\0url:", "");
+      return await fetchCached(url2, config);
+    }
+  };
 }
-async function writePathsDeclarationFile(entrypoints, config) {
-  const filePath = (0, import_path6.resolve)(config.typesDir, "paths.d.ts");
-  const unions = entrypoints.map(
-    (entry) => getEntrypointBundlePath(
-      entry,
-      config.outDir,
-      entry.inputPath.endsWith(".html") ? ".html" : ".js"
-    )
-  ).concat(await getPublicFiles(config)).map(normalizePath).map((path11) => `    | "/${path11}"`).sort().join("\n");
-  const template = `// Generated by wxt
-import "wxt/browser";
 
-declare module "wxt/browser" {
-  export type PublicPath =
-{{ union }}
-  export interface WxtRuntime extends Runtime.Static {
-    getURL(path: PublicPath): string;
-  }
+// src/core/builders/vite/plugins/multipageMove.ts
+var import_node_path5 = require("path");
+var import_fs_extra6 = __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_path5.extname)(oldBundlePath)
+        );
+        if (newBundlePath === oldBundlePath) {
+          config.logger.debug(
+            "HTML file is already in the correct location",
+            oldBundlePath
+          );
+          continue;
+        }
+        const oldAbsPath = (0, import_node_path5.resolve)(config.outDir, oldBundlePath);
+        const newAbsPath = (0, import_node_path5.resolve)(config.outDir, newBundlePath);
+        await (0, import_fs_extra6.ensureDir)((0, import_node_path5.dirname)(newAbsPath));
+        await import_fs_extra6.default.move(oldAbsPath, newAbsPath, { overwrite: true });
+        const renamedChunk = {
+          ...bundle[oldBundlePath],
+          fileName: newBundlePath
+        };
+        delete bundle[oldBundlePath];
+        bundle[newBundlePath] = renamedChunk;
+      }
+      removeEmptyDirs(config.outDir);
+    }
+  };
 }
-`;
-  await writeFileIfDifferent(
-    filePath,
-    template.replace("{{ union }}", unions || "    | never")
-  );
-  return filePath;
+async function removeEmptyDirs(dir) {
+  const files = await import_fs_extra6.default.readdir(dir);
+  for (const file of files) {
+    const filePath = (0, import_node_path5.join)(dir, file);
+    const stats = await import_fs_extra6.default.stat(filePath);
+    if (stats.isDirectory()) {
+      await removeEmptyDirs(filePath);
+    }
+  }
+  try {
+    await import_fs_extra6.default.rmdir(dir);
+  } catch {
+  }
 }
-async function writeI18nDeclarationFile(config) {
-  const filePath = (0, import_path6.resolve)(config.typesDir, "i18n.d.ts");
-  const defaultLocale = config.manifest.default_locale;
-  const template = `// Generated by wxt
-import "wxt/browser";
 
-declare module "wxt/browser" {
-  /**
-   * See https://developer.chrome.com/docs/extensions/reference/i18n/#method-getMessage
-   */
-  interface GetMessageOptions {
-    /**
-     * See https://developer.chrome.com/docs/extensions/reference/i18n/#method-getMessage
-     */
-    escapeLt?: boolean
-  }
+// src/core/builders/vite/plugins/unimport.ts
+var import_unimport3 = require("unimport");
+var import_path5 = require("path");
+var ENABLED_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".js",
+  ".jsx",
+  ".ts",
+  ".tsx",
+  ".vue",
+  ".svelte"
+]);
+function unimport(config) {
+  const options = getUnimportOptions(config);
+  if (options === false)
+    return [];
+  const unimport2 = (0, import_unimport3.createUnimport)(options);
+  return {
+    name: "wxt:unimport",
+    async config() {
+      await unimport2.scanImportsFromDir(void 0, { cwd: config.srcDir });
+    },
+    async transform(code, id) {
+      if (id.includes("node_modules"))
+        return;
+      if (!ENABLED_EXTENSIONS.has((0, import_path5.extname)(id)))
+        return;
+      return unimport2.injectImports(code, id);
+    }
+  };
+}
 
-  export interface WxtI18n extends I18n.Static {
-{{ overrides }}
-  }
+// src/core/builders/vite/plugins/virtualEntrypoint.ts
+var import_fs_extra7 = __toESM(require("fs-extra"), 1);
+var import_path6 = 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_extra7.default.readFile(
+        (0, import_path6.resolve)(
+          config.root,
+          `node_modules/wxt/dist/virtual/${type}-entrypoint.js`
+        ),
+        "utf-8"
+      );
+      return template.replace(`virtual:user-${type}`, inputPath);
+    }
+  };
 }
-`;
-  let messages;
-  if (defaultLocale) {
-    const defaultLocalePath = import_node_path6.default.resolve(
-      config.publicDir,
-      "_locales",
-      defaultLocale,
-      "messages.json"
-    );
-    const content = JSON.parse(await import_fs_extra6.default.readFile(defaultLocalePath, "utf-8"));
-    messages = parseI18nMessages(content);
-  } else {
-    messages = parseI18nMessages({});
-  }
-  const overrides = messages.map((message) => {
-    return `    /**
-     * ${message.description ?? "No message description."}
-     *
-     * "${message.message}"
-     */
-    getMessage(
-      messageName: "${message.name}",
-      substitutions?: string | string[],
-      options?: GetMessageOptions,
-    ): string;`;
-  });
-  await writeFileIfDifferent(
-    filePath,
-    template.replace("{{ overrides }}", overrides.join("\n"))
-  );
-  return filePath;
+
+// src/core/builders/vite/plugins/tsconfigPaths.ts
+function tsconfigPaths(config) {
+  return {
+    name: "wxt:aliases",
+    async config() {
+      return {
+        resolve: {
+          alias: config.alias
+        }
+      };
+    }
+  };
 }
-async function writeGlobalsDeclarationFile(config) {
-  const filePath = (0, import_path6.resolve)(config.typesDir, "globals.d.ts");
-  const globals2 = [...getGlobals(config), ...getEntrypointGlobals(config, "")];
-  await writeFileIfDifferent(
-    filePath,
-    [
-      "// Generated by wxt",
-      "export {}",
-      "declare global {",
-      ...globals2.map((global3) => `  const ${global3.name}: ${global3.type};`),
-      "}"
-    ].join("\n") + "\n"
-  );
-  return filePath;
+
+// 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/client';
+export default defineBackground(() => void 0)`;
+      }
+    }
+  };
 }
-async function writeMainDeclarationFile(references, config) {
-  const dir = config.wxtDir;
-  const filePath = (0, import_path6.resolve)(dir, "wxt.d.ts");
-  await writeFileIfDifferent(
-    filePath,
-    [
-      "// Generated by wxt",
-      `/// <reference types="vite/client" />`,
-      ...references.map(
-        (ref) => `/// <reference types="./${normalizePath((0, import_path6.relative)(dir, ref))}" />`
-      )
-    ].join("\n") + "\n"
-  );
-  return filePath;
+
+// 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];
+      });
+    }
+  };
 }
-async function writeTsConfigFile(mainReference, config) {
-  const dir = config.wxtDir;
-  const getTsconfigPath = (path11) => normalizePath((0, import_path6.relative)(dir, path11));
-  const paths = Object.entries(config.alias).flatMap(([alias, absolutePath]) => {
-    const aliasPath = getTsconfigPath(absolutePath);
-    return [
-      `      "${alias}": ["${aliasPath}"]`,
-      `      "${alias}/*": ["${aliasPath}/*"]`
-    ];
-  }).join(",\n");
-  await writeFileIfDifferent(
-    (0, import_path6.resolve)(dir, "tsconfig.json"),
-    `{
-  "compilerOptions": {
-    "target": "ESNext",
-    "module": "ESNext",
-    "moduleResolution": "Bundler",
-    "noEmit": true,
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "paths": {
-${paths}
+
+// src/core/builders/vite/plugins/bundleAnalysis.ts
+var import_rollup_plugin_visualizer = require("rollup-plugin-visualizer");
+var increment = 0;
+function bundleAnalysis() {
+  return (0, import_rollup_plugin_visualizer.visualizer)({
+    emitFile: true,
+    template: "raw-data",
+    filename: `stats-${increment++}.json`
+  });
+}
+
+// src/core/builders/vite/plugins/globals.ts
+function globals(config) {
+  return {
+    name: "wxt:globals",
+    config() {
+      const define = {};
+      for (const global3 of getGlobals(config)) {
+        define[global3.name] = JSON.stringify(global3.value);
+      }
+      return {
+        define
+      };
     }
-  },
-  "include": [
-    "${getTsconfigPath(config.root)}/**/*",
-    "./${getTsconfigPath(mainReference)}"
-  ],
-  "exclude": ["${getTsconfigPath(config.outBaseDir)}"]
-}`
-  );
+  };
 }
 
-// src/core/utils/building/get-internal-config.ts
-var import_c12 = require("c12");
-var import_node_path7 = __toESM(require("path"), 1);
-var vite2 = __toESM(require("vite"), 1);
+// src/core/builders/vite/plugins/webextensionPolyfillAlias.ts
+var import_node_path6 = __toESM(require("path"), 1);
 
-// src/core/utils/cache.ts
-var import_fs_extra7 = __toESM(require("fs-extra"), 1);
-var import_path7 = require("path");
-function createFsCache(wxtDir) {
-  const getPath = (key) => (0, import_path7.resolve)(wxtDir, "cache", encodeURIComponent(key));
+// src/core/builders/vite/plugins/excludeBrowserPolyfill.ts
+function excludeBrowserPolyfill(config) {
+  const virtualId = "virtual:wxt-webextension-polyfill-disabled";
   return {
-    async set(key, value) {
-      const path11 = getPath(key);
-      await (0, import_fs_extra7.ensureDir)((0, import_path7.dirname)(path11));
-      await writeFileIfDifferent(path11, value);
+    name: "wxt:exclude-browser-polyfill",
+    config() {
+      if (config.experimental.includeBrowserPolyfill)
+        return;
+      return {
+        resolve: {
+          alias: {
+            "webextension-polyfill": virtualId
+          }
+        }
+      };
     },
-    async get(key) {
-      const path11 = getPath(key);
-      try {
-        return await import_fs_extra7.default.readFile(path11, "utf-8");
-      } catch {
-        return void 0;
+    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 global3 of getEntrypointGlobals(name)) {
+        define[global3.name] = JSON.stringify(global3.value);
+      }
+      return {
+        define
+      };
+    }
+  };
+}
+
+// src/core/builders/vite/index.ts
+async function craeteViteBuilder(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;
+    config.plugins ??= [];
+    config.plugins.push(
+      download(wxtConfig),
+      devHtmlPrerender(wxtConfig),
+      unimport(wxtConfig),
+      virtualEntrypoint("background", wxtConfig),
+      virtualEntrypoint("content-script", wxtConfig),
+      virtualEntrypoint("unlisted-script", wxtConfig),
+      devServerGlobals(wxtConfig),
+      tsconfigPaths(wxtConfig),
+      noopBackground(),
+      globals(wxtConfig),
+      excludeBrowserPolyfill(wxtConfig)
+    );
+    if (wxtConfig.analysis.enabled) {
+      config.plugins.push(bundleAnalysis());
+    }
+    return config;
+  };
+  const getLibModeConfig = (entrypoint) => {
+    const isVirtual = [
+      "background",
+      "content-script",
+      "unlisted-script"
+    ].includes(entrypoint.type);
+    const entry = isVirtual ? `virtual:wxt-${entrypoint.type}?${entrypoint.inputPath}` : entrypoint.inputPath;
+    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) => {
+    return {
+      mode: wxtConfig.mode,
+      plugins: [
+        multipageMove(entrypoints, wxtConfig),
+        entrypointGroupGlobals(entrypoints)
+      ],
+      build: {
+        rollupOptions: {
+          input: entrypoints.reduce((input, entry) => {
+            input[entry.name] = entry.inputPath;
+            return input;
+          }, {}),
+          output: {
+            // Include a hash to prevent conflicts
+            chunkFileNames: "chunks/[name]-[hash].js",
+            // Include a hash to prevent conflicts
+            entryFileNames: "chunks/[name]-[hash].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);
+        },
+        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;
+}
 
 // src/core/utils/building/get-internal-config.ts
-var import_consola = __toESM(require("consola"), 1);
-var import_defu = __toESM(require("defu"), 1);
-async function getInternalConfig(inlineConfig, command) {
+var import_defu2 = __toESM(require("defu"), 1);
+async function getInternalConfig(inlineConfig, command, server) {
   let userConfig = {};
   let userConfigMetadata;
   if (inlineConfig.configFile !== false) {
@@ -3826,7 +3924,7 @@ async function getInternalConfig(inlineConfig, command) {
   );
   const publicDir = import_node_path7.default.resolve(srcDir, mergedConfig.publicDir ?? "public");
   const typesDir = import_node_path7.default.resolve(wxtDir, "types");
-  const outBaseDir = import_node_path7.default.resolve(root, ".output");
+  const outBaseDir = import_node_path7.default.resolve(root, mergedConfig.outDir ?? ".output");
   const outDir = import_node_path7.default.resolve(outBaseDir, `${browser}-mv${manifestVersion}`);
   const runnerConfig = await (0, import_c12.loadConfig)({
     name: "web-ext",
@@ -3864,8 +3962,6 @@ async function getInternalConfig(inlineConfig, command) {
     runnerConfig,
     srcDir,
     typesDir,
-    vite: () => ({}),
-    // Real value added after this object is initialized.
     wxtDir,
     zip: resolveInternalZipConfig(root, mergedConfig),
     transformManifest(manifest) {
@@ -3880,10 +3976,18 @@ async function getInternalConfig(inlineConfig, command) {
     alias,
     experimental: {
       includeBrowserPolyfill: mergedConfig.experimental?.includeBrowserPolyfill ?? true
-    }
+    },
+    server
+  };
+  const builder = await craeteViteBuilder(
+    inlineConfig,
+    userConfig,
+    finalConfig
+  );
+  return {
+    ...finalConfig,
+    builder
   };
-  finalConfig.vite = (env2) => resolveInternalViteConfig(env2, mergedConfig, finalConfig);
-  return finalConfig;
 }
 async function resolveManifestConfig(env, manifest) {
   return await (typeof manifest === "function" ? manifest(env) : manifest ?? {});
@@ -3895,26 +3999,18 @@ function mergeInlineConfig(inlineConfig, userConfig) {
   } else if (userConfig.imports == null && inlineConfig.imports == null) {
     imports = void 0;
   } else {
-    imports = vite2.mergeConfig(
-      userConfig.imports ?? {},
-      inlineConfig.imports ?? {}
-    );
+    imports = (0, import_defu2.default)(inlineConfig.imports ?? {}, userConfig.imports ?? {});
   }
   const manifest = async (env) => {
     const user = await resolveManifestConfig(env, userConfig.manifest);
     const inline = await resolveManifestConfig(env, inlineConfig.manifest);
-    return vite2.mergeConfig(user, inline);
-  };
-  const viteConfig = async (env) => {
-    const user = await userConfig.vite?.(env);
-    const inline = await inlineConfig.vite?.(env);
-    return vite2.mergeConfig(user ?? {}, inline ?? {});
+    return (0, import_defu2.default)(inline, user);
   };
-  const runner = (0, import_defu.default)(
+  const runner = (0, import_defu2.default)(
     inlineConfig.runner ?? {},
     userConfig.runner ?? {}
   );
-  const zip2 = (0, import_defu.default)(
+  const zip2 = (0, import_defu2.default)(
     inlineConfig.zip ?? {},
     userConfig.zip ?? {}
   );
@@ -3932,7 +4028,7 @@ function mergeInlineConfig(inlineConfig, userConfig) {
     publicDir: inlineConfig.publicDir ?? userConfig.publicDir,
     runner,
     srcDir: inlineConfig.srcDir ?? userConfig.srcDir,
-    vite: viteConfig,
+    outDir: inlineConfig.outDir ?? userConfig.outDir,
     zip: zip2,
     analysis: {
       enabled: inlineConfig.analysis?.enabled ?? userConfig.analysis?.enabled,
@@ -3945,11 +4041,14 @@ function mergeInlineConfig(inlineConfig, userConfig) {
     experimental: {
       ...userConfig.experimental,
       ...inlineConfig.experimental
-    }
+    },
+    vite: void 0,
+    transformManifest: void 0
   };
 }
 function resolveInternalZipConfig(root, mergedConfig) {
   return {
+    name: void 0,
     sourcesTemplate: "{{name}}-{{version}}-sources.zip",
     artifactTemplate: "{{name}}-{{version}}-{{browser}}.zip",
     sourcesRoot: root,
@@ -3968,38 +4067,6 @@ function resolveInternalZipConfig(root, mergedConfig) {
     ]
   };
 }
-async function resolveInternalViteConfig(env, mergedConfig, finalConfig) {
-  const internalVite = await mergedConfig.vite?.(env) ?? {};
-  internalVite.root = finalConfig.root;
-  internalVite.configFile = false;
-  internalVite.logLevel = "warn";
-  internalVite.mode = env.mode;
-  internalVite.build ??= {};
-  internalVite.build.outDir = finalConfig.outDir;
-  internalVite.build.emptyOutDir = false;
-  internalVite.plugins ??= [];
-  internalVite.plugins.push(download(finalConfig));
-  internalVite.plugins.push(devHtmlPrerender(finalConfig));
-  internalVite.plugins.push(unimport(finalConfig));
-  internalVite.plugins.push(
-    virtualEntrypoint("background", finalConfig)
-  );
-  internalVite.plugins.push(
-    virtualEntrypoint("content-script", finalConfig)
-  );
-  internalVite.plugins.push(
-    virtualEntrypoint("unlisted-script", finalConfig)
-  );
-  internalVite.plugins.push(devServerGlobals(finalConfig));
-  internalVite.plugins.push(tsconfigPaths(finalConfig));
-  internalVite.plugins.push(noopBackground());
-  if (finalConfig.analysis.enabled) {
-    internalVite.plugins.push(bundleAnalysis());
-  }
-  internalVite.plugins.push(globals(finalConfig));
-  internalVite.plugins.push(excludeBrowserPolyfill(finalConfig));
-  return internalVite;
-}
 
 // src/core/utils/building/group-entrypoints.ts
 function groupEntrypoints(entrypoints) {
@@ -4041,7 +4108,7 @@ var ENTRY_TYPE_TO_GROUP_MAP = {
 var import_jiti = __toESM(require("jiti"), 1);
 var import_unimport5 = require("unimport");
 var import_fs_extra8 = __toESM(require("fs-extra"), 1);
-var import_path8 = require("path");
+var import_path7 = require("path");
 
 // src/core/utils/strings.ts
 function kebabCaseAlphanumeric(str) {
@@ -4063,16 +4130,16 @@ ${noImports}`;
 
 // src/core/utils/building/import-entrypoint.ts
 var import_esbuild = require("esbuild");
-async function importEntrypointFile(path11, config) {
-  config.logger.debug("Loading file metadata:", path11);
-  const normalPath = normalizePath(path11);
+async function importEntrypointFile(path10, config) {
+  config.logger.debug("Loading file metadata:", path10);
+  const normalPath = normalizePath(path10);
   const unimport2 = (0, import_unimport5.createUnimport)({
     ...getUnimportOptions(config),
     // Only allow specific imports, not all from the project
     dirs: []
   });
   await unimport2.init();
-  const text = await import_fs_extra8.default.readFile(path11, "utf-8");
+  const text = await import_fs_extra8.default.readFile(path10, "utf-8");
   const textNoImports = removeProjectImportStatements(text);
   const { code } = await unimport2.injectImports(textNoImports);
   config.logger.debug(
@@ -4083,7 +4150,7 @@ async function importEntrypointFile(path11, config) {
     debug: config.debug,
     esmResolve: true,
     alias: {
-      "webextension-polyfill": (0, import_path8.resolve)(
+      "webextension-polyfill": (0, import_path7.resolve)(
         config.root,
         "node_modules/wxt/dist/virtual/mock-browser.js"
       )
@@ -4103,7 +4170,7 @@ async function importEntrypointFile(path11, config) {
     }
   });
   try {
-    const res = await jiti(path11);
+    const res = await jiti(path10);
     return res.default;
   } catch (err) {
     config.logger.error(err);
@@ -4121,11 +4188,10 @@ function getEsbuildOptions(opts) {
 
 // src/core/utils/building/internal-build.ts
 var import_picocolors4 = __toESM(require("picocolors"), 1);
-var vite3 = __toESM(require("vite"), 1);
 var import_fs_extra12 = __toESM(require("fs-extra"), 1);
 
 // src/core/utils/log/printBuildSummary.ts
-var import_path9 = require("path");
+var import_path8 = require("path");
 
 // src/core/utils/log/printFileList.ts
 var import_node_path8 = __toESM(require("path"), 1);
@@ -4212,7 +4278,7 @@ async function printBuildSummary(log, header, output, config) {
       return diff;
     return l.fileName.localeCompare(r.fileName);
   });
-  const files = chunks.map((chunk) => (0, import_path9.resolve)(config.outDir, chunk.fileName));
+  const files = chunks.map((chunk) => (0, import_path8.resolve)(config.outDir, chunk.fileName));
   await printFileList(log, header, config.outDir, files);
 }
 var DEFAULT_SORT_WEIGHT = 100;
@@ -4233,7 +4299,7 @@ function getChunkSortWeight(filename) {
 var import_picocolors3 = __toESM(require("picocolors"), 1);
 
 // package.json
-var version = "0.10.3";
+var version = "0.11.0";
 
 // src/core/utils/log/printHeader.ts
 var import_consola2 = require("consola");
@@ -4243,7 +4309,7 @@ var import_fast_glob3 = __toESM(require("fast-glob"), 1);
 
 // src/core/utils/manifest.ts
 var import_fs_extra11 = __toESM(require("fs-extra"), 1);
-var import_path10 = require("path");
+var import_path9 = require("path");
 
 // src/core/utils/content-security-policy.ts
 var ContentSecurityPolicy = class _ContentSecurityPolicy {
@@ -4363,37 +4429,34 @@ async function getPackageJson(config) {
 
 // src/core/utils/manifest.ts
 var import_immer = require("immer");
-var import_defu2 = __toESM(require("defu"), 1);
+var import_defu3 = __toESM(require("defu"), 1);
 async function writeManifest(manifest, output, config) {
   const str = config.mode === "production" ? JSON.stringify(manifest) : JSON.stringify(manifest, null, 2);
   await import_fs_extra11.default.ensureDir(config.outDir);
-  await writeFileIfDifferent((0, import_path10.resolve)(config.outDir, "manifest.json"), str);
+  await writeFileIfDifferent((0, import_path9.resolve)(config.outDir, "manifest.json"), str);
   output.publicAssets.unshift({
     type: "asset",
-    fileName: "manifest.json",
-    name: "manifest",
-    needsCodeReference: false,
-    source: str
+    fileName: "manifest.json"
   });
 }
 async function generateMainfest(entrypoints, buildOutput, config) {
   const pkg = await getPackageJson(config);
   const versionName = config.manifest.version_name ?? pkg?.version;
-  const version3 = config.manifest.version ?? simplifyVersion(pkg?.version);
+  const version2 = config.manifest.version ?? simplifyVersion(pkg?.version);
   const baseManifest = {
     manifest_version: config.manifestVersion,
     name: pkg?.name,
     description: pkg?.description,
-    version: version3,
+    version: version2,
     version_name: (
       // Firefox doesn't support version_name
-      config.browser === "firefox" || versionName === version3 ? void 0 : versionName
+      config.browser === "firefox" || versionName === version2 ? void 0 : versionName
     ),
     short_name: pkg?.shortName,
     icons: discoverIcons(buildOutput)
   };
   const userManifest = config.manifest;
-  const manifest = (0, import_defu2.default)(
+  const manifest = (0, import_defu3.default)(
     userManifest,
     baseManifest
   );
@@ -4415,14 +4478,14 @@ async function generateMainfest(entrypoints, buildOutput, config) {
   return finalManifest;
 }
 function simplifyVersion(versionName) {
-  const version3 = /^((0|[1-9][0-9]{0,8})([.](0|[1-9][0-9]{0,8})){0,3}).*$/.exec(
+  const version2 = /^((0|[1-9][0-9]{0,8})([.](0|[1-9][0-9]{0,8})){0,3}).*$/.exec(
     versionName
   )?.[1];
-  if (version3 == null)
+  if (version2 == null)
     throw Error(
       `Cannot simplify package.json version "${versionName}" to a valid extension version, "X.Y.Z"`
     );
-  return version3;
+  return version2;
 }
 function addEntrypoints(manifest, entrypoints, buildOutput, config) {
   const entriesByType = entrypoints.reduce((map, entrypoint) => {
@@ -4794,7 +4857,7 @@ async function internalBuild(config) {
   const target = `${config.browser}-mv${config.manifestVersion}`;
   config.logger.info(
     `${verb} ${import_picocolors4.default.cyan(target)} for ${import_picocolors4.default.cyan(config.mode)} with ${import_picocolors4.default.green(
-      `Vite ${vite3.version}`
+      `${config.builder.name} ${config.builder.version}`
     )}`
   );
   const startTime = Date.now();
@@ -4833,7 +4896,7 @@ async function combineAnalysisStats(config) {
 }
 
 // src/core/build.ts
-async function build2(config) {
+async function build(config) {
   const internalConfig = await getInternalConfig(config ?? {}, "build");
   return await internalBuild(internalConfig);
 }
@@ -4883,9 +4946,6 @@ function defineRunnerConfig(config) {
   return config;
 }
 
-// src/core/create-server.ts
-var vite4 = __toESM(require("vite"), 1);
-
 // src/core/runners/wsl.ts
 var import_node_path13 = require("path");
 function createWslRunner() {
@@ -5019,29 +5079,77 @@ var import_consola4 = require("consola");
 var import_async_mutex = require("async-mutex");
 var import_picocolors6 = __toESM(require("picocolors"), 1);
 var import_node_path16 = require("path");
-async function createServer2(config) {
-  const serverInfo = await getServerInfo();
-  const getLatestInternalConfig = async () => {
-    return getInternalConfig(
-      {
-        ...config,
-        vite: () => serverInfo.viteServerConfig
-      },
-      "serve"
-    );
+async function createServer(inlineConfig) {
+  const port = await getPort();
+  const hostname = "localhost";
+  const origin = `http://${hostname}:${port}`;
+  const serverInfo = {
+    port,
+    hostname,
+    origin
   };
-  let internalConfig = await getLatestInternalConfig();
-  const server = await setupServer(serverInfo, internalConfig);
-  internalConfig.server = server;
-  const fileChangedMutex = new import_async_mutex.Mutex();
-  const changeQueue = [];
+  const server = {
+    ...serverInfo,
+    watcher: void 0,
+    // Filled out later down below
+    ws: void 0,
+    // Filled out later down below
+    currentOutput: void 0,
+    // Filled out later down below
+    async start() {
+      await builderServer.listen();
+      config.logger.success(`Started dev server @ ${serverInfo.origin}`);
+      server.currentOutput = await internalBuild(config);
+      await runner.openBrowser(config);
+    },
+    transformHtml(url2, html, originalUrl) {
+      return builderServer.transformHtml(url2, html, originalUrl);
+    },
+    reloadContentScript(contentScript) {
+      server.ws.send("wxt:reload-content-script", contentScript);
+    },
+    reloadPage(path10) {
+      server.ws.send("wxt:reload-page", path10);
+    },
+    reloadExtension() {
+      server.ws.send("wxt:reload-extension");
+    }
+  };
+  const getLatestConfig = () => getInternalConfig(inlineConfig ?? {}, "serve", server);
+  let config = await getLatestConfig();
+  const [runner, builderServer] = await Promise.all([
+    createExtensionRunner(config),
+    config.builder.createServer(server)
+  ]);
+  server.watcher = builderServer.watcher;
+  server.ws = builderServer.ws;
   server.ws.on("wxt:background-initialized", () => {
-    reloadContentScripts(server.currentOutput.steps, internalConfig, server);
+    reloadContentScripts(server.currentOutput.steps, config, server);
+  });
+  const reloadOnChange = createFileReloader({
+    server,
+    getLatestConfig,
+    updateConfig(newConfig) {
+      config = newConfig;
+    }
   });
-  server.watcher.on("all", async (event, path11, _stats) => {
-    if (path11.startsWith(internalConfig.outBaseDir))
+  server.watcher.on("all", reloadOnChange);
+  return server;
+}
+async function getPort() {
+  const { default: getPort2, portNumbers } = await import("get-port");
+  return await getPort2({ port: portNumbers(3e3, 3010) });
+}
+function createFileReloader(options) {
+  const { server, getLatestConfig, updateConfig } = options;
+  const fileChangedMutex = new import_async_mutex.Mutex();
+  const changeQueue = [];
+  return async (event, path10) => {
+    const config = await getLatestConfig();
+    updateConfig(config);
+    if (path10.startsWith(config.outBaseDir))
       return;
-    changeQueue.push([event, path11]);
+    changeQueue.push([event, path10]);
     await fileChangedMutex.runExclusive(async () => {
       const fileChanges = changeQueue.splice(0, changeQueue.length);
       if (fileChanges.length === 0)
@@ -5049,18 +5157,16 @@ async function createServer2(config) {
       const changes = detectDevChanges(fileChanges, server.currentOutput);
       if (changes.type === "no-change")
         return;
-      internalConfig.logger.info(
-        `Changed: ${Array.from(new Set(fileChanges.map((change) => change[1]))).map((file) => import_picocolors6.default.dim((0, import_node_path16.relative)(internalConfig.root, file))).join(", ")}`
+      config.logger.info(
+        `Changed: ${Array.from(new Set(fileChanges.map((change) => change[1]))).map((file) => import_picocolors6.default.dim((0, import_node_path16.relative)(config.root, file))).join(", ")}`
       );
       const rebuiltNames = changes.rebuildGroups.flat().map((entry) => {
         return import_picocolors6.default.cyan(
-          (0, import_node_path16.relative)(internalConfig.outDir, getEntrypointOutputFile(entry, ""))
+          (0, import_node_path16.relative)(config.outDir, getEntrypointOutputFile(entry, ""))
         );
       }).join(import_picocolors6.default.dim(", "));
-      internalConfig = await getLatestInternalConfig();
-      internalConfig.server = server;
       const { output: newOutput } = await rebuild(
-        internalConfig,
+        config,
         // TODO: this excludes new entrypoints, so they're not built until the dev command is restarted
         changes.rebuildGroups,
         changes.cachedOutput
@@ -5071,74 +5177,15 @@ async function createServer2(config) {
           server.reloadExtension();
           break;
         case "html-reload":
-          reloadHtmlPages(changes.rebuildGroups, server, internalConfig);
+          reloadHtmlPages(changes.rebuildGroups, server, config);
           break;
         case "content-script-reload":
-          reloadContentScripts(changes.changedSteps, internalConfig, server);
+          reloadContentScripts(changes.changedSteps, config, server);
           break;
       }
       import_consola4.consola.success(`Reloaded: ${rebuiltNames}`);
     });
-  });
-  return server;
-}
-async function getServerInfo() {
-  const { default: getPort, portNumbers } = await import("get-port");
-  const port = await getPort({ port: portNumbers(3e3, 3010) });
-  const hostname = "localhost";
-  const origin = `http://${hostname}:${port}`;
-  const serverConfig = {
-    server: {
-      origin
-    }
-  };
-  return {
-    port,
-    hostname,
-    origin,
-    viteServerConfig: serverConfig
-  };
-}
-async function setupServer(serverInfo, config) {
-  const runner = await createExtensionRunner(config);
-  const viteServer = await vite4.createServer(
-    vite4.mergeConfig(serverInfo, await config.vite(config.env))
-  );
-  const start = async () => {
-    await viteServer.listen(server.port);
-    config.logger.success(`Started dev server @ ${serverInfo.origin}`);
-    server.currentOutput = await internalBuild(config);
-    await runner.openBrowser(config);
   };
-  const reloadExtension = () => {
-    viteServer.ws.send("wxt:reload-extension");
-  };
-  const reloadPage = (path11) => {
-    viteServer.ws.send("wxt:reload-page", path11);
-  };
-  const reloadContentScript = (contentScript) => {
-    viteServer.ws.send("wxt:reload-content-script", contentScript);
-  };
-  const server = {
-    ...viteServer,
-    start,
-    currentOutput: {
-      manifest: {
-        manifest_version: 3,
-        name: "",
-        version: ""
-      },
-      publicAssets: [],
-      steps: []
-    },
-    port: serverInfo.port,
-    hostname: serverInfo.hostname,
-    origin: serverInfo.origin,
-    reloadExtension,
-    reloadPage,
-    reloadContentScript
-  };
-  return server;
 }
 function reloadContentScripts(steps, config, server) {
   if (config.manifestVersion === 3) {
@@ -5172,8 +5219,8 @@ function reloadContentScripts(steps, config, server) {
 }
 function reloadHtmlPages(groups, server, config) {
   groups.flat().forEach((entry) => {
-    const path11 = getEntrypointBundlePath(entry, config.outDir, ".html");
-    server.reloadPage(path11);
+    const path10 = getEntrypointBundlePath(entry, config.outDir, ".html");
+    server.reloadPage(path10);
   });
 }
 
@@ -5355,8 +5402,8 @@ async function zip(config) {
     );
     await (0, import_zip_dir.default)(internalConfig.zip.sourcesRoot, {
       saveTo: sourcesZipPath,
-      filter(path11) {
-        const relativePath = (0, import_node_path18.relative)(internalConfig.zip.sourcesRoot, path11);
+      filter(path10) {
+        const relativePath = (0, import_node_path18.relative)(internalConfig.zip.sourcesRoot, path10);
         const matchedPattern = internalConfig.zip.ignoredSources.find(
           (pattern) => (0, import_minimatch2.minimatch)(relativePath, pattern)
         );