wxt 0.17.8 → 0.17.10

package/dist/{chunk-5XQOZCZF.js → chunk-2SH4GQGN.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-VBXJIVYU.js";
 
 // package.json
-var version = "0.17.8";
+var version = "0.17.10";
 
 // src/core/utils/paths.ts
 import systemPath from "node:path";
@@ -17,187 +17,15 @@ function unnormalizePath(path8) {
 var CSS_EXTENSIONS = ["css", "scss", "sass", "less", "styl", "stylus"];
 var CSS_EXTENSIONS_PATTERN = `+(${CSS_EXTENSIONS.join("|")})`;
 
-// src/core/utils/fs.ts
-import fs from "fs-extra";
-import glob from "fast-glob";
-async function writeFileIfDifferent(file, newContents) {
-  const existingContents = await fs.readFile(file, "utf-8").catch(() => void 0);
-  if (existingContents !== newContents) {
-    await fs.writeFile(file, newContents);
-  }
-}
-async function getPublicFiles() {
-  if (!await fs.exists(wxt.config.publicDir))
-    return [];
-  const files = await glob("**/*", { cwd: wxt.config.publicDir });
-  return files.map(unnormalizePath);
-}
-
-// src/core/utils/building/build-entrypoints.ts
-import fs2 from "fs-extra";
-import { dirname, resolve } from "path";
-import pc from "picocolors";
-async function buildEntrypoints(groups, spinner) {
-  const steps = [];
-  for (let i = 0; i < groups.length; i++) {
-    const group = groups[i];
-    const groupNames = [group].flat().map((e) => e.name);
-    const groupNameColored = groupNames.join(pc.dim(", "));
-    spinner.text = pc.dim(`[${i + 1}/${groups.length}]`) + ` ${groupNameColored}`;
-    try {
-      steps.push(await wxt.config.builder.build(group));
-    } catch (err) {
-      spinner.stop().clear();
-      wxt.logger.error(err);
-      throw Error(`Failed to build ${groupNames.join(", ")}`, { cause: err });
-    }
-  }
-  const publicAssets = await copyPublicDirectory();
-  return { publicAssets, steps };
-}
-async function copyPublicDirectory() {
-  const files = await getPublicFiles();
-  if (files.length === 0)
-    return [];
-  const publicAssets = [];
-  for (const file of files) {
-    const srcPath = resolve(wxt.config.publicDir, file);
-    const outPath = resolve(wxt.config.outDir, file);
-    await fs2.ensureDir(dirname(outPath));
-    await fs2.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;
-}
-function some(array, predicate) {
-  for (let i = 0; i < array.length; i++)
-    if (predicate(array[i], i))
-      return true;
-  return false;
-}
-
-// src/core/utils/building/detect-dev-changes.ts
-function detectDevChanges(changedFiles, currentOutput) {
-  const isConfigChange = some(
-    changedFiles,
-    (file) => file === wxt.config.userConfigMetadata.configFile
-  );
-  if (isConfigChange)
-    return { type: "full-restart" };
-  const isRunnerChange = some(
-    changedFiles,
-    (file) => file === wxt.config.runnerConfig.configFile
-  );
-  if (isRunnerChange)
-    return { type: "browser-restart" };
-  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);
-  const isChunkEffected = (chunk) => (
-    // If it's an HTML file with the same path, is is effected because HTML files need to be re-rendered
-    // - fileName is normalized, relative bundle path, "<entrypoint-name>.html"
-    chunk.type === "asset" && changedPath.replace("/index.html", ".html").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
-import { relative as relative2, resolve as resolve3 } from "path";
-import fs3 from "fs-extra";
-import { minimatch } from "minimatch";
-import { parseHTML } from "linkedom";
-import JSON5 from "json5";
-import glob2 from "fast-glob";
-
 // src/core/utils/entrypoints.ts
-import path, { relative, resolve as resolve2 } from "node:path";
+import path, { relative, resolve } from "node:path";
 function getEntrypointName(entrypointsDir, inputPath) {
   const relativePath = path.relative(entrypointsDir, inputPath);
   const name = relativePath.split(/[\.\/\\]/, 2)[0];
   return name;
 }
 function getEntrypointOutputFile(entrypoint, ext) {
-  return resolve2(entrypoint.outputDir, `${entrypoint.name}${ext}`);
+  return resolve(entrypoint.outputDir, `${entrypoint.name}${ext}`);
 }
 function getEntrypointBundlePath(entrypoint, outDir, ext) {
   return normalizePath(
@@ -221,1439 +49,1382 @@ function isHtmlEntrypoint(entrypoint) {
   return entrypoint.inputPath.endsWith(".html");
 }
 
-// src/core/utils/constants.ts
-var VIRTUAL_NOOP_BACKGROUND_MODULE_ID = "virtual:user-background";
+// 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/building/find-entrypoints.ts
-import pc2 from "picocolors";
-async function findEntrypoints() {
-  const relativePaths = await glob2(Object.keys(PATH_GLOB_TO_TYPE_MAP), {
-    cwd: wxt.config.entrypointsDir
+// src/core/utils/network.ts
+import dns from "node:dns";
+function isOffline() {
+  const isOffline2 = new Promise((res) => {
+    dns.resolve("google.com", (err) => {
+      if (err == null) {
+        res(false);
+      } else {
+        res(true);
+      }
+    });
   });
-  relativePaths.sort();
-  const pathGlobs = Object.keys(PATH_GLOB_TO_TYPE_MAP);
-  const entrypointInfos = relativePaths.reduce((results, relativePath) => {
-    const inputPath = resolve3(wxt.config.entrypointsDir, relativePath);
-    const name = getEntrypointName(wxt.config.entrypointsDir, inputPath);
-    const matchingGlob = pathGlobs.find(
-      (glob4) => minimatch(relativePath, glob4)
+  return withTimeout(isOffline2, 1e3).catch(() => true);
+}
+async function isOnline() {
+  const offline = await isOffline();
+  return !offline;
+}
+async function fetchCached(url, config) {
+  let content = "";
+  if (await isOnline()) {
+    const res = await fetch(url);
+    if (res.status < 300) {
+      content = await res.text();
+      await config.fsCache.set(url, content);
+    } else {
+      config.logger.debug(
+        `Failed to download "${url}", falling back to cache...`
+      );
+    }
+  }
+  if (!content)
+    content = await config.fsCache.get(url) ?? "";
+  if (!content)
+    throw Error(
+      `Offline and "${url}" has not been cached. Try again when online.`
     );
-    if (matchingGlob) {
-      const type = PATH_GLOB_TO_TYPE_MAP[matchingGlob];
-      results.push({
-        name,
-        inputPath,
-        type,
-        skipped: wxt.config.filterEntrypoints != null && !wxt.config.filterEntrypoints.has(name)
-      });
+  return content;
+}
+
+// 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 url = id.replace("\0url:", "");
+      return await fetchCached(url, config);
     }
-    return results;
-  }, []);
-  preventNoEntrypoints(entrypointInfos);
-  preventDuplicateEntrypointNames(entrypointInfos);
-  let hasBackground = false;
-  const entrypoints = await Promise.all(
-    entrypointInfos.map(async (info) => {
-      const { type } = info;
-      switch (type) {
-        case "popup":
-          return await getPopupEntrypoint(info);
-        case "sidepanel":
-          return await getSidepanelEntrypoint(info);
-        case "options":
-          return await getOptionsEntrypoint(info);
-        case "background":
-          hasBackground = true;
-          return await getBackgroundEntrypoint(info);
-        case "content-script":
-          return await getContentScriptEntrypoint(info);
-        case "unlisted-page":
-          return await getUnlistedPageEntrypoint(info);
-        case "unlisted-script":
-          return await getUnlistedScriptEntrypoint(info);
-        case "content-script-style":
-          return {
-            ...info,
-            type,
-            outputDir: resolve3(wxt.config.outDir, CONTENT_SCRIPT_OUT_DIR),
-            options: {
-              include: void 0,
-              exclude: void 0
-            }
-          };
-        default:
-          return {
-            ...info,
-            type,
-            outputDir: wxt.config.outDir,
-            options: {
-              include: void 0,
-              exclude: void 0
-            }
-          };
-      }
-    })
-  );
-  if (wxt.config.command === "serve" && !hasBackground) {
-    entrypoints.push(
-      await getBackgroundEntrypoint({
-        inputPath: VIRTUAL_NOOP_BACKGROUND_MODULE_ID,
-        name: "background",
-        type: "background",
-        skipped: false
-      })
-    );
-  }
-  wxt.logger.debug("All entrypoints:", entrypoints);
-  const skippedEntrypointNames = entrypointInfos.filter((item) => item.skipped).map((item) => item.name);
-  if (skippedEntrypointNames.length) {
-    wxt.logger.warn(
-      `Filter excluded the following entrypoints:
-${skippedEntrypointNames.map((item) => `${pc2.dim("-")} ${pc2.cyan(item)}`).join("\n")}`
-    );
-  }
-  const targetEntrypoints = entrypoints.filter((entry) => {
-    const { include, exclude } = entry.options;
-    if (include?.length && exclude?.length) {
-      wxt.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(wxt.config.browser);
-    }
-    if (include?.length && !exclude?.length) {
-      return include.includes(wxt.config.browser);
+  };
+}
+
+// src/core/builders/vite/plugins/unimport.ts
+import { createUnimport } from "unimport";
+import { extname } from "path";
+var ENABLED_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".js",
+  ".jsx",
+  ".ts",
+  ".tsx",
+  ".vue",
+  ".svelte"
+]);
+function unimport(config) {
+  const options = config.imports;
+  if (options === false)
+    return [];
+  const unimport2 = 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(extname(id)))
+        return;
+      const injected = await unimport2.injectImports(code, id);
+      return {
+        code: injected.code,
+        map: injected.s.generateMap({ hires: "boundary", source: id })
+      };
     }
-    if (skippedEntrypointNames.includes(entry.name)) {
-      return false;
+  };
+}
+
+// src/core/builders/vite/plugins/tsconfigPaths.ts
+function tsconfigPaths(config) {
+  return {
+    name: "wxt:aliases",
+    async config() {
+      return {
+        resolve: {
+          alias: config.alias
+        }
+      };
     }
-    return true;
-  });
-  wxt.logger.debug(`${wxt.config.browser} entrypoints:`, targetEntrypoints);
-  await wxt.hooks.callHook("entrypoints:resolved", wxt, targetEntrypoints);
-  return targetEntrypoints;
+  };
 }
-function preventDuplicateEntrypointNames(files) {
-  const namesToPaths = files.reduce(
-    (map, { name, inputPath }) => {
-      map[name] ??= [];
-      map[name].push(inputPath);
-      return map;
+
+// src/core/utils/globals.ts
+function getGlobals(config) {
+  return [
+    {
+      name: "MANIFEST_VERSION",
+      value: config.manifestVersion,
+      type: `2 | 3`
     },
-    {}
-  );
-  const errorLines = Object.entries(namesToPaths).reduce(
-    (lines, [name, absolutePaths]) => {
-      if (absolutePaths.length > 1) {
-        lines.push(`- ${name}`);
-        absolutePaths.forEach((absolutePath) => {
-          lines.push(`  - ${relative2(wxt.config.root, absolutePath)}`);
-        });
-      }
-      return lines;
+    {
+      name: "BROWSER",
+      value: config.browser,
+      type: `string`
     },
-    []
-  );
-  if (errorLines.length > 0) {
-    const errorContent = errorLines.join("\n");
-    throw Error(
-      `Multiple entrypoints with the same name detected, only one entrypoint for each name is allowed.
-
-${errorContent}`
-    );
-  }
-}
-function preventNoEntrypoints(files) {
-  if (files.length === 0) {
-    throw Error(`No entrypoints found in ${wxt.config.entrypointsDir}`);
-  }
-}
-async function getPopupEntrypoint(info) {
-  const options = await getHtmlEntrypointOptions(
-    info,
     {
-      browserStyle: "browse_style",
-      exclude: "exclude",
-      include: "include",
-      defaultIcon: "default_icon",
-      defaultTitle: "default_title",
-      mv2Key: "type"
+      name: "CHROME",
+      value: config.browser === "chrome",
+      type: `boolean`
     },
     {
-      defaultTitle: (document) => document.querySelector("title")?.textContent || void 0
+      name: "FIREFOX",
+      value: config.browser === "firefox",
+      type: `boolean`
     },
     {
-      defaultTitle: (content) => content,
-      mv2Key: (content) => content === "page_action" ? "page_action" : "browser_action"
+      name: "SAFARI",
+      value: config.browser === "safari",
+      type: `boolean`
+    },
+    {
+      name: "EDGE",
+      value: config.browser === "edge",
+      type: `boolean`
+    },
+    {
+      name: "OPERA",
+      value: config.browser === "opera",
+      type: `boolean`
+    },
+    {
+      name: "COMMAND",
+      value: config.command,
+      type: `"build" | "serve"`
     }
-  );
-  return {
-    type: "popup",
-    name: "popup",
-    options: resolvePerBrowserOptions(options, wxt.config.browser),
-    inputPath: info.inputPath,
-    outputDir: wxt.config.outDir,
-    skipped: info.skipped
-  };
+  ];
 }
-async function getOptionsEntrypoint(info) {
-  const options = await getHtmlEntrypointOptions(
-    info,
+function getEntrypointGlobals(entrypointName) {
+  return [
     {
-      browserStyle: "browse_style",
-      chromeStyle: "chrome_style",
-      exclude: "exclude",
-      include: "include",
-      openInTab: "open_in_tab"
+      name: "ENTRYPOINT",
+      value: entrypointName,
+      type: `string`
     }
-  );
+  ];
+}
+
+// src/core/builders/vite/plugins/globals.ts
+function globals(config) {
   return {
-    type: "options",
-    name: "options",
-    options: resolvePerBrowserOptions(options, wxt.config.browser),
-    inputPath: info.inputPath,
-    outputDir: wxt.config.outDir,
-    skipped: info.skipped
+    name: "wxt:globals",
+    config() {
+      const define = {};
+      for (const global of getGlobals(config)) {
+        define[`import.meta.env.${global.name}`] = JSON.stringify(global.value);
+      }
+      return {
+        define
+      };
+    }
   };
 }
-async function getUnlistedPageEntrypoint(info) {
-  const options = await getHtmlEntrypointOptions(info, {
-    exclude: "exclude",
-    include: "include"
-  });
-  return {
-    type: "unlisted-page",
-    name: info.name,
-    inputPath: info.inputPath,
-    outputDir: wxt.config.outDir,
-    options,
-    skipped: info.skipped
-  };
-}
-async function getUnlistedScriptEntrypoint({
-  inputPath,
-  name,
-  skipped
-}) {
-  const defaultExport = await importEntrypointFile(inputPath);
-  if (defaultExport == null) {
-    throw Error(
-      `${name}: Default export not found, did you forget to call "export default defineUnlistedScript(...)"?`
-    );
-  }
-  const { main: _, ...options } = defaultExport;
+
+// src/core/builders/vite/plugins/webextensionPolyfillMock.ts
+import path2 from "node:path";
+function webextensionPolyfillMock(config) {
   return {
-    type: "unlisted-script",
-    name,
-    inputPath,
-    outputDir: wxt.config.outDir,
-    options: resolvePerBrowserOptions(options, wxt.config.browser),
-    skipped
-  };
-}
-async function getBackgroundEntrypoint({
-  inputPath,
-  name,
-  skipped
-}) {
-  let options = {};
-  if (inputPath !== VIRTUAL_NOOP_BACKGROUND_MODULE_ID) {
-    const defaultExport = await importEntrypointFile(inputPath);
-    if (defaultExport == null) {
-      throw Error(
-        `${name}: Default export not found, did you forget to call "export default defineBackground(...)"?`
-      );
+    name: "wxt:testing-inline-deps",
+    config() {
+      return {
+        resolve: {
+          alias: {
+            // Alias to use a mocked version of the polyfill
+            "webextension-polyfill": path2.resolve(
+              config.wxtModuleDir,
+              "dist/virtual/mock-browser"
+            )
+          }
+        },
+        ssr: {
+          // Inline all WXT modules
+          noExternal: ["wxt"]
+        }
+      };
     }
-    const { main: _, ...moduleOptions } = defaultExport;
-    options = moduleOptions;
-  }
-  if (wxt.config.manifestVersion !== 3) {
-    delete options.type;
-  }
-  return {
-    type: "background",
-    name,
-    inputPath,
-    outputDir: wxt.config.outDir,
-    options: resolvePerBrowserOptions(options, wxt.config.browser),
-    skipped
-  };
-}
-async function getContentScriptEntrypoint({
-  inputPath,
-  name,
-  skipped
-}) {
-  const { main: _, ...options } = await importEntrypointFile(inputPath);
-  if (options == null) {
-    throw Error(
-      `${name}: Default export not found, did you forget to call "export default defineContentScript(...)"?`
-    );
-  }
-  return {
-    type: "content-script",
-    name,
-    inputPath,
-    outputDir: resolve3(wxt.config.outDir, CONTENT_SCRIPT_OUT_DIR),
-    options: resolvePerBrowserOptions(options, wxt.config.browser),
-    skipped
   };
 }
-async function getSidepanelEntrypoint(info) {
-  const options = await getHtmlEntrypointOptions(
-    info,
-    {
-      browserStyle: "browse_style",
-      exclude: "exclude",
-      include: "include",
-      defaultIcon: "default_icon",
-      defaultTitle: "default_title",
-      openAtInstall: "open_at_install"
-    },
+
+// src/core/builders/vite/plugins/devHtmlPrerender.ts
+import { parseHTML } from "linkedom";
+import { dirname, relative as relative2, resolve as resolve2 } from "node:path";
+var reactRefreshPreamble = "";
+function devHtmlPrerender(config, server) {
+  const htmlReloadId = "@wxt/reload-html";
+  const resolvedHtmlReloadId = resolve2(
+    config.wxtModuleDir,
+    "dist/virtual/reload-html.js"
+  );
+  const virtualReactRefreshId = "@wxt/virtual-react-refresh";
+  const resolvedVirtualReactRefreshId = "\0" + virtualReactRefreshId;
+  return [
     {
-      defaultTitle: (document) => document.querySelector("title")?.textContent || void 0
+      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) {
+        if (config.command !== "serve" || server == null || !id.endsWith(".html"))
+          return;
+        const { document } = parseHTML(code);
+        const _pointToDevServer = (querySelector, attr) => pointToDevServer(config, server, id, document, querySelector, attr);
+        _pointToDevServer("script[type=module]", "src");
+        _pointToDevServer("link[rel=stylesheet]", "href");
+        const reloader = document.createElement("script");
+        reloader.src = htmlReloadId;
+        reloader.type = "module";
+        document.head.appendChild(reloader);
+        const newHtml = document.toString();
+        config.logger.debug("transform " + id);
+        config.logger.debug("Old HTML:\n" + code);
+        config.logger.debug("New HTML:\n" + newHtml);
+        return newHtml;
+      },
+      // Pass the HTML through the dev server to add dev-mode specific code
+      async transformIndexHtml(html, ctx) {
+        if (config.command !== "serve" || server == null)
+          return;
+        const originalUrl = `${server.origin}${ctx.path}`;
+        const name = getEntrypointName(config.entrypointsDir, ctx.filename);
+        const url = `${server.origin}/${name}.html`;
+        const serverHtml = await server.transformHtml(url, html, originalUrl);
+        const { document } = 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;
+      }
     },
     {
-      defaultTitle: (content) => content
+      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 "";
+        }
+      }
     }
-  );
-  return {
-    type: "sidepanel",
-    name: info.name,
-    options: resolvePerBrowserOptions(options, wxt.config.browser),
-    inputPath: info.inputPath,
-    outputDir: wxt.config.outDir,
-    skipped: info.skipped
-  };
+  ];
 }
-async function getHtmlEntrypointOptions(info, keyMap, queries, parsers) {
-  const content = await fs3.readFile(info.inputPath, "utf-8");
-  const { document } = parseHTML(content);
-  const options = {};
-  const defaultQuery = (manifestKey) => document.querySelector(`meta[name='manifest.${manifestKey}']`)?.getAttribute("content");
-  Object.entries(keyMap).forEach(([_key, manifestKey]) => {
-    const key = _key;
-    const content2 = queries?.[key] ? queries[key](document, manifestKey) : defaultQuery(manifestKey);
-    if (content2) {
-      try {
-        options[key] = (parsers?.[key] ?? JSON5.parse)(content2);
-      } catch (err) {
-        wxt.logger.fatal(
-          `Failed to parse meta tag content. Usually this means you have invalid JSON5 content (content=${content2})`,
-          err
-        );
+function pointToDevServer(config, server, id, document, querySelector, attr) {
+  document.querySelectorAll(querySelector).forEach((element) => {
+    const src = element.getAttribute(attr);
+    if (!src || isUrl(src))
+      return;
+    let resolvedAbsolutePath;
+    const matchingAlias = Object.entries(config.alias).find(
+      ([key]) => src.startsWith(key)
+    );
+    if (matchingAlias) {
+      const [alias, replacement] = matchingAlias;
+      resolvedAbsolutePath = resolve2(
+        config.root,
+        src.replace(alias, replacement)
+      );
+    } else {
+      resolvedAbsolutePath = resolve2(dirname(id), src);
+    }
+    if (resolvedAbsolutePath) {
+      const relativePath = normalizePath(
+        relative2(config.root, resolvedAbsolutePath)
+      );
+      if (relativePath.startsWith(".")) {
+        let path8 = normalizePath(resolvedAbsolutePath);
+        if (!path8.startsWith("/"))
+          path8 = "/" + path8;
+        element.setAttribute(attr, `${server.origin}/@fs${path8}`);
+      } else {
+        const url = new URL(relativePath, server.origin);
+        element.setAttribute(attr, url.href);
       }
     }
   });
-  return options;
 }
-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?(x)": "unlisted-script",
-  "*/index.[jt]s?(x)": "unlisted-script",
-  [`*.${CSS_EXTENSIONS_PATTERN}`]: "unlisted-style",
-  [`*/index.${CSS_EXTENSIONS_PATTERN}`]: "unlisted-style"
-};
-var CONTENT_SCRIPT_OUT_DIR = "content-scripts";
-
-// src/core/utils/building/generate-wxt-dir.ts
-import { createUnimport } from "unimport";
-import fs4 from "fs-extra";
-import { relative as relative3, resolve as resolve4 } from "path";
+function isUrl(str) {
+  try {
+    new URL(str);
+    return true;
+  } catch {
+    return false;
+  }
+}
 
-// src/core/utils/globals.ts
-function getGlobals(config) {
-  return [
-    {
-      name: "MANIFEST_VERSION",
-      value: config.manifestVersion,
-      type: `2 | 3`
-    },
-    {
-      name: "BROWSER",
-      value: config.browser,
-      type: `string`
-    },
-    {
-      name: "CHROME",
-      value: config.browser === "chrome",
-      type: `boolean`
-    },
-    {
-      name: "FIREFOX",
-      value: config.browser === "firefox",
-      type: `boolean`
-    },
-    {
-      name: "SAFARI",
-      value: config.browser === "safari",
-      type: `boolean`
-    },
-    {
-      name: "EDGE",
-      value: config.browser === "edge",
-      type: `boolean`
-    },
-    {
-      name: "OPERA",
-      value: config.browser === "opera",
-      type: `boolean`
-    },
-    {
-      name: "COMMAND",
-      value: config.command,
-      type: `"build" | "serve"`
+// src/core/builders/vite/plugins/devServerGlobals.ts
+function devServerGlobals(config, server) {
+  return {
+    name: "wxt:dev-server-globals",
+    config() {
+      if (server == null || config.command == "build")
+        return;
+      return {
+        define: {
+          __DEV_SERVER_PROTOCOL__: JSON.stringify("ws:"),
+          __DEV_SERVER_HOSTNAME__: JSON.stringify(server.hostname),
+          __DEV_SERVER_PORT__: JSON.stringify(server.port)
+        }
+      };
     }
-  ];
+  };
 }
-function getEntrypointGlobals(entrypointName) {
-  return [
-    {
-      name: "ENTRYPOINT",
-      value: entrypointName,
-      type: `string`
+
+// src/core/builders/vite/plugins/multipageMove.ts
+import { dirname as dirname2, extname as extname2, resolve as resolve3, join } from "node:path";
+import fs, { ensureDir } from "fs-extra";
+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,
+          extname2(oldBundlePath)
+        );
+        if (newBundlePath === oldBundlePath) {
+          config.logger.debug(
+            "HTML file is already in the correct location",
+            oldBundlePath
+          );
+          continue;
+        }
+        const oldAbsPath = resolve3(config.outDir, oldBundlePath);
+        const newAbsPath = resolve3(config.outDir, newBundlePath);
+        await ensureDir(dirname2(newAbsPath));
+        await fs.move(oldAbsPath, newAbsPath, { overwrite: true });
+        const renamedChunk = {
+          ...bundle[oldBundlePath],
+          fileName: newBundlePath
+        };
+        delete bundle[oldBundlePath];
+        bundle[newBundlePath] = renamedChunk;
+      }
+      removeEmptyDirs(config.outDir);
     }
-  ];
+  };
 }
-
-// src/core/utils/building/generate-wxt-dir.ts
-import path2 from "node:path";
-
-// 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".`
+async function removeEmptyDirs(dir) {
+  const files = await fs.readdir(dir);
+  for (const file of files) {
+    const filePath = join(dir, file);
+    const stats = await fs.stat(filePath);
+    if (stats.isDirectory()) {
+      await removeEmptyDirs(filePath);
+    }
+  }
+  try {
+    await fs.rmdir(dir);
+  } catch {
   }
-};
-function parseI18nMessages(messagesJson) {
-  return Object.entries({
-    ...predefinedMessages,
-    ...messagesJson
-  }).map(([name, details]) => ({
-    name,
-    ...details
-  }));
 }
 
-// src/core/utils/building/generate-wxt-dir.ts
-async function generateTypesDir(entrypoints) {
-  await fs4.ensureDir(wxt.config.typesDir);
-  const references = [];
-  if (wxt.config.imports !== false) {
-    const unimport2 = createUnimport(wxt.config.imports);
-    references.push(await writeImportsDeclarationFile(unimport2));
-    if (wxt.config.imports.eslintrc.enabled) {
-      await writeImportsEslintFile(unimport2, wxt.config.imports);
+// src/core/builders/vite/plugins/virtualEntrypoint.ts
+import fs2 from "fs-extra";
+import { resolve as resolve4 } from "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 fs2.readFile(
+        resolve4(config.wxtModuleDir, `dist/virtual/${type}-entrypoint.js`),
+        "utf-8"
+      );
+      return template.replace(`virtual:user-${type}`, inputPath);
     }
-  }
-  references.push(await writePathsDeclarationFile(entrypoints));
-  references.push(await writeI18nDeclarationFile());
-  references.push(await writeGlobalsDeclarationFile());
-  const mainReference = await writeMainDeclarationFile(references);
-  await writeTsConfigFile(mainReference);
-}
-async function writeImportsDeclarationFile(unimport2) {
-  const filePath = resolve4(wxt.config.typesDir, "imports.d.ts");
-  await unimport2.scanImportsFromDir(void 0, { cwd: wxt.config.srcDir });
-  await writeFileIfDifferent(
-    filePath,
-    ["// Generated by wxt", await unimport2.generateTypeDeclarations()].join(
-      "\n"
-    ) + "\n"
-  );
-  return filePath;
-}
-async function writeImportsEslintFile(unimport2, options) {
-  const globals2 = {};
-  const eslintrc = { globals: globals2 };
-  (await unimport2.getImports()).map((i) => i.as ?? i.name).filter(Boolean).sort().forEach((name) => {
-    eslintrc.globals[name] = options.eslintrc.globalsPropValue;
-  });
-  await fs4.writeJson(options.eslintrc.filePath, eslintrc, { spaces: 2 });
+  };
 }
-async function writePathsDeclarationFile(entrypoints) {
-  const filePath = resolve4(wxt.config.typesDir, "paths.d.ts");
-  const unions = entrypoints.map(
-    (entry) => getEntrypointBundlePath(
-      entry,
-      wxt.config.outDir,
-      isHtmlEntrypoint(entry) ? ".html" : ".js"
-    )
-  ).concat(await getPublicFiles()).map(normalizePath).map((path8) => `    | "/${path8}"`).sort().join("\n");
-  const template = `// Generated by wxt
-import "wxt/browser";
 
-declare module "wxt/browser" {
-  export type PublicPath =
-{{ union }}
-  type HtmlPublicPath = Extract<PublicPath, \`\${string}.html\`>
-  export interface WxtRuntime extends Runtime.Static {
-    getURL(path: PublicPath): string;
-    getURL(path: \`\${HtmlPublicPath}\${string}\`): string;
-  }
-}
-`;
-  await writeFileIfDifferent(
-    filePath,
-    template.replace("{{ union }}", unions || "    | never")
-  );
-  return filePath;
-}
-async function writeI18nDeclarationFile() {
-  const filePath = resolve4(wxt.config.typesDir, "i18n.d.ts");
-  const defaultLocale = wxt.config.manifest.default_locale;
-  const template = `// Generated by wxt
-import "wxt/browser";
+// src/core/utils/constants.ts
+var VIRTUAL_NOOP_BACKGROUND_MODULE_ID = "virtual:user-background";
 
-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/noopBackground.ts
+function noopBackground() {
+  const virtualModuleId = VIRTUAL_NOOP_BACKGROUND_MODULE_ID;
+  const resolvedVirtualModuleId = "\0" + virtualModuleId;
+  return {
+    name: "wxt:noop-background",
+    resolveId(id) {
+      if (id === virtualModuleId)
+        return resolvedVirtualModuleId;
+    },
+    load(id) {
+      if (id === resolvedVirtualModuleId) {
+        return `import { defineBackground } from 'wxt/sandbox';
+export default defineBackground(() => void 0)`;
+      }
+    }
+  };
+}
 
-  export interface WxtI18n extends I18n.Static {
-{{ overrides }}
-  }
+// 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];
+      });
+    }
+  };
 }
-`;
-  let messages;
-  if (defaultLocale) {
-    const defaultLocalePath = path2.resolve(
-      wxt.config.publicDir,
-      "_locales",
-      defaultLocale,
-      "messages.json"
-    );
-    const content = JSON.parse(await fs4.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;`;
+
+// src/core/builders/vite/plugins/bundleAnalysis.ts
+import { visualizer } from "@aklinker1/rollup-plugin-visualizer";
+import path3 from "node:path";
+var increment = 0;
+function bundleAnalysis(config) {
+  return visualizer({
+    template: "raw-data",
+    filename: path3.resolve(
+      config.analysis.outputDir,
+      `${config.analysis.outputName}-${increment++}.json`
+    )
   });
-  await writeFileIfDifferent(
-    filePath,
-    template.replace("{{ overrides }}", overrides.join("\n"))
-  );
-  return filePath;
-}
-async function writeGlobalsDeclarationFile() {
-  const filePath = resolve4(wxt.config.typesDir, "globals.d.ts");
-  const globals2 = [...getGlobals(wxt.config), ...getEntrypointGlobals("")];
-  await writeFileIfDifferent(
-    filePath,
-    [
-      "// Generated by wxt",
-      "export {}",
-      "interface ImportMetaEnv {",
-      ...globals2.map((global) => `  readonly ${global.name}: ${global.type};`),
-      "}",
-      "interface ImportMeta {",
-      "  readonly env: ImportMetaEnv",
-      "}"
-    ].join("\n") + "\n"
-  );
-  return filePath;
-}
-async function writeMainDeclarationFile(references) {
-  const dir = wxt.config.wxtDir;
-  const filePath = resolve4(dir, "wxt.d.ts");
-  await writeFileIfDifferent(
-    filePath,
-    [
-      "// Generated by wxt",
-      `/// <reference types="wxt/vite-builder-env" />`,
-      ...references.map(
-        (ref) => `/// <reference types="./${normalizePath(relative3(dir, ref))}" />`
-      )
-    ].join("\n") + "\n"
-  );
-  return filePath;
 }
-async function writeTsConfigFile(mainReference) {
-  const dir = wxt.config.wxtDir;
-  const getTsconfigPath = (path8) => normalizePath(relative3(dir, path8));
-  const paths = Object.entries(wxt.config.alias).flatMap(([alias, absolutePath]) => {
-    const aliasPath = getTsconfigPath(absolutePath);
-    return [
-      `      "${alias}": ["${aliasPath}"]`,
-      `      "${alias}/*": ["${aliasPath}/*"]`
-    ];
-  }).join(",\n");
-  await writeFileIfDifferent(
-    resolve4(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/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";
+      }
     }
-  },
-  "include": [
-    "${getTsconfigPath(wxt.config.root)}/**/*",
-    "./${getTsconfigPath(mainReference)}"
-  ],
-  "exclude": ["${getTsconfigPath(wxt.config.outBaseDir)}"]
-}`
-  );
+  };
 }
 
-// src/core/utils/building/resolve-config.ts
-import { loadConfig } from "c12";
-import path5 from "node:path";
-
-// src/core/utils/cache.ts
-import fs5, { ensureDir } from "fs-extra";
-import { dirname as dirname2, resolve as resolve5 } from "path";
-function createFsCache(wxtDir) {
-  const getPath = (key) => resolve5(wxtDir, "cache", encodeURIComponent(key));
+// src/core/builders/vite/plugins/entrypointGroupGlobals.ts
+function entrypointGroupGlobals(entrypointGroup) {
   return {
-    async set(key, value) {
-      const path8 = getPath(key);
-      await ensureDir(dirname2(path8));
-      await writeFileIfDifferent(path8, value);
-    },
-    async get(key) {
-      const path8 = getPath(key);
-      try {
-        return await fs5.readFile(path8, "utf-8");
-      } catch {
-        return void 0;
+    name: "wxt:entrypoint-group-globals",
+    config() {
+      const define = {};
+      let name = Array.isArray(entrypointGroup) ? "html" : entrypointGroup.name;
+      for (const global of getEntrypointGlobals(name)) {
+        define[`import.meta.env.${global.name}`] = JSON.stringify(global.value);
       }
+      return {
+        define
+      };
     }
   };
 }
 
-// src/core/utils/building/resolve-config.ts
-import consola, { LogLevels } from "consola";
+// src/core/builders/vite/plugins/defineImportMeta.ts
+function defineImportMeta() {
+  return {
+    name: "wxt:define",
+    config() {
+      return {
+        define: {
+          // This works for all extension contexts, including background service worker
+          "import.meta.url": "self.location.href"
+        }
+      };
+    }
+  };
+}
 
-// src/core/builders/vite/plugins/devHtmlPrerender.ts
-import { parseHTML as parseHTML2 } from "linkedom";
-import { dirname as dirname3, relative as relative4, resolve as resolve6 } from "node:path";
-var reactRefreshPreamble = "";
-function devHtmlPrerender(config) {
-  const htmlReloadId = "@wxt/reload-html";
-  const resolvedHtmlReloadId = resolve6(
-    config.wxtModuleDir,
-    "dist/virtual/reload-html.js"
-  );
-  const virtualReactRefreshId = "@wxt/virtual-react-refresh";
-  const resolvedVirtualReactRefreshId = "\0" + virtualReactRefreshId;
-  return [
-    {
-      apply: "build",
-      name: "wxt:dev-html-prerender",
-      config() {
-        return {
-          resolve: {
-            alias: {
-              [htmlReloadId]: resolvedHtmlReloadId
-            }
-          }
-        };
-      },
-      // Convert scripts like src="./main.tsx" -> src="http://localhost:3000/entrypoints/popup/main.tsx"
-      // before the paths are replaced with their bundled path
-      transform(code, id) {
-        const server = config.server;
-        if (config.command !== "serve" || server == null || !id.endsWith(".html"))
-          return;
-        const { document } = parseHTML2(code);
-        const _pointToDevServer = (querySelector, attr) => pointToDevServer(config, server, id, document, querySelector, attr);
-        _pointToDevServer("script[type=module]", "src");
-        _pointToDevServer("link[rel=stylesheet]", "href");
-        const reloader = document.createElement("script");
-        reloader.src = htmlReloadId;
-        reloader.type = "module";
-        document.head.appendChild(reloader);
-        const newHtml = document.toString();
-        config.logger.debug("transform " + id);
-        config.logger.debug("Old HTML:\n" + code);
-        config.logger.debug("New HTML:\n" + newHtml);
-        return newHtml;
-      },
-      // Pass the HTML through the dev server to add dev-mode specific code
-      async transformIndexHtml(html, ctx) {
-        const server = config.server;
-        if (config.command !== "serve" || server == null)
-          return;
-        const originalUrl = `${server.origin}${ctx.path}`;
-        const name = getEntrypointName(config.entrypointsDir, ctx.filename);
-        const url = `${server.origin}/${name}.html`;
-        const serverHtml = await server.transformHtml(url, html, originalUrl);
-        const { document } = parseHTML2(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/utils/fs.ts
+import fs3 from "fs-extra";
+import glob from "fast-glob";
+async function writeFileIfDifferent(file, newContents) {
+  const existingContents = await fs3.readFile(file, "utf-8").catch(() => void 0);
+  if (existingContents !== newContents) {
+    await fs3.writeFile(file, newContents);
+  }
+}
+async function getPublicFiles() {
+  if (!await fs3.exists(wxt.config.publicDir))
+    return [];
+  const files = await glob("**/*", { cwd: wxt.config.publicDir });
+  return files.map(unnormalizePath);
+}
+
+// src/core/utils/building/build-entrypoints.ts
+import fs4 from "fs-extra";
+import { dirname as dirname3, resolve as resolve5 } from "path";
+import pc from "picocolors";
+async function buildEntrypoints(groups, spinner) {
+  const steps = [];
+  for (let i = 0; i < groups.length; i++) {
+    const group = groups[i];
+    const groupNames = [group].flat().map((e) => e.name);
+    const groupNameColored = groupNames.join(pc.dim(", "));
+    spinner.text = pc.dim(`[${i + 1}/${groups.length}]`) + ` ${groupNameColored}`;
+    try {
+      steps.push(await wxt.builder.build(group));
+    } catch (err) {
+      spinner.stop().clear();
+      wxt.logger.error(err);
+      throw Error(`Failed to build ${groupNames.join(", ")}`, { cause: err });
     }
-  ];
+  }
+  const publicAssets = await copyPublicDirectory();
+  return { publicAssets, steps };
 }
-function pointToDevServer(config, server, id, document, querySelector, attr) {
-  document.querySelectorAll(querySelector).forEach((element) => {
-    const src = element.getAttribute(attr);
-    if (!src || isUrl(src))
-      return;
-    let resolvedAbsolutePath;
-    const matchingAlias = Object.entries(config.alias).find(
-      ([key]) => src.startsWith(key)
+async function copyPublicDirectory() {
+  const files = await getPublicFiles();
+  if (files.length === 0)
+    return [];
+  const publicAssets = [];
+  for (const file of files) {
+    const srcPath = resolve5(wxt.config.publicDir, file);
+    const outPath = resolve5(wxt.config.outDir, file);
+    await fs4.ensureDir(dirname3(outPath));
+    await fs4.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;
+}
+function some(array, predicate) {
+  for (let i = 0; i < array.length; i++)
+    if (predicate(array[i], i))
+      return true;
+  return false;
+}
+
+// src/core/utils/building/detect-dev-changes.ts
+function detectDevChanges(changedFiles, currentOutput) {
+  const isConfigChange = some(
+    changedFiles,
+    (file) => file === wxt.config.userConfigMetadata.configFile
+  );
+  if (isConfigChange)
+    return { type: "full-restart" };
+  const isRunnerChange = some(
+    changedFiles,
+    (file) => file === wxt.config.runnerConfig.configFile
+  );
+  if (isRunnerChange)
+    return { type: "browser-restart" };
+  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);
+  const isChunkEffected = (chunk) => (
+    // If it's an HTML file with the same path, is is effected because HTML files need to be re-rendered
+    // - fileName is normalized, relative bundle path, "<entrypoint-name>.html"
+    chunk.type === "asset" && changedPath.replace("/index.html", ".html").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
+import { relative as relative3, resolve as resolve6 } from "path";
+import fs5 from "fs-extra";
+import { minimatch } from "minimatch";
+import { parseHTML as parseHTML2 } from "linkedom";
+import JSON5 from "json5";
+import glob2 from "fast-glob";
+import pc2 from "picocolors";
+async function findEntrypoints() {
+  const relativePaths = await glob2(Object.keys(PATH_GLOB_TO_TYPE_MAP), {
+    cwd: wxt.config.entrypointsDir
+  });
+  relativePaths.sort();
+  const pathGlobs = Object.keys(PATH_GLOB_TO_TYPE_MAP);
+  const entrypointInfos = relativePaths.reduce((results, relativePath) => {
+    const inputPath = resolve6(wxt.config.entrypointsDir, relativePath);
+    const name = getEntrypointName(wxt.config.entrypointsDir, inputPath);
+    const matchingGlob = pathGlobs.find(
+      (glob4) => minimatch(relativePath, glob4)
+    );
+    if (matchingGlob) {
+      const type = PATH_GLOB_TO_TYPE_MAP[matchingGlob];
+      results.push({
+        name,
+        inputPath,
+        type,
+        skipped: wxt.config.filterEntrypoints != null && !wxt.config.filterEntrypoints.has(name)
+      });
+    }
+    return results;
+  }, []);
+  preventNoEntrypoints(entrypointInfos);
+  preventDuplicateEntrypointNames(entrypointInfos);
+  let hasBackground = false;
+  const entrypoints = await Promise.all(
+    entrypointInfos.map(async (info) => {
+      const { type } = info;
+      switch (type) {
+        case "popup":
+          return await getPopupEntrypoint(info);
+        case "sidepanel":
+          return await getSidepanelEntrypoint(info);
+        case "options":
+          return await getOptionsEntrypoint(info);
+        case "background":
+          hasBackground = true;
+          return await getBackgroundEntrypoint(info);
+        case "content-script":
+          return await getContentScriptEntrypoint(info);
+        case "unlisted-page":
+          return await getUnlistedPageEntrypoint(info);
+        case "unlisted-script":
+          return await getUnlistedScriptEntrypoint(info);
+        case "content-script-style":
+          return {
+            ...info,
+            type,
+            outputDir: resolve6(wxt.config.outDir, CONTENT_SCRIPT_OUT_DIR),
+            options: {
+              include: void 0,
+              exclude: void 0
+            }
+          };
+        default:
+          return {
+            ...info,
+            type,
+            outputDir: wxt.config.outDir,
+            options: {
+              include: void 0,
+              exclude: void 0
+            }
+          };
+      }
+    })
+  );
+  if (wxt.config.command === "serve" && !hasBackground) {
+    entrypoints.push(
+      await getBackgroundEntrypoint({
+        inputPath: VIRTUAL_NOOP_BACKGROUND_MODULE_ID,
+        name: "background",
+        type: "background",
+        skipped: false
+      })
     );
-    if (matchingAlias) {
-      const [alias, replacement] = matchingAlias;
-      resolvedAbsolutePath = resolve6(
-        config.root,
-        src.replace(alias, replacement)
+  }
+  wxt.logger.debug("All entrypoints:", entrypoints);
+  const skippedEntrypointNames = entrypointInfos.filter((item) => item.skipped).map((item) => item.name);
+  if (skippedEntrypointNames.length) {
+    wxt.logger.warn(
+      `Filter excluded the following entrypoints:
+${skippedEntrypointNames.map((item) => `${pc2.dim("-")} ${pc2.cyan(item)}`).join("\n")}`
+    );
+  }
+  const targetEntrypoints = entrypoints.filter((entry) => {
+    const { include, exclude } = entry.options;
+    if (include?.length && exclude?.length) {
+      wxt.logger.warn(
+        `The ${entry.name} entrypoint lists both include and exclude, but only one can be used per entrypoint. Entrypoint ignored.`
       );
-    } else {
-      resolvedAbsolutePath = resolve6(dirname3(id), src);
+      return false;
     }
-    if (resolvedAbsolutePath) {
-      const relativePath = normalizePath(
-        relative4(config.root, resolvedAbsolutePath)
-      );
-      if (relativePath.startsWith(".")) {
-        let path8 = normalizePath(resolvedAbsolutePath);
-        if (!path8.startsWith("/"))
-          path8 = "/" + path8;
-        element.setAttribute(attr, `${server.origin}/@fs${path8}`);
-      } else {
-        const url = new URL(relativePath, server.origin);
-        element.setAttribute(attr, url.href);
-      }
+    if (exclude?.length && !include?.length) {
+      return !exclude.includes(wxt.config.browser);
     }
-  });
-}
-function isUrl(str) {
-  try {
-    new URL(str);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/core/builders/vite/plugins/devServerGlobals.ts
-function devServerGlobals(config) {
-  return {
-    name: "wxt:dev-server-globals",
-    config() {
-      if (config.server == null || config.command == "build")
-        return;
-      return {
-        define: {
-          __DEV_SERVER_PROTOCOL__: JSON.stringify("ws:"),
-          __DEV_SERVER_HOSTNAME__: JSON.stringify(config.server.hostname),
-          __DEV_SERVER_PORT__: JSON.stringify(config.server.port)
-        }
-      };
+    if (include?.length && !exclude?.length) {
+      return include.includes(wxt.config.browser);
     }
-  };
-}
-
-// src/core/utils/network.ts
-import dns from "node:dns";
-
-// 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));
+    if (skippedEntrypointNames.includes(entry.name)) {
+      return false;
+    }
+    return true;
   });
+  wxt.logger.debug(`${wxt.config.browser} entrypoints:`, targetEntrypoints);
+  await wxt.hooks.callHook("entrypoints:resolved", wxt, targetEntrypoints);
+  return targetEntrypoints;
 }
-
-// src/core/utils/network.ts
-function isOffline() {
-  const isOffline2 = new Promise((res) => {
-    dns.resolve("google.com", (err) => {
-      if (err == null) {
-        res(false);
-      } else {
-        res(true);
+function preventDuplicateEntrypointNames(files) {
+  const namesToPaths = files.reduce(
+    (map, { name, inputPath }) => {
+      map[name] ??= [];
+      map[name].push(inputPath);
+      return map;
+    },
+    {}
+  );
+  const errorLines = Object.entries(namesToPaths).reduce(
+    (lines, [name, absolutePaths]) => {
+      if (absolutePaths.length > 1) {
+        lines.push(`- ${name}`);
+        absolutePaths.forEach((absolutePath) => {
+          lines.push(`  - ${relative3(wxt.config.root, absolutePath)}`);
+        });
       }
-    });
-  });
-  return withTimeout(isOffline2, 1e3).catch(() => true);
-}
-async function isOnline() {
-  const offline = await isOffline();
-  return !offline;
-}
-async function fetchCached(url, config) {
-  let content = "";
-  if (await isOnline()) {
-    const res = await fetch(url);
-    if (res.status < 300) {
-      content = await res.text();
-      await config.fsCache.set(url, content);
-    } else {
-      config.logger.debug(
-        `Failed to download "${url}", falling back to cache...`
-      );
-    }
-  }
-  if (!content)
-    content = await config.fsCache.get(url) ?? "";
-  if (!content)
+      return lines;
+    },
+    []
+  );
+  if (errorLines.length > 0) {
+    const errorContent = errorLines.join("\n");
     throw Error(
-      `Offline and "${url}" has not been cached. Try again when online.`
+      `Multiple entrypoints with the same name detected, only one entrypoint for each name is allowed.
+
+${errorContent}`
     );
-  return content;
+  }
 }
-
-// src/core/builders/vite/plugins/download.ts
-function download(config) {
-  return {
-    name: "wxt:download",
-    resolveId(id) {
-      if (id.startsWith("url:"))
-        return "\0" + id;
+function preventNoEntrypoints(files) {
+  if (files.length === 0) {
+    throw Error(`No entrypoints found in ${wxt.config.entrypointsDir}`);
+  }
+}
+async function getPopupEntrypoint(info) {
+  const options = await getHtmlEntrypointOptions(
+    info,
+    {
+      browserStyle: "browse_style",
+      exclude: "exclude",
+      include: "include",
+      defaultIcon: "default_icon",
+      defaultTitle: "default_title",
+      mv2Key: "type"
     },
-    async load(id) {
-      if (!id.startsWith("\0url:"))
-        return;
-      const url = id.replace("\0url:", "");
-      return await fetchCached(url, config);
+    {
+      defaultTitle: (document) => document.querySelector("title")?.textContent || void 0
+    },
+    {
+      defaultTitle: (content) => content,
+      mv2Key: (content) => content === "page_action" ? "page_action" : "browser_action"
     }
+  );
+  return {
+    type: "popup",
+    name: "popup",
+    options: resolvePerBrowserOptions(options, wxt.config.browser),
+    inputPath: info.inputPath,
+    outputDir: wxt.config.outDir,
+    skipped: info.skipped
   };
 }
-
-// src/core/builders/vite/plugins/multipageMove.ts
-import { dirname as dirname4, extname, resolve as resolve7, join } from "node:path";
-import fs6, { ensureDir as ensureDir2 } from "fs-extra";
-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,
-          extname(oldBundlePath)
-        );
-        if (newBundlePath === oldBundlePath) {
-          config.logger.debug(
-            "HTML file is already in the correct location",
-            oldBundlePath
-          );
-          continue;
-        }
-        const oldAbsPath = resolve7(config.outDir, oldBundlePath);
-        const newAbsPath = resolve7(config.outDir, newBundlePath);
-        await ensureDir2(dirname4(newAbsPath));
-        await fs6.move(oldAbsPath, newAbsPath, { overwrite: true });
-        const renamedChunk = {
-          ...bundle[oldBundlePath],
-          fileName: newBundlePath
-        };
-        delete bundle[oldBundlePath];
-        bundle[newBundlePath] = renamedChunk;
-      }
-      removeEmptyDirs(config.outDir);
+async function getOptionsEntrypoint(info) {
+  const options = await getHtmlEntrypointOptions(
+    info,
+    {
+      browserStyle: "browse_style",
+      chromeStyle: "chrome_style",
+      exclude: "exclude",
+      include: "include",
+      openInTab: "open_in_tab"
     }
+  );
+  return {
+    type: "options",
+    name: "options",
+    options: resolvePerBrowserOptions(options, wxt.config.browser),
+    inputPath: info.inputPath,
+    outputDir: wxt.config.outDir,
+    skipped: info.skipped
+  };
+}
+async function getUnlistedPageEntrypoint(info) {
+  const options = await getHtmlEntrypointOptions(info, {
+    exclude: "exclude",
+    include: "include"
+  });
+  return {
+    type: "unlisted-page",
+    name: info.name,
+    inputPath: info.inputPath,
+    outputDir: wxt.config.outDir,
+    options,
+    skipped: info.skipped
+  };
+}
+async function getUnlistedScriptEntrypoint({
+  inputPath,
+  name,
+  skipped
+}) {
+  const defaultExport = await importEntrypointFile(inputPath);
+  if (defaultExport == null) {
+    throw Error(
+      `${name}: Default export not found, did you forget to call "export default defineUnlistedScript(...)"?`
+    );
+  }
+  const { main: _, ...options } = defaultExport;
+  return {
+    type: "unlisted-script",
+    name,
+    inputPath,
+    outputDir: wxt.config.outDir,
+    options: resolvePerBrowserOptions(options, wxt.config.browser),
+    skipped
   };
 }
-async function removeEmptyDirs(dir) {
-  const files = await fs6.readdir(dir);
-  for (const file of files) {
-    const filePath = join(dir, file);
-    const stats = await fs6.stat(filePath);
-    if (stats.isDirectory()) {
-      await removeEmptyDirs(filePath);
+async function getBackgroundEntrypoint({
+  inputPath,
+  name,
+  skipped
+}) {
+  let options = {};
+  if (inputPath !== VIRTUAL_NOOP_BACKGROUND_MODULE_ID) {
+    const defaultExport = await importEntrypointFile(inputPath);
+    if (defaultExport == null) {
+      throw Error(
+        `${name}: Default export not found, did you forget to call "export default defineBackground(...)"?`
+      );
     }
+    const { main: _, ...moduleOptions } = defaultExport;
+    options = moduleOptions;
   }
-  try {
-    await fs6.rmdir(dir);
-  } catch {
+  if (wxt.config.manifestVersion !== 3) {
+    delete options.type;
   }
-}
-
-// src/core/builders/vite/plugins/unimport.ts
-import { createUnimport as createUnimport2 } from "unimport";
-import { extname as extname2 } from "path";
-var ENABLED_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".js",
-  ".jsx",
-  ".ts",
-  ".tsx",
-  ".vue",
-  ".svelte"
-]);
-function unimport(config) {
-  const options = config.imports;
-  if (options === false)
-    return [];
-  const unimport2 = createUnimport2(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(extname2(id)))
-        return;
-      const injected = await unimport2.injectImports(code, id);
-      return {
-        code: injected.code,
-        map: injected.s.generateMap({ hires: "boundary", source: id })
-      };
-    }
+    type: "background",
+    name,
+    inputPath,
+    outputDir: wxt.config.outDir,
+    options: resolvePerBrowserOptions(options, wxt.config.browser),
+    skipped
   };
 }
-
-// src/core/builders/vite/plugins/virtualEntrypoint.ts
-import fs7 from "fs-extra";
-import { resolve as resolve8 } from "path";
-function virtualEntrypoint(type, config) {
-  const virtualId = `virtual:wxt-${type}?`;
-  const resolvedVirtualId = `\0${virtualId}`;
+async function getContentScriptEntrypoint({
+  inputPath,
+  name,
+  skipped
+}) {
+  const { main: _, ...options } = await importEntrypointFile(inputPath);
+  if (options == null) {
+    throw Error(
+      `${name}: Default export not found, did you forget to call "export default defineContentScript(...)"?`
+    );
+  }
   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 fs7.readFile(
-        resolve8(config.wxtModuleDir, `dist/virtual/${type}-entrypoint.js`),
-        "utf-8"
-      );
-      return template.replace(`virtual:user-${type}`, inputPath);
-    }
+    type: "content-script",
+    name,
+    inputPath,
+    outputDir: resolve6(wxt.config.outDir, CONTENT_SCRIPT_OUT_DIR),
+    options: resolvePerBrowserOptions(options, wxt.config.browser),
+    skipped
   };
 }
-
-// src/core/builders/vite/plugins/tsconfigPaths.ts
-function tsconfigPaths(config) {
-  return {
-    name: "wxt:aliases",
-    async config() {
-      return {
-        resolve: {
-          alias: config.alias
-        }
-      };
+async function getSidepanelEntrypoint(info) {
+  const options = await getHtmlEntrypointOptions(
+    info,
+    {
+      browserStyle: "browse_style",
+      exclude: "exclude",
+      include: "include",
+      defaultIcon: "default_icon",
+      defaultTitle: "default_title",
+      openAtInstall: "open_at_install"
+    },
+    {
+      defaultTitle: (document) => document.querySelector("title")?.textContent || void 0
+    },
+    {
+      defaultTitle: (content) => content
     }
+  );
+  return {
+    type: "sidepanel",
+    name: info.name,
+    options: resolvePerBrowserOptions(options, wxt.config.browser),
+    inputPath: info.inputPath,
+    outputDir: wxt.config.outDir,
+    skipped: info.skipped
   };
 }
-
-// src/core/builders/vite/plugins/noopBackground.ts
-function noopBackground() {
-  const virtualModuleId = VIRTUAL_NOOP_BACKGROUND_MODULE_ID;
-  const resolvedVirtualModuleId = "\0" + virtualModuleId;
-  return {
-    name: "wxt:noop-background",
-    resolveId(id) {
-      if (id === virtualModuleId)
-        return resolvedVirtualModuleId;
-    },
-    load(id) {
-      if (id === resolvedVirtualModuleId) {
-        return `import { defineBackground } from 'wxt/sandbox';
-export default defineBackground(() => void 0)`;
+async function getHtmlEntrypointOptions(info, keyMap, queries, parsers) {
+  const content = await fs5.readFile(info.inputPath, "utf-8");
+  const { document } = parseHTML2(content);
+  const options = {};
+  const defaultQuery = (manifestKey) => document.querySelector(`meta[name='manifest.${manifestKey}']`)?.getAttribute("content");
+  Object.entries(keyMap).forEach(([_key, manifestKey]) => {
+    const key = _key;
+    const content2 = queries?.[key] ? queries[key](document, manifestKey) : defaultQuery(manifestKey);
+    if (content2) {
+      try {
+        options[key] = (parsers?.[key] ?? JSON5.parse)(content2);
+      } catch (err) {
+        wxt.logger.fatal(
+          `Failed to parse meta tag content. Usually this means you have invalid JSON5 content (content=${content2})`,
+          err
+        );
       }
     }
-  };
+  });
+  return options;
+}
+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?(x)": "unlisted-script",
+  "*/index.[jt]s?(x)": "unlisted-script",
+  [`*.${CSS_EXTENSIONS_PATTERN}`]: "unlisted-style",
+  [`*/index.${CSS_EXTENSIONS_PATTERN}`]: "unlisted-style"
+};
+var CONTENT_SCRIPT_OUT_DIR = "content-scripts";
+
+// src/core/utils/building/generate-wxt-dir.ts
+import { createUnimport as createUnimport2 } from "unimport";
+import fs6 from "fs-extra";
+import { relative as relative4, resolve as resolve7 } from "path";
+import path4 from "node:path";
+
+// 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/builders/vite/plugins/cssEntrypoints.ts
-function cssEntrypoints(entrypoint, config) {
-  return {
-    name: "wxt:css-entrypoint",
-    config() {
-      return {
-        build: {
-          rollupOptions: {
-            output: {
-              assetFileNames: () => getEntrypointBundlePath(entrypoint, config.outDir, ".css")
-            }
-          }
-        }
-      };
-    },
-    generateBundle(_, bundle) {
-      Object.keys(bundle).forEach((file) => {
-        if (file.endsWith(".js"))
-          delete bundle[file];
-      });
+// src/core/utils/building/generate-wxt-dir.ts
+async function generateTypesDir(entrypoints) {
+  await fs6.ensureDir(wxt.config.typesDir);
+  const references = [];
+  if (wxt.config.imports !== false) {
+    const unimport2 = createUnimport2(wxt.config.imports);
+    references.push(await writeImportsDeclarationFile(unimport2));
+    if (wxt.config.imports.eslintrc.enabled) {
+      await writeImportsEslintFile(unimport2, wxt.config.imports);
     }
-  };
+  }
+  references.push(await writePathsDeclarationFile(entrypoints));
+  references.push(await writeI18nDeclarationFile());
+  references.push(await writeGlobalsDeclarationFile());
+  const mainReference = await writeMainDeclarationFile(references);
+  await writeTsConfigFile(mainReference);
 }
-
-// src/core/builders/vite/plugins/bundleAnalysis.ts
-import { visualizer } from "@aklinker1/rollup-plugin-visualizer";
-import path3 from "node:path";
-var increment = 0;
-function bundleAnalysis(config) {
-  return visualizer({
-    template: "raw-data",
-    filename: path3.resolve(
-      config.analysis.outputDir,
-      `${config.analysis.outputName}-${increment++}.json`
-    )
+async function writeImportsDeclarationFile(unimport2) {
+  const filePath = resolve7(wxt.config.typesDir, "imports.d.ts");
+  await unimport2.scanImportsFromDir(void 0, { cwd: wxt.config.srcDir });
+  await writeFileIfDifferent(
+    filePath,
+    ["// Generated by wxt", await unimport2.generateTypeDeclarations()].join(
+      "\n"
+    ) + "\n"
+  );
+  return filePath;
+}
+async function writeImportsEslintFile(unimport2, options) {
+  const globals2 = {};
+  const eslintrc = { globals: globals2 };
+  (await unimport2.getImports()).map((i) => i.as ?? i.name).filter(Boolean).sort().forEach((name) => {
+    eslintrc.globals[name] = options.eslintrc.globalsPropValue;
   });
+  await fs6.writeJson(options.eslintrc.filePath, eslintrc, { spaces: 2 });
 }
+async function writePathsDeclarationFile(entrypoints) {
+  const filePath = resolve7(wxt.config.typesDir, "paths.d.ts");
+  const unions = entrypoints.map(
+    (entry) => getEntrypointBundlePath(
+      entry,
+      wxt.config.outDir,
+      isHtmlEntrypoint(entry) ? ".html" : ".js"
+    )
+  ).concat(await getPublicFiles()).map(normalizePath).map((path8) => `    | "/${path8}"`).sort().join("\n");
+  const template = `// Generated by wxt
+import "wxt/browser";
 
-// src/core/builders/vite/plugins/globals.ts
-function globals(config) {
-  return {
-    name: "wxt:globals",
-    config() {
-      const define = {};
-      for (const global of getGlobals(config)) {
-        define[`import.meta.env.${global.name}`] = JSON.stringify(global.value);
-      }
-      return {
-        define
-      };
-    }
-  };
+declare module "wxt/browser" {
+  export type PublicPath =
+{{ union }}
+  type HtmlPublicPath = Extract<PublicPath, \`\${string}.html\`>
+  export interface WxtRuntime extends Runtime.Static {
+    getURL(path: PublicPath): string;
+    getURL(path: \`\${HtmlPublicPath}\${string}\`): string;
+  }
 }
-
-// src/core/builders/vite/plugins/webextensionPolyfillMock.ts
-import path4 from "node:path";
-function webextensionPolyfillMock(config) {
-  return {
-    name: "wxt:testing-inline-deps",
-    config() {
-      return {
-        resolve: {
-          alias: {
-            // Alias to use a mocked version of the polyfill
-            "webextension-polyfill": path4.resolve(
-              config.wxtModuleDir,
-              "dist/virtual/mock-browser"
-            )
-          }
-        },
-        ssr: {
-          // Inline all WXT modules
-          noExternal: ["wxt"]
-        }
-      };
-    }
-  };
+`;
+  await writeFileIfDifferent(
+    filePath,
+    template.replace("{{ union }}", unions || "    | never")
+  );
+  return filePath;
 }
+async function writeI18nDeclarationFile() {
+  const filePath = resolve7(wxt.config.typesDir, "i18n.d.ts");
+  const defaultLocale = wxt.config.manifest.default_locale;
+  const template = `// Generated by wxt
+import "wxt/browser";
 
-// src/core/builders/vite/plugins/excludeBrowserPolyfill.ts
-function excludeBrowserPolyfill(config) {
-  const virtualId = "virtual:wxt-webextension-polyfill-disabled";
-  return {
-    name: "wxt:exclude-browser-polyfill",
-    config() {
-      if (config.experimental.includeBrowserPolyfill)
-        return;
-      return {
-        resolve: {
-          alias: {
-            "webextension-polyfill": virtualId
-          }
-        }
-      };
-    },
-    load(id) {
-      if (id === virtualId) {
-        return "export default chrome";
-      }
-    }
-  };
-}
+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/entrypointGroupGlobals.ts
-function entrypointGroupGlobals(entrypointGroup) {
-  return {
-    name: "wxt:entrypoint-group-globals",
-    config() {
-      const define = {};
-      let name = Array.isArray(entrypointGroup) ? "html" : entrypointGroup.name;
-      for (const global of getEntrypointGlobals(name)) {
-        define[`import.meta.env.${global.name}`] = JSON.stringify(global.value);
-      }
-      return {
-        define
-      };
+  export interface WxtI18n extends I18n.Static {
+{{ overrides }}
+  }
+}
+`;
+  let messages;
+  if (defaultLocale) {
+    const defaultLocalePath = path4.resolve(
+      wxt.config.publicDir,
+      "_locales",
+      defaultLocale,
+      "messages.json"
+    );
+    const content = JSON.parse(await fs6.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;
+}
+async function writeGlobalsDeclarationFile() {
+  const filePath = resolve7(wxt.config.typesDir, "globals.d.ts");
+  const globals2 = [...getGlobals(wxt.config), ...getEntrypointGlobals("")];
+  await writeFileIfDifferent(
+    filePath,
+    [
+      "// Generated by wxt",
+      "export {}",
+      "interface ImportMetaEnv {",
+      ...globals2.map((global) => `  readonly ${global.name}: ${global.type};`),
+      "}",
+      "interface ImportMeta {",
+      "  readonly env: ImportMetaEnv",
+      "}"
+    ].join("\n") + "\n"
+  );
+  return filePath;
+}
+async function writeMainDeclarationFile(references) {
+  const dir = wxt.config.wxtDir;
+  const filePath = resolve7(dir, "wxt.d.ts");
+  await writeFileIfDifferent(
+    filePath,
+    [
+      "// Generated by wxt",
+      `/// <reference types="wxt/vite-builder-env" />`,
+      ...references.map(
+        (ref) => `/// <reference types="./${normalizePath(relative4(dir, ref))}" />`
+      )
+    ].join("\n") + "\n"
+  );
+  return filePath;
+}
+async function writeTsConfigFile(mainReference) {
+  const dir = wxt.config.wxtDir;
+  const getTsconfigPath = (path8) => normalizePath(relative4(dir, path8));
+  const paths = Object.entries(wxt.config.alias).flatMap(([alias, absolutePath]) => {
+    const aliasPath = getTsconfigPath(absolutePath);
+    return [
+      `      "${alias}": ["${aliasPath}"]`,
+      `      "${alias}/*": ["${aliasPath}/*"]`
+    ];
+  }).join(",\n");
+  await writeFileIfDifferent(
+    resolve7(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(wxt.config.root)}/**/*",
+    "./${getTsconfigPath(mainReference)}"
+  ],
+  "exclude": ["${getTsconfigPath(wxt.config.outBaseDir)}"]
+}`
+  );
 }
 
-// src/core/builders/vite/plugins/defineImportMeta.ts
-function defineImportMeta() {
-  return {
-    name: "wxt:define",
-    config() {
-      return {
-        define: {
-          // This works for all extension contexts, including background service worker
-          "import.meta.url": "self.location.href"
-        }
-      };
-    }
-  };
-}
+// src/core/utils/building/resolve-config.ts
+import { loadConfig } from "c12";
+import path5 from "node:path";
 
-// src/core/builders/vite/index.ts
-async function createViteBuilder(inlineConfig, userConfig, wxtConfig) {
-  const vite = await import("vite");
-  const getBaseConfig = async () => {
-    const resolvedInlineConfig = await inlineConfig.vite?.(wxtConfig.env) ?? {};
-    const resolvedUserConfig = await userConfig.vite?.(wxtConfig.env) ?? {};
-    const config = vite.mergeConfig(
-      resolvedUserConfig,
-      resolvedInlineConfig
-    );
-    config.root = wxtConfig.root;
-    config.configFile = false;
-    config.logLevel = "warn";
-    config.mode = wxtConfig.mode;
-    config.build ??= {};
-    config.build.outDir = wxtConfig.outDir;
-    config.build.emptyOutDir = false;
-    if (config.build.minify == null && wxtConfig.command === "serve") {
-      config.build.minify = false;
-    }
-    if (config.build.sourcemap == null && wxtConfig.command === "serve") {
-      config.build.sourcemap = "inline";
-    }
-    config.plugins ??= [];
-    config.plugins.push(
-      download(wxtConfig),
-      devHtmlPrerender(wxtConfig),
-      unimport(wxtConfig),
-      virtualEntrypoint("background", wxtConfig),
-      virtualEntrypoint("content-script-isolated-world", wxtConfig),
-      virtualEntrypoint("content-script-main-world", wxtConfig),
-      virtualEntrypoint("unlisted-script", wxtConfig),
-      devServerGlobals(wxtConfig),
-      tsconfigPaths(wxtConfig),
-      noopBackground(),
-      globals(wxtConfig),
-      excludeBrowserPolyfill(wxtConfig),
-      defineImportMeta()
-    );
-    if (wxtConfig.analysis.enabled) {
-      config.plugins.push(bundleAnalysis(wxtConfig));
-    }
-    return config;
-  };
-  const getLibModeConfig = (entrypoint) => {
-    const entry = getRollupEntry(entrypoint);
-    const plugins = [
-      entrypointGroupGlobals(entrypoint)
-    ];
-    if (entrypoint.type === "content-script-style" || entrypoint.type === "unlisted-style") {
-      plugins.push(cssEntrypoints(entrypoint, wxtConfig));
-    }
-    const libMode = {
-      mode: wxtConfig.mode,
-      plugins,
-      build: {
-        lib: {
-          entry,
-          formats: ["iife"],
-          name: "_",
-          fileName: entrypoint.name
-        },
-        rollupOptions: {
-          output: {
-            // There's only a single output for this build, so we use the desired bundle path for the
-            // entry output (like "content-scripts/overlay.js")
-            entryFileNames: getEntrypointBundlePath(
-              entrypoint,
-              wxtConfig.outDir,
-              ".js"
-            ),
-            // Output content script CSS to `content-scripts/`, but all other scripts are written to
-            // `assets/`.
-            assetFileNames: ({ name }) => {
-              if (entrypoint.type === "content-script" && name?.endsWith("css")) {
-                return `content-scripts/${entrypoint.name}.[ext]`;
-              } else {
-                return `assets/${entrypoint.name}.[ext]`;
-              }
-            }
-          }
-        }
-      },
-      define: {
-        // See https://github.com/aklinker1/vite-plugin-web-extension/issues/96
-        "process.env.NODE_ENV": JSON.stringify(wxtConfig.mode)
-      }
-    };
-    return libMode;
-  };
-  const getMultiPageConfig = (entrypoints) => {
-    const htmlEntrypoints = new Set(
-      entrypoints.filter(isHtmlEntrypoint).map((e) => e.name)
-    );
-    return {
-      mode: wxtConfig.mode,
-      plugins: [
-        multipageMove(entrypoints, wxtConfig),
-        entrypointGroupGlobals(entrypoints)
-      ],
-      build: {
-        rollupOptions: {
-          input: entrypoints.reduce((input, entry) => {
-            input[entry.name] = getRollupEntry(entry);
-            return input;
-          }, {}),
-          output: {
-            // Include a hash to prevent conflicts
-            chunkFileNames: "chunks/[name]-[hash].js",
-            entryFileNames: ({ name }) => {
-              if (htmlEntrypoints.has(name))
-                return "chunks/[name]-[hash].js";
-              return "[name].js";
-            },
-            // We can't control the "name", so we need a hash to prevent conflicts
-            assetFileNames: "assets/[name]-[hash].[ext]"
-          }
-        }
-      }
-    };
-  };
-  const getCssConfig = (entrypoint) => {
-    return {
-      mode: wxtConfig.mode,
-      plugins: [entrypointGroupGlobals(entrypoint)],
-      build: {
-        rollupOptions: {
-          input: {
-            [entrypoint.name]: entrypoint.inputPath
-          },
-          output: {
-            assetFileNames: () => {
-              if (entrypoint.type === "content-script-style") {
-                return `content-scripts/${entrypoint.name}.[ext]`;
-              } else {
-                return `assets/${entrypoint.name}.[ext]`;
-              }
-            }
-          }
-        }
-      }
-    };
-  };
+// src/core/utils/cache.ts
+import fs7, { ensureDir as ensureDir2 } from "fs-extra";
+import { dirname as dirname4, resolve as resolve8 } from "path";
+function createFsCache(wxtDir) {
+  const getPath = (key) => resolve8(wxtDir, "cache", encodeURIComponent(key));
   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 set(key, value) {
+      const path8 = getPath(key);
+      await ensureDir2(dirname4(path8));
+      await writeFileIfDifferent(path8, value);
     },
-    async createServer(info) {
-      const serverConfig = {
-        server: {
-          port: info.port,
-          strictPort: true,
-          host: info.hostname,
-          origin: info.origin
-        }
-      };
-      const baseConfig = await getBaseConfig();
-      const viteServer = await vite.createServer(
-        vite.mergeConfig(baseConfig, serverConfig)
-      );
-      const server = {
-        async listen() {
-          await viteServer.listen(info.port);
-        },
-        async close() {
-          await viteServer.close();
-        },
-        transformHtml(...args) {
-          return viteServer.transformIndexHtml(...args);
-        },
-        ws: {
-          send(message, payload) {
-            return viteServer.ws.send(message, payload);
-          },
-          on(message, cb) {
-            viteServer.ws.on(message, cb);
-          }
-        },
-        watcher: viteServer.watcher
-      };
-      return server;
+    async get(key) {
+      const path8 = getPath(key);
+      try {
+        return await fs7.readFile(path8, "utf-8");
+      } catch {
+        return void 0;
+      }
     }
   };
 }
-function getBuildOutputChunks(result) {
-  if ("on" in result)
-    throw Error("wxt does not support vite watch mode.");
-  if (Array.isArray(result))
-    return result.flatMap(({ output }) => output);
-  return result.output;
-}
-function getRollupEntry(entrypoint) {
-  let virtualEntrypointType;
-  switch (entrypoint.type) {
-    case "background":
-    case "unlisted-script":
-      virtualEntrypointType = entrypoint.type;
-      break;
-    case "content-script":
-      virtualEntrypointType = entrypoint.options.world === "MAIN" ? "content-script-main-world" : "content-script-isolated-world";
-      break;
-  }
-  return virtualEntrypointType ? `virtual:wxt-${virtualEntrypointType}?${entrypoint.inputPath}` : entrypoint.inputPath;
-}
 
 // src/core/utils/building/resolve-config.ts
+import consola, { LogLevels } from "consola";
 import defu from "defu";
 
 // src/core/utils/package.ts
@@ -1676,7 +1447,7 @@ function isModuleInstalled(name) {
 
 // src/core/utils/building/resolve-config.ts
 import fs9 from "fs-extra";
-async function resolveConfig(inlineConfig, command, server) {
+async function resolveConfig(inlineConfig, command) {
   let userConfig = {};
   let userConfigMetadata;
   if (inlineConfig.configFile !== false) {
@@ -1692,14 +1463,14 @@ async function resolveConfig(inlineConfig, command, server) {
     userConfig = loadedConfig ?? {};
     userConfigMetadata = metadata;
   }
-  const mergedConfig = mergeInlineConfig(inlineConfig, userConfig);
+  const mergedConfig = await mergeInlineConfig(inlineConfig, userConfig);
   const debug = mergedConfig.debug ?? false;
   const logger = mergedConfig.logger ?? consola;
   if (debug)
     logger.level = LogLevels.debug;
   const browser = mergedConfig.browser ?? "chrome";
   const manifestVersion = mergedConfig.manifestVersion ?? (browser === "firefox" || browser === "safari" ? 2 : 3);
-  const mode = mergedConfig.mode ?? (command === "build" ? "production" : "development");
+  const mode = mergedConfig.mode ?? COMMAND_MODES[command];
   const env = { browser, command, manifestVersion, mode };
   const root = path5.resolve(
     inlineConfig.root ?? userConfig.root ?? process.cwd()
@@ -1738,15 +1509,21 @@ async function resolveConfig(inlineConfig, command, server) {
       "~": srcDir,
       "@@": root,
       "~~": root
-    }).map(([key, value]) => [key, path5.resolve(root, value)])
-  );
-  const analysisOutputFile = path5.resolve(
-    root,
-    mergedConfig.analysis?.outputFile ?? "stats.html"
+    }).map(([key, value]) => [key, path5.resolve(root, value)])
   );
-  const analysisOutputDir = path5.dirname(analysisOutputFile);
-  const analysisOutputName = path5.parse(analysisOutputFile).name;
-  const finalConfig = {
+  let devServerConfig;
+  if (command === "serve") {
+    let port = mergedConfig.dev?.server?.port;
+    if (port == null || !isFinite(port)) {
+      const { default: getPort, portNumbers } = await import("get-port");
+      port = await getPort({ port: portNumbers(3e3, 3010) });
+    }
+    devServerConfig = {
+      port,
+      hostname: "localhost"
+    };
+  }
+  return {
     browser,
     command,
     debug,
@@ -1768,109 +1545,47 @@ async function resolveConfig(inlineConfig, command, server) {
     srcDir,
     typesDir,
     wxtDir,
-    zip: resolveInternalZipConfig(root, mergedConfig),
-    transformManifest(manifest) {
-      userConfig.transformManifest?.(manifest);
-      inlineConfig.transformManifest?.(manifest);
-    },
-    analysis: {
-      enabled: mergedConfig.analysis?.enabled ?? false,
-      open: mergedConfig.analysis?.open ?? false,
-      template: mergedConfig.analysis?.template ?? "treemap",
-      outputFile: analysisOutputFile,
-      outputDir: analysisOutputDir,
-      outputName: analysisOutputName,
-      keepArtifacts: mergedConfig.analysis?.keepArtifacts ?? false
-    },
+    zip: resolveZipConfig(root, mergedConfig),
+    transformManifest: mergedConfig.transformManifest,
+    analysis: resolveAnalysisConfig(root, mergedConfig),
     userConfigMetadata: userConfigMetadata ?? {},
     alias,
-    experimental: {
-      includeBrowserPolyfill: mergedConfig.experimental?.includeBrowserPolyfill ?? true
-    },
-    server,
+    experimental: defu(mergedConfig.experimental, {
+      includeBrowserPolyfill: true
+    }),
     dev: {
+      server: devServerConfig,
       reloadCommand
     },
-    hooks: mergedConfig.hooks ?? {}
-  };
-  const builder = await createViteBuilder(
-    inlineConfig,
-    userConfig,
-    finalConfig
-  );
-  return {
-    ...finalConfig,
-    builder
+    hooks: mergedConfig.hooks ?? {},
+    vite: mergedConfig.vite ?? (() => ({}))
   };
 }
 async function resolveManifestConfig(env, manifest) {
   return await (typeof manifest === "function" ? manifest(env) : manifest ?? {});
 }
-function mergeInlineConfig(inlineConfig, userConfig) {
-  let imports;
-  if (inlineConfig.imports === false || userConfig.imports === false) {
-    imports = false;
-  } else if (userConfig.imports == null && inlineConfig.imports == null) {
-    imports = void 0;
-  } else {
-    imports = defu(inlineConfig.imports ?? {}, userConfig.imports ?? {});
-  }
+async function mergeInlineConfig(inlineConfig, userConfig) {
+  const imports = inlineConfig.imports === false || userConfig.imports === false ? false : userConfig.imports == null && inlineConfig.imports == null ? void 0 : defu(inlineConfig.imports ?? {}, userConfig.imports ?? {});
   const manifest = async (env) => {
     const user = await resolveManifestConfig(env, userConfig.manifest);
     const inline = await resolveManifestConfig(env, inlineConfig.manifest);
     return defu(inline, user);
   };
-  const runner = defu(
-    inlineConfig.runner ?? {},
-    userConfig.runner ?? {}
-  );
-  const zip = defu(
-    inlineConfig.zip ?? {},
-    userConfig.zip ?? {}
-  );
-  const hooks = defu(
-    inlineConfig.hooks ?? {},
-    userConfig.hooks ?? {}
-  );
+  const transformManifest = (manifest2) => {
+    userConfig.transformManifest?.(manifest2);
+    inlineConfig.transformManifest?.(manifest2);
+  };
+  const builderConfig = await mergeBuilderConfig(inlineConfig, userConfig);
   return {
-    root: inlineConfig.root ?? userConfig.root,
-    browser: inlineConfig.browser ?? userConfig.browser,
-    manifestVersion: inlineConfig.manifestVersion ?? userConfig.manifestVersion,
-    configFile: inlineConfig.configFile,
-    debug: inlineConfig.debug ?? userConfig.debug,
-    entrypointsDir: inlineConfig.entrypointsDir ?? userConfig.entrypointsDir,
-    filterEntrypoints: inlineConfig.filterEntrypoints ?? userConfig.filterEntrypoints,
+    ...defu(inlineConfig, userConfig),
+    // Custom merge values
+    transformManifest,
     imports,
-    logger: inlineConfig.logger ?? userConfig.logger,
     manifest,
-    mode: inlineConfig.mode ?? userConfig.mode,
-    publicDir: inlineConfig.publicDir ?? userConfig.publicDir,
-    runner,
-    srcDir: inlineConfig.srcDir ?? userConfig.srcDir,
-    outDir: inlineConfig.outDir ?? userConfig.outDir,
-    zip,
-    analysis: {
-      ...userConfig.analysis,
-      ...inlineConfig.analysis
-    },
-    alias: {
-      ...userConfig.alias,
-      ...inlineConfig.alias
-    },
-    experimental: {
-      ...userConfig.experimental,
-      ...inlineConfig.experimental
-    },
-    vite: void 0,
-    transformManifest: void 0,
-    dev: {
-      ...userConfig.dev,
-      ...inlineConfig.dev
-    },
-    hooks
+    ...builderConfig
   };
 }
-function resolveInternalZipConfig(root, mergedConfig) {
+function resolveZipConfig(root, mergedConfig) {
   const downloadedPackagesDir = path5.resolve(root, ".wxt/local_modules");
   return {
     name: void 0,
@@ -1895,6 +1610,23 @@ function resolveInternalZipConfig(root, mergedConfig) {
     downloadedPackagesDir
   };
 }
+function resolveAnalysisConfig(root, mergedConfig) {
+  const analysisOutputFile = path5.resolve(
+    root,
+    mergedConfig.analysis?.outputFile ?? "stats.html"
+  );
+  const analysisOutputDir = path5.dirname(analysisOutputFile);
+  const analysisOutputName = path5.parse(analysisOutputFile).name;
+  return {
+    enabled: mergedConfig.analysis?.enabled ?? false,
+    open: mergedConfig.analysis?.open ?? false,
+    template: mergedConfig.analysis?.template ?? "treemap",
+    outputFile: analysisOutputFile,
+    outputDir: analysisOutputDir,
+    outputName: analysisOutputName,
+    keepArtifacts: mergedConfig.analysis?.keepArtifacts ?? false
+  };
+}
 async function getUnimportOptions(wxtDir, logger, config) {
   if (config.imports === false)
     return false;
@@ -1947,6 +1679,23 @@ function logMissingDir(logger, name, expected) {
     )}`
   );
 }
+var COMMAND_MODES = {
+  build: "production",
+  serve: "development"
+};
+async function mergeBuilderConfig(inlineConfig, userConfig) {
+  const vite = await import("vite").catch(() => void 0);
+  if (vite) {
+    return {
+      vite: async (env) => {
+        const resolvedInlineConfig = await inlineConfig.vite?.(env) ?? {};
+        const resolvedUserConfig = await userConfig.vite?.(env) ?? {};
+        return vite.mergeConfig(resolvedUserConfig, resolvedInlineConfig);
+      }
+    };
+  }
+  throw Error("Builder not found. Make sure vite is installed.");
+}
 
 // src/core/utils/building/group-entrypoints.ts
 function groupEntrypoints(entrypoints) {
@@ -2379,7 +2128,7 @@ async function generateManifest(entrypoints, buildOutput) {
     addDevModeCsp(manifest);
   if (wxt.config.command === "serve")
     addDevModePermissions(manifest);
-  wxt.config.transformManifest(manifest);
+  wxt.config.transformManifest?.(manifest);
   await wxt.hooks.callHook("build:manifestGenerated", wxt, manifest);
   if (wxt.config.manifestVersion === 2) {
     convertWebAccessibleResourcesToMv2(manifest);
@@ -2660,8 +2409,8 @@ function discoverIcons(buildOutput) {
   return icons.length > 0 ? Object.fromEntries(icons) : void 0;
 }
 function addDevModeCsp(manifest) {
-  const permission = `http://${wxt.config.server?.hostname ?? ""}/*`;
-  const allowedCsp = wxt.config.server?.origin ?? "http://localhost:*";
+  const permission = `http://${wxt.server?.hostname ?? ""}/*`;
+  const allowedCsp = wxt.server?.origin ?? "http://localhost:*";
   if (manifest.manifest_version === 3) {
     addHostPermission(manifest, permission);
   } else {
@@ -2674,7 +2423,7 @@ function addDevModeCsp(manifest) {
     ) : manifest.content_security_policy ?? "script-src 'self'; object-src 'self';"
     // default CSP for MV2
   );
-  if (wxt.config.server)
+  if (wxt.server)
     csp.add("script-src", allowedCsp);
   if (manifest.manifest_version === 3) {
     manifest.content_security_policy ??= {};
@@ -2934,7 +2683,7 @@ async function internalBuild() {
   const target = `${wxt.config.browser}-mv${wxt.config.manifestVersion}`;
   wxt.logger.info(
     `${verb} ${pc5.cyan(target)} for ${pc5.cyan(wxt.config.mode)} with ${pc5.green(
-      `${wxt.config.builder.name} ${wxt.config.builder.version}`
+      `${wxt.builder.name} ${wxt.builder.version}`
     )}`
   );
   const startTime = Date.now();
@@ -3232,11 +2981,227 @@ var packageManagers = {
   yarn
 };
 
+// src/core/builders/vite/index.ts
+async function createViteBuilder(wxtConfig, server) {
+  const vite = await import("vite");
+  const getBaseConfig = async () => {
+    const config = await wxtConfig.vite(wxtConfig.env);
+    config.root = wxtConfig.root;
+    config.configFile = false;
+    config.logLevel = "warn";
+    config.mode = wxtConfig.mode;
+    config.build ??= {};
+    config.build.outDir = wxtConfig.outDir;
+    config.build.emptyOutDir = false;
+    if (config.build.minify == null && wxtConfig.command === "serve") {
+      config.build.minify = false;
+    }
+    if (config.build.sourcemap == null && wxtConfig.command === "serve") {
+      config.build.sourcemap = "inline";
+    }
+    config.plugins ??= [];
+    config.plugins.push(
+      download(wxtConfig),
+      devHtmlPrerender(wxtConfig, server),
+      unimport(wxtConfig),
+      virtualEntrypoint("background", wxtConfig),
+      virtualEntrypoint("content-script-isolated-world", wxtConfig),
+      virtualEntrypoint("content-script-main-world", wxtConfig),
+      virtualEntrypoint("unlisted-script", wxtConfig),
+      devServerGlobals(wxtConfig, server),
+      tsconfigPaths(wxtConfig),
+      noopBackground(),
+      globals(wxtConfig),
+      excludeBrowserPolyfill(wxtConfig),
+      defineImportMeta()
+    );
+    if (wxtConfig.analysis.enabled) {
+      config.plugins.push(bundleAnalysis(wxtConfig));
+    }
+    return config;
+  };
+  const getLibModeConfig = (entrypoint) => {
+    const entry = getRollupEntry(entrypoint);
+    const plugins = [
+      entrypointGroupGlobals(entrypoint)
+    ];
+    if (entrypoint.type === "content-script-style" || entrypoint.type === "unlisted-style") {
+      plugins.push(cssEntrypoints(entrypoint, wxtConfig));
+    }
+    const libMode = {
+      mode: wxtConfig.mode,
+      plugins,
+      build: {
+        lib: {
+          entry,
+          formats: ["iife"],
+          name: "_",
+          fileName: entrypoint.name
+        },
+        rollupOptions: {
+          output: {
+            // There's only a single output for this build, so we use the desired bundle path for the
+            // entry output (like "content-scripts/overlay.js")
+            entryFileNames: getEntrypointBundlePath(
+              entrypoint,
+              wxtConfig.outDir,
+              ".js"
+            ),
+            // Output content script CSS to `content-scripts/`, but all other scripts are written to
+            // `assets/`.
+            assetFileNames: ({ name }) => {
+              if (entrypoint.type === "content-script" && name?.endsWith("css")) {
+                return `content-scripts/${entrypoint.name}.[ext]`;
+              } else {
+                return `assets/${entrypoint.name}.[ext]`;
+              }
+            }
+          }
+        }
+      },
+      define: {
+        // See https://github.com/aklinker1/vite-plugin-web-extension/issues/96
+        "process.env.NODE_ENV": JSON.stringify(wxtConfig.mode)
+      }
+    };
+    return libMode;
+  };
+  const getMultiPageConfig = (entrypoints) => {
+    const htmlEntrypoints = new Set(
+      entrypoints.filter(isHtmlEntrypoint).map((e) => e.name)
+    );
+    return {
+      mode: wxtConfig.mode,
+      plugins: [
+        multipageMove(entrypoints, wxtConfig),
+        entrypointGroupGlobals(entrypoints)
+      ],
+      build: {
+        rollupOptions: {
+          input: entrypoints.reduce((input, entry) => {
+            input[entry.name] = getRollupEntry(entry);
+            return input;
+          }, {}),
+          output: {
+            // Include a hash to prevent conflicts
+            chunkFileNames: "chunks/[name]-[hash].js",
+            entryFileNames: ({ name }) => {
+              if (htmlEntrypoints.has(name))
+                return "chunks/[name]-[hash].js";
+              return "[name].js";
+            },
+            // We can't control the "name", so we need a hash to prevent conflicts
+            assetFileNames: "assets/[name]-[hash].[ext]"
+          }
+        }
+      }
+    };
+  };
+  const getCssConfig = (entrypoint) => {
+    return {
+      mode: wxtConfig.mode,
+      plugins: [entrypointGroupGlobals(entrypoint)],
+      build: {
+        rollupOptions: {
+          input: {
+            [entrypoint.name]: entrypoint.inputPath
+          },
+          output: {
+            assetFileNames: () => {
+              if (entrypoint.type === "content-script-style") {
+                return `content-scripts/${entrypoint.name}.[ext]`;
+              } else {
+                return `assets/${entrypoint.name}.[ext]`;
+              }
+            }
+          }
+        }
+      }
+    };
+  };
+  return {
+    name: "Vite",
+    version: vite.version,
+    async build(group) {
+      let entryConfig;
+      if (Array.isArray(group))
+        entryConfig = getMultiPageConfig(group);
+      else if (group.inputPath.endsWith(".css"))
+        entryConfig = getCssConfig(group);
+      else
+        entryConfig = getLibModeConfig(group);
+      const buildConfig = vite.mergeConfig(await getBaseConfig(), entryConfig);
+      const result = await vite.build(buildConfig);
+      return {
+        entrypoints: group,
+        chunks: getBuildOutputChunks(result)
+      };
+    },
+    async createServer(info) {
+      const serverConfig = {
+        server: {
+          port: info.port,
+          strictPort: true,
+          host: info.hostname,
+          origin: info.origin
+        }
+      };
+      const baseConfig = await getBaseConfig();
+      const viteServer = await vite.createServer(
+        vite.mergeConfig(baseConfig, serverConfig)
+      );
+      const server2 = {
+        async listen() {
+          await viteServer.listen(info.port);
+        },
+        async close() {
+          await viteServer.close();
+        },
+        transformHtml(...args) {
+          return viteServer.transformIndexHtml(...args);
+        },
+        ws: {
+          send(message, payload) {
+            return viteServer.ws.send(message, payload);
+          },
+          on(message, cb) {
+            viteServer.ws.on(message, cb);
+          }
+        },
+        watcher: viteServer.watcher
+      };
+      return server2;
+    }
+  };
+}
+function getBuildOutputChunks(result) {
+  if ("on" in result)
+    throw Error("wxt does not support vite watch mode.");
+  if (Array.isArray(result))
+    return result.flatMap(({ output }) => output);
+  return result.output;
+}
+function getRollupEntry(entrypoint) {
+  let virtualEntrypointType;
+  switch (entrypoint.type) {
+    case "background":
+    case "unlisted-script":
+      virtualEntrypointType = entrypoint.type;
+      break;
+    case "content-script":
+      virtualEntrypointType = entrypoint.options.world === "MAIN" ? "content-script-main-world" : "content-script-isolated-world";
+      break;
+  }
+  return virtualEntrypointType ? `virtual:wxt-${virtualEntrypointType}?${entrypoint.inputPath}` : entrypoint.inputPath;
+}
+
 // src/core/wxt.ts
 var wxt;
-async function registerWxt(command, inlineConfig = {}, server) {
-  const config = await resolveConfig(inlineConfig, command, server);
+async function registerWxt(command, inlineConfig = {}, getServer) {
   const hooks = createHooks();
+  const config = await resolveConfig(inlineConfig, command);
+  const server = await getServer?.(config);
+  const builder = await createViteBuilder(config, server);
   const pm = await createWxtPackageManager(config.root);
   wxt = {
     config,
@@ -3245,9 +3210,11 @@ async function registerWxt(command, inlineConfig = {}, server) {
       return config.logger;
     },
     async reloadConfig() {
-      wxt.config = await resolveConfig(inlineConfig, command, server);
+      wxt.config = await resolveConfig(inlineConfig, command);
     },
-    pm
+    pm,
+    builder,
+    server
   };
   wxt.hooks.addHooks(config.hooks);
   await wxt.hooks.callHook("ready", wxt);
@@ -3256,19 +3223,19 @@ async function registerWxt(command, inlineConfig = {}, server) {
 export {
   normalizePath,
   unnormalizePath,
-  wxt,
-  registerWxt,
-  detectDevChanges,
   getEntrypointBundlePath,
   isHtmlEntrypoint,
-  findEntrypoints,
-  generateTypesDir,
   formatDuration,
   download,
   unimport,
   tsconfigPaths,
   globals,
   webextensionPolyfillMock,
+  wxt,
+  registerWxt,
+  detectDevChanges,
+  findEntrypoints,
+  generateTypesDir,
   getPackageJson,
   resolveConfig,
   kebabCaseAlphanumeric,