wxt 0.16.2 → 0.16.3

package/dist/cli.js

@@ -20,6 +20,26 @@ function unnormalizePath(path7) {
 var CSS_EXTENSIONS = ["css", "scss", "sass", "less", "styl", "stylus"];
 var CSS_EXTENSIONS_PATTERN = `+(${CSS_EXTENSIONS.join("|")})`;
 
+// src/core/wxt.ts
+import { createHooks } from "hookable";
+var wxt;
+async function registerWxt(command, inlineConfig = {}, server) {
+  const config = await resolveConfig(inlineConfig, command, server);
+  const hooks = createHooks();
+  wxt = {
+    config,
+    hooks,
+    get logger() {
+      return config.logger;
+    },
+    async reloadConfig() {
+      wxt.config = await resolveConfig(inlineConfig, command, server);
+    }
+  };
+  wxt.hooks.addHooks(config.hooks);
+  await wxt.hooks.callHook("ready", wxt);
+}
+
 // src/core/utils/fs.ts
 async function writeFileIfDifferent(file, newContents) {
   const existingContents = await fs.readFile(file, "utf-8").catch(() => void 0);
@@ -27,10 +47,10 @@ async function writeFileIfDifferent(file, newContents) {
     await fs.writeFile(file, newContents);
   }
 }
-async function getPublicFiles(config) {
-  if (!await fs.exists(config.publicDir))
+async function getPublicFiles() {
+  if (!await fs.exists(wxt.config.publicDir))
     return [];
-  const files = await glob("**/*", { cwd: config.publicDir });
+  const files = await glob("**/*", { cwd: wxt.config.publicDir });
   return files.map(unnormalizePath);
 }
 
@@ -38,7 +58,7 @@ async function getPublicFiles(config) {
 import fs2 from "fs-extra";
 import { dirname, resolve } from "path";
 import pc from "picocolors";
-async function buildEntrypoints(groups, config, spinner) {
+async function buildEntrypoints(groups, spinner) {
   const steps = [];
   for (let i = 0; i < groups.length; i++) {
     const group = groups[i];
@@ -46,22 +66,22 @@ async function buildEntrypoints(groups, config, spinner) {
     const groupNameColored = groupNames.join(pc.dim(", "));
     spinner.text = pc.dim(`[${i + 1}/${groups.length}]`) + ` ${groupNameColored}`;
     try {
-      steps.push(await config.builder.build(group));
+      steps.push(await wxt.config.builder.build(group));
     } catch (err) {
       throw Error(`Failed to build ${groupNames.join(", ")}`, { cause: err });
     }
   }
-  const publicAssets = await copyPublicDirectory(config);
+  const publicAssets = await copyPublicDirectory();
   return { publicAssets, steps };
 }
-async function copyPublicDirectory(config) {
-  const files = await getPublicFiles(config);
+async function copyPublicDirectory() {
+  const files = await getPublicFiles();
   if (files.length === 0)
     return [];
   const publicAssets = [];
   for (const file of files) {
-    const srcPath = resolve(config.publicDir, file);
-    const outPath = resolve(config.outDir, file);
+    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({
@@ -87,16 +107,16 @@ function some(array, predicate) {
 }
 
 // src/core/utils/building/detect-dev-changes.ts
-function detectDevChanges(config, changedFiles, currentOutput) {
+function detectDevChanges(changedFiles, currentOutput) {
   const isConfigChange = some(
     changedFiles,
-    (file) => file === config.userConfigMetadata.configFile
+    (file) => file === wxt.config.userConfigMetadata.configFile
   );
   if (isConfigChange)
     return { type: "full-restart" };
   const isRunnerChange = some(
     changedFiles,
-    (file) => file === config.runnerConfig.configFile
+    (file) => file === wxt.config.runnerConfig.configFile
   );
   if (isRunnerChange)
     return { type: "browser-restart" };
@@ -214,15 +234,15 @@ var VIRTUAL_NOOP_BACKGROUND_MODULE_ID = "virtual:user-background";
 
 // src/core/utils/building/find-entrypoints.ts
 import pc2 from "picocolors";
-async function findEntrypoints(config) {
+async function findEntrypoints() {
   const relativePaths = await glob2(Object.keys(PATH_GLOB_TO_TYPE_MAP), {
-    cwd: config.entrypointsDir
+    cwd: wxt.config.entrypointsDir
   });
   relativePaths.sort();
   const pathGlobs = Object.keys(PATH_GLOB_TO_TYPE_MAP);
   const entrypointInfos = relativePaths.reduce((results, relativePath) => {
-    const inputPath = resolve3(config.entrypointsDir, relativePath);
-    const name = getEntrypointName(config.entrypointsDir, inputPath);
+    const inputPath = resolve3(wxt.config.entrypointsDir, relativePath);
+    const name = getEntrypointName(wxt.config.entrypointsDir, inputPath);
     const matchingGlob = pathGlobs.find(
       (glob5) => minimatch(relativePath, glob5)
     );
@@ -232,36 +252,36 @@ async function findEntrypoints(config) {
         name,
         inputPath,
         type,
-        skipped: config.filterEntrypoints != null && !config.filterEntrypoints.has(name)
+        skipped: wxt.config.filterEntrypoints != null && !wxt.config.filterEntrypoints.has(name)
       });
     }
     return results;
   }, []);
-  preventNoEntrypoints(config, entrypointInfos);
-  preventDuplicateEntrypointNames(config, entrypointInfos);
+  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(config, info);
+          return await getPopupEntrypoint(info);
         case "options":
-          return await getOptionsEntrypoint(config, info);
+          return await getOptionsEntrypoint(info);
         case "background":
           hasBackground = true;
-          return await getBackgroundEntrypoint(config, info);
+          return await getBackgroundEntrypoint(info);
         case "content-script":
-          return await getContentScriptEntrypoint(config, info);
+          return await getContentScriptEntrypoint(info);
         case "unlisted-page":
-          return await getUnlistedPageEntrypoint(config, info);
+          return await getUnlistedPageEntrypoint(info);
         case "unlisted-script":
-          return await getUnlistedScriptEntrypoint(config, info);
+          return await getUnlistedScriptEntrypoint(info);
         case "content-script-style":
           return {
             ...info,
             type,
-            outputDir: resolve3(config.outDir, CONTENT_SCRIPT_OUT_DIR),
+            outputDir: resolve3(wxt.config.outDir, CONTENT_SCRIPT_OUT_DIR),
             options: {
               include: void 0,
               exclude: void 0
@@ -271,7 +291,7 @@ async function findEntrypoints(config) {
           return {
             ...info,
             type,
-            outputDir: config.outDir,
+            outputDir: wxt.config.outDir,
             options: {
               include: void 0,
               exclude: void 0
@@ -280,9 +300,9 @@ async function findEntrypoints(config) {
       }
     })
   );
-  if (config.command === "serve" && !hasBackground) {
+  if (wxt.config.command === "serve" && !hasBackground) {
     entrypoints.push(
-      await getBackgroundEntrypoint(config, {
+      await getBackgroundEntrypoint({
         inputPath: VIRTUAL_NOOP_BACKGROUND_MODULE_ID,
         name: "background",
         type: "background",
@@ -290,10 +310,10 @@ async function findEntrypoints(config) {
       })
     );
   }
-  config.logger.debug("All entrypoints:", entrypoints);
+  wxt.logger.debug("All entrypoints:", entrypoints);
   const skippedEntrypointNames = entrypointInfos.filter((item) => item.skipped).map((item) => item.name);
   if (skippedEntrypointNames.length) {
-    config.logger.warn(
+    wxt.logger.warn(
       `Filter excluded the following entrypoints:
 ${skippedEntrypointNames.map((item) => `${pc2.dim("-")} ${pc2.cyan(item)}`).join("\n")}`
     );
@@ -301,26 +321,27 @@ ${skippedEntrypointNames.map((item) => `${pc2.dim("-")} ${pc2.cyan(item)}`).join
   const targetEntrypoints = entrypoints.filter((entry) => {
     const { include, exclude } = entry.options;
     if (include?.length && exclude?.length) {
-      config.logger.warn(
+      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(config.browser);
+      return !exclude.includes(wxt.config.browser);
     }
     if (include?.length && !exclude?.length) {
-      return include.includes(config.browser);
+      return include.includes(wxt.config.browser);
     }
     if (skippedEntrypointNames.includes(entry.name)) {
       return false;
     }
     return true;
   });
-  config.logger.debug(`${config.browser} entrypoints:`, targetEntrypoints);
+  wxt.logger.debug(`${wxt.config.browser} entrypoints:`, targetEntrypoints);
+  await wxt.hooks.callHook("entrypoints:resolved", wxt, targetEntrypoints);
   return targetEntrypoints;
 }
-function preventDuplicateEntrypointNames(config, files) {
+function preventDuplicateEntrypointNames(files) {
   const namesToPaths = files.reduce(
     (map, { name, inputPath }) => {
       map[name] ??= [];
@@ -334,7 +355,7 @@ function preventDuplicateEntrypointNames(config, files) {
       if (absolutePaths.length > 1) {
         lines.push(`- ${name}`);
         absolutePaths.forEach((absolutePath) => {
-          lines.push(`  - ${relative2(config.root, absolutePath)}`);
+          lines.push(`  - ${relative2(wxt.config.root, absolutePath)}`);
         });
       }
       return lines;
@@ -350,9 +371,9 @@ ${errorContent}`
     );
   }
 }
-function preventNoEntrypoints(config, files) {
+function preventNoEntrypoints(files) {
   if (files.length === 0) {
-    throw Error(`No entrypoints found in ${config.entrypointsDir}`);
+    throw Error(`No entrypoints found in ${wxt.config.entrypointsDir}`);
   }
 }
 function getHtmlBaseOptions(document) {
@@ -367,7 +388,11 @@ function getHtmlBaseOptions(document) {
   }
   return options;
 }
-async function getPopupEntrypoint(config, { inputPath, name, skipped }) {
+async function getPopupEntrypoint({
+  inputPath,
+  name,
+  skipped
+}) {
   const content = await fs3.readFile(inputPath, "utf-8");
   const { document } = parseHTML(content);
   const options = getHtmlBaseOptions(document);
@@ -379,7 +404,7 @@ async function getPopupEntrypoint(config, { inputPath, name, skipped }) {
     try {
       options.defaultIcon = JSON5.parse(defaultIconContent);
     } catch (err) {
-      config.logger.fatal(
+      wxt.logger.fatal(
         `Failed to parse default_icon meta tag content as JSON5. content=${defaultIconContent}`,
         err
       );
@@ -398,11 +423,15 @@ async function getPopupEntrypoint(config, { inputPath, name, skipped }) {
     name: "popup",
     options,
     inputPath,
-    outputDir: config.outDir,
+    outputDir: wxt.config.outDir,
     skipped
   };
 }
-async function getOptionsEntrypoint(config, { inputPath, name, skipped }) {
+async function getOptionsEntrypoint({
+  inputPath,
+  name,
+  skipped
+}) {
   const content = await fs3.readFile(inputPath, "utf-8");
   const { document } = parseHTML(content);
   const options = getHtmlBaseOptions(document);
@@ -423,27 +452,32 @@ async function getOptionsEntrypoint(config, { inputPath, name, skipped }) {
     name: "options",
     options,
     inputPath,
-    outputDir: config.outDir,
+    outputDir: wxt.config.outDir,
     skipped
   };
 }
-async function getUnlistedPageEntrypoint(config, { inputPath, name, skipped }) {
+async function getUnlistedPageEntrypoint({
+  inputPath,
+  name,
+  skipped
+}) {
   const content = await fs3.readFile(inputPath, "utf-8");
   const { document } = parseHTML(content);
   return {
     type: "unlisted-page",
-    name: getEntrypointName(config.entrypointsDir, inputPath),
+    name: getEntrypointName(wxt.config.entrypointsDir, inputPath),
     inputPath,
-    outputDir: config.outDir,
+    outputDir: wxt.config.outDir,
     options: getHtmlBaseOptions(document),
     skipped
   };
 }
-async function getUnlistedScriptEntrypoint(config, { inputPath, name, skipped }) {
-  const defaultExport = await importEntrypointFile(
-    inputPath,
-    config
-  );
+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(...)"?`
@@ -455,18 +489,19 @@ async function getUnlistedScriptEntrypoint(config, { inputPath, name, skipped })
     type: "unlisted-script",
     name,
     inputPath,
-    outputDir: config.outDir,
+    outputDir: wxt.config.outDir,
     options,
     skipped
   };
 }
-async function getBackgroundEntrypoint(config, { inputPath, name, skipped }) {
+async function getBackgroundEntrypoint({
+  inputPath,
+  name,
+  skipped
+}) {
   let options = {};
   if (inputPath !== VIRTUAL_NOOP_BACKGROUND_MODULE_ID) {
-    const defaultExport = await importEntrypointFile(
-      inputPath,
-      config
-    );
+    const defaultExport = await importEntrypointFile(inputPath);
     if (defaultExport == null) {
       throw Error(
         `${name}: Default export not found, did you forget to call "export default defineBackground(...)"?`
@@ -475,24 +510,31 @@ async function getBackgroundEntrypoint(config, { inputPath, name, skipped }) {
     const { main: _, ...moduleOptions } = defaultExport;
     options = moduleOptions;
   }
-  if (config.manifestVersion !== 3) {
+  if (wxt.config.manifestVersion !== 3) {
     delete options.type;
   }
   return {
     type: "background",
     name,
     inputPath,
-    outputDir: config.outDir,
+    outputDir: wxt.config.outDir,
     options: {
       ...options,
-      type: resolvePerBrowserOption(options.type, config.browser),
-      persistent: resolvePerBrowserOption(options.persistent, config.browser)
+      type: resolvePerBrowserOption(options.type, wxt.config.browser),
+      persistent: resolvePerBrowserOption(
+        options.persistent,
+        wxt.config.browser
+      )
     },
     skipped
   };
 }
-async function getContentScriptEntrypoint(config, { inputPath, name, skipped }) {
-  const { main: _, ...options } = await importEntrypointFile(inputPath, config);
+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(...)"?`
@@ -502,7 +544,7 @@ async function getContentScriptEntrypoint(config, { inputPath, name, skipped })
     type: "content-script",
     name,
     inputPath,
-    outputDir: resolve3(config.outDir, CONTENT_SCRIPT_OUT_DIR),
+    outputDir: resolve3(wxt.config.outDir, CONTENT_SCRIPT_OUT_DIR),
     options,
     skipped
   };
@@ -672,23 +714,23 @@ function parseI18nMessages(messagesJson) {
 }
 
 // src/core/utils/building/generate-wxt-dir.ts
-async function generateTypesDir(entrypoints, config) {
-  await fs4.ensureDir(config.typesDir);
+async function generateTypesDir(entrypoints) {
+  await fs4.ensureDir(wxt.config.typesDir);
   const references = [];
-  const imports = getUnimportOptions(config);
+  const imports = getUnimportOptions(wxt.config);
   if (imports !== false) {
-    references.push(await writeImportsDeclarationFile(config, imports));
+    references.push(await writeImportsDeclarationFile(imports));
   }
-  references.push(await writePathsDeclarationFile(entrypoints, config));
-  references.push(await writeI18nDeclarationFile(config));
-  references.push(await writeGlobalsDeclarationFile(config));
-  const mainReference = await writeMainDeclarationFile(references, config);
-  await writeTsConfigFile(mainReference, config);
+  references.push(await writePathsDeclarationFile(entrypoints));
+  references.push(await writeI18nDeclarationFile());
+  references.push(await writeGlobalsDeclarationFile());
+  const mainReference = await writeMainDeclarationFile(references);
+  await writeTsConfigFile(mainReference);
 }
-async function writeImportsDeclarationFile(config, unimportOptions) {
-  const filePath = resolve4(config.typesDir, "imports.d.ts");
+async function writeImportsDeclarationFile(unimportOptions) {
+  const filePath = resolve4(wxt.config.typesDir, "imports.d.ts");
   const unimport2 = createUnimport(unimportOptions);
-  await unimport2.scanImportsFromDir(void 0, { cwd: config.srcDir });
+  await unimport2.scanImportsFromDir(void 0, { cwd: wxt.config.srcDir });
   await writeFileIfDifferent(
     filePath,
     ["// Generated by wxt", await unimport2.generateTypeDeclarations()].join(
@@ -697,15 +739,15 @@ async function writeImportsDeclarationFile(config, unimportOptions) {
   );
   return filePath;
 }
-async function writePathsDeclarationFile(entrypoints, config) {
-  const filePath = resolve4(config.typesDir, "paths.d.ts");
+async function writePathsDeclarationFile(entrypoints) {
+  const filePath = resolve4(wxt.config.typesDir, "paths.d.ts");
   const unions = entrypoints.map(
     (entry) => getEntrypointBundlePath(
       entry,
-      config.outDir,
+      wxt.config.outDir,
       entry.inputPath.endsWith(".html") ? ".html" : ".js"
     )
-  ).concat(await getPublicFiles(config)).map(normalizePath).map((path7) => `    | "/${path7}"`).sort().join("\n");
+  ).concat(await getPublicFiles()).map(normalizePath).map((path7) => `    | "/${path7}"`).sort().join("\n");
   const template = `// Generated by wxt
 import "wxt/browser";
 
@@ -725,9 +767,9 @@ declare module "wxt/browser" {
   );
   return filePath;
 }
-async function writeI18nDeclarationFile(config) {
-  const filePath = resolve4(config.typesDir, "i18n.d.ts");
-  const defaultLocale = config.manifest.default_locale;
+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";
 
@@ -750,7 +792,7 @@ declare module "wxt/browser" {
   let messages;
   if (defaultLocale) {
     const defaultLocalePath = path2.resolve(
-      config.publicDir,
+      wxt.config.publicDir,
       "_locales",
       defaultLocale,
       "messages.json"
@@ -778,9 +820,9 @@ declare module "wxt/browser" {
   );
   return filePath;
 }
-async function writeGlobalsDeclarationFile(config) {
-  const filePath = resolve4(config.typesDir, "globals.d.ts");
-  const globals2 = [...getGlobals(config), ...getEntrypointGlobals("")];
+async function writeGlobalsDeclarationFile() {
+  const filePath = resolve4(wxt.config.typesDir, "globals.d.ts");
+  const globals2 = [...getGlobals(wxt.config), ...getEntrypointGlobals("")];
   await writeFileIfDifferent(
     filePath,
     [
@@ -796,8 +838,8 @@ async function writeGlobalsDeclarationFile(config) {
   );
   return filePath;
 }
-async function writeMainDeclarationFile(references, config) {
-  const dir = config.wxtDir;
+async function writeMainDeclarationFile(references) {
+  const dir = wxt.config.wxtDir;
   const filePath = resolve4(dir, "wxt.d.ts");
   await writeFileIfDifferent(
     filePath,
@@ -811,10 +853,10 @@ async function writeMainDeclarationFile(references, config) {
   );
   return filePath;
 }
-async function writeTsConfigFile(mainReference, config) {
-  const dir = config.wxtDir;
+async function writeTsConfigFile(mainReference) {
+  const dir = wxt.config.wxtDir;
   const getTsconfigPath = (path7) => normalizePath(relative3(dir, path7));
-  const paths = Object.entries(config.alias).flatMap(([alias, absolutePath]) => {
+  const paths = Object.entries(wxt.config.alias).flatMap(([alias, absolutePath]) => {
     const aliasPath = getTsconfigPath(absolutePath);
     return [
       `      "${alias}": ["${aliasPath}"]`,
@@ -839,15 +881,15 @@ ${paths}
     }
   },
   "include": [
-    "${getTsconfigPath(config.root)}/**/*",
+    "${getTsconfigPath(wxt.config.root)}/**/*",
     "./${getTsconfigPath(mainReference)}"
   ],
-  "exclude": ["${getTsconfigPath(config.outBaseDir)}"]
+  "exclude": ["${getTsconfigPath(wxt.config.outBaseDir)}"]
 }`
   );
 }
 
-// src/core/utils/building/get-internal-config.ts
+// src/core/utils/building/resolve-config.ts
 import { loadConfig } from "c12";
 import path3 from "node:path";
 
@@ -873,7 +915,7 @@ function createFsCache(wxtDir) {
   };
 }
 
-// src/core/utils/building/get-internal-config.ts
+// src/core/utils/building/resolve-config.ts
 import consola, { LogLevels } from "consola";
 
 // src/core/builders/vite/plugins/devHtmlPrerender.ts
@@ -1595,9 +1637,9 @@ function getRollupEntry(entrypoint) {
   return virtualEntrypointType ? `virtual:wxt-${virtualEntrypointType}?${entrypoint.inputPath}` : entrypoint.inputPath;
 }
 
-// src/core/utils/building/get-internal-config.ts
+// src/core/utils/building/resolve-config.ts
 import defu2 from "defu";
-async function getInternalConfig(inlineConfig, command, server) {
+async function resolveConfig(inlineConfig, command, server) {
   let userConfig = {};
   let userConfigMetadata;
   if (inlineConfig.configFile !== false) {
@@ -1691,7 +1733,8 @@ async function getInternalConfig(inlineConfig, command, server) {
     server,
     dev: {
       reloadCommand
-    }
+    },
+    hooks: mergedConfig.hooks ?? {}
   };
   const builder = await createViteBuilder(
     inlineConfig,
@@ -1728,6 +1771,10 @@ function mergeInlineConfig(inlineConfig, userConfig) {
     inlineConfig.zip ?? {},
     userConfig.zip ?? {}
   );
+  const hooks = defu2(
+    inlineConfig.hooks ?? {},
+    userConfig.hooks ?? {}
+  );
   return {
     root: inlineConfig.root ?? userConfig.root,
     browser: inlineConfig.browser ?? userConfig.browser,
@@ -1762,7 +1809,8 @@ function mergeInlineConfig(inlineConfig, userConfig) {
     dev: {
       ...userConfig.dev,
       ...inlineConfig.dev
-    }
+    },
+    hooks
   };
 }
 function resolveInternalZipConfig(root, mergedConfig) {
@@ -1853,11 +1901,11 @@ ${noImports}`;
 // src/core/utils/building/import-entrypoint.ts
 import { transformSync } from "esbuild";
 import { fileURLToPath } from "node:url";
-async function importEntrypointFile(path7, config) {
-  config.logger.debug("Loading file metadata:", path7);
+async function importEntrypointFile(path7) {
+  wxt.logger.debug("Loading file metadata:", path7);
   const normalPath = normalizePath(path7);
   const unimport2 = createUnimport3({
-    ...getUnimportOptions(config),
+    ...getUnimportOptions(wxt.config),
     // Only allow specific imports, not all from the project
     dirs: []
   });
@@ -1865,18 +1913,18 @@ async function importEntrypointFile(path7, config) {
   const text = await fs8.readFile(path7, "utf-8");
   const textNoImports = removeProjectImportStatements(text);
   const { code } = await unimport2.injectImports(textNoImports);
-  config.logger.debug(
+  wxt.logger.debug(
     ["Text:", text, "No imports:", textNoImports, "Code:", code].join("\n")
   );
   const jiti = createJITI(
     typeof __filename !== "undefined" ? __filename : fileURLToPath(import.meta.url),
     {
       cache: false,
-      debug: config.debug,
+      debug: wxt.config.debug,
       esmResolve: true,
       alias: {
         "webextension-polyfill": resolve9(
-          config.root,
+          wxt.config.root,
           "node_modules/wxt/dist/virtual/mock-browser.js"
         )
       },
@@ -1908,7 +1956,7 @@ async function importEntrypointFile(path7, config) {
     const res = await jiti(path7);
     return res.default;
   } catch (err) {
-    const filePath = relative5(config.root, path7);
+    const filePath = relative5(wxt.config.root, path7);
     if (err instanceof ReferenceError) {
       const variableName = err.message.replace(" is not defined", "");
       throw Error(
@@ -1916,7 +1964,7 @@ async function importEntrypointFile(path7, config) {
         { cause: err }
       );
     } else {
-      config.logger.error(err);
+      wxt.logger.error(err);
       throw Error(`Failed to load entrypoint: ${filePath}`, { cause: err });
     }
   }
@@ -2010,7 +2058,7 @@ function getChunkColor(filename) {
 }
 
 // src/core/utils/log/printBuildSummary.ts
-async function printBuildSummary(log, header, output, config) {
+async function printBuildSummary(log, header, output) {
   const chunks = [
     ...output.steps.flatMap((step) => step.chunks),
     ...output.publicAssets
@@ -2022,8 +2070,10 @@ async function printBuildSummary(log, header, output, config) {
       return diff;
     return l.fileName.localeCompare(r.fileName);
   });
-  const files = chunks.map((chunk) => resolve10(config.outDir, chunk.fileName));
-  await printFileList(log, header, config.outDir, files);
+  const files = chunks.map(
+    (chunk) => resolve10(wxt.config.outDir, chunk.fileName)
+  );
+  await printFileList(log, header, wxt.config.outDir, files);
 }
 var DEFAULT_SORT_WEIGHT = 100;
 var CHUNK_SORT_WEIGHTS = {
@@ -2043,7 +2093,7 @@ function getChunkSortWeight(filename) {
 import pc4 from "picocolors";
 
 // package.json
-var version = "0.16.2";
+var version = "0.16.3";
 
 // src/core/utils/log/printHeader.ts
 import { consola as consola2 } from "consola";
@@ -2103,8 +2153,8 @@ var ContentSecurityPolicy = class _ContentSecurityPolicy {
 };
 
 // src/core/utils/content-scripts.ts
-function hashContentScriptOptions(options, config) {
-  const simplifiedOptions = mapWxtOptionsToContentScript(options, config);
+function hashContentScriptOptions(options) {
+  const simplifiedOptions = mapWxtOptionsToContentScript(options);
   Object.keys(simplifiedOptions).forEach((key) => {
     if (simplifiedOptions[key] == null)
       delete simplifiedOptions[key];
@@ -2130,31 +2180,31 @@ function hashContentScriptOptions(options, config) {
     }).sort((l, r) => l[0].localeCompare(r[0]))
   );
 }
-function mapWxtOptionsToContentScript(options, config) {
+function mapWxtOptionsToContentScript(options) {
   return {
-    matches: resolvePerBrowserOption(options.matches, config.browser),
-    all_frames: resolvePerBrowserOption(options.allFrames, config.browser),
+    matches: resolvePerBrowserOption(options.matches, wxt.config.browser),
+    all_frames: resolvePerBrowserOption(options.allFrames, wxt.config.browser),
     match_about_blank: resolvePerBrowserOption(
       options.matchAboutBlank,
-      config.browser
+      wxt.config.browser
     ),
     exclude_globs: resolvePerBrowserOption(
       options.excludeGlobs,
-      config.browser
+      wxt.config.browser
     ),
     exclude_matches: resolvePerBrowserOption(
       options.excludeMatches,
-      config.browser
+      wxt.config.browser
     ),
     include_globs: resolvePerBrowserOption(
       options.includeGlobs,
-      config.browser
+      wxt.config.browser
     ),
-    run_at: resolvePerBrowserOption(options.runAt, config.browser),
+    run_at: resolvePerBrowserOption(options.runAt, wxt.config.browser),
     // @ts-expect-error: untyped chrome options
     match_origin_as_fallback: resolvePerBrowserOption(
       options.matchOriginAsFallback,
-      config.browser
+      wxt.config.browser
     ),
     world: options.world
   };
@@ -2163,12 +2213,12 @@ function mapWxtOptionsToContentScript(options, config) {
 // src/core/utils/package.ts
 import { resolve as resolve11 } from "node:path";
 import fs10 from "fs-extra";
-async function getPackageJson(config) {
-  const file = resolve11(config.root, "package.json");
+async function getPackageJson() {
+  const file = resolve11(wxt.config.root, "package.json");
   try {
     return await fs10.readJson(file);
   } catch (err) {
-    config.logger.debug(
+    wxt.logger.debug(
       `Failed to read package.json at: ${file}. Returning undefined.`
     );
     return {};
@@ -2178,40 +2228,40 @@ async function getPackageJson(config) {
 // src/core/utils/manifest.ts
 import { produce } from "immer";
 import defu3 from "defu";
-async function writeManifest(manifest, output, config) {
-  const str = config.mode === "production" ? JSON.stringify(manifest) : JSON.stringify(manifest, null, 2);
-  await fs11.ensureDir(config.outDir);
-  await writeFileIfDifferent(resolve12(config.outDir, "manifest.json"), str);
+async function writeManifest(manifest, output) {
+  const str = wxt.config.mode === "production" ? JSON.stringify(manifest) : JSON.stringify(manifest, null, 2);
+  await fs11.ensureDir(wxt.config.outDir);
+  await writeFileIfDifferent(resolve12(wxt.config.outDir, "manifest.json"), str);
   output.publicAssets.unshift({
     type: "asset",
     fileName: "manifest.json"
   });
 }
-async function generateManifest(entrypoints, buildOutput, config) {
+async function generateManifest(entrypoints, buildOutput) {
   const warnings = [];
-  const pkg = await getPackageJson(config);
-  let versionName = config.manifest.version_name ?? config.manifest.version ?? pkg?.version;
+  const pkg = await getPackageJson();
+  let versionName = wxt.config.manifest.version_name ?? wxt.config.manifest.version ?? pkg?.version;
   if (versionName == null) {
     versionName = "0.0.0";
-    config.logger.warn(
+    wxt.logger.warn(
       'Extension version not found, defaulting to "0.0.0". Add a version to your `package.json` or `wxt.config.ts` file. For more details, see: https://wxt.dev/guide/manifest.html#version-and-version-name'
     );
   }
-  const version2 = config.manifest.version ?? simplifyVersion(versionName);
+  const version2 = wxt.config.manifest.version ?? simplifyVersion(versionName);
   const baseManifest = {
-    manifest_version: config.manifestVersion,
+    manifest_version: wxt.config.manifestVersion,
     name: pkg?.name,
     description: pkg?.description,
     version: version2,
     short_name: pkg?.shortName,
     icons: discoverIcons(buildOutput)
   };
-  const userManifest = config.manifest;
+  const userManifest = wxt.config.manifest;
   const manifest = defu3(
     userManifest,
     baseManifest
   );
-  if (config.command === "serve" && config.dev.reloadCommand) {
+  if (wxt.config.command === "serve" && wxt.config.dev.reloadCommand) {
     if (manifest.commands && Object.keys(manifest.commands).length >= 4) {
       warnings.push([
         "Extension already has 4 registered commands, WXT's reload command is disabled"
@@ -2221,20 +2271,21 @@ async function generateManifest(entrypoints, buildOutput, config) {
       manifest.commands["wxt:reload-extension"] = {
         description: "Reload the extension during development",
         suggested_key: {
-          default: config.dev.reloadCommand
+          default: wxt.config.dev.reloadCommand
         }
       };
     }
   }
   manifest.version = version2;
   manifest.version_name = // Firefox doesn't support version_name
-  config.browser === "firefox" || versionName === version2 ? void 0 : versionName;
-  addEntrypoints(manifest, entrypoints, buildOutput, config);
-  if (config.command === "serve")
-    addDevModeCsp(manifest, config);
-  if (config.command === "serve")
-    addDevModePermissions(manifest, config);
-  const finalManifest = produce(manifest, config.transformManifest);
+  wxt.config.browser === "firefox" || versionName === version2 ? void 0 : versionName;
+  addEntrypoints(manifest, entrypoints, buildOutput);
+  if (wxt.config.command === "serve")
+    addDevModeCsp(manifest);
+  if (wxt.config.command === "serve")
+    addDevModePermissions(manifest);
+  const finalManifest = produce(manifest, wxt.config.transformManifest);
+  await wxt.hooks.callHook("build:manifestGenerated", wxt, finalManifest);
   if (finalManifest.name == null)
     throw Error(
       "Manifest 'name' is missing. Either:\n1. Set the name in your <rootDir>/package.json\n2. Set a name via the manifest option in your wxt.config.ts"
@@ -2259,7 +2310,7 @@ function simplifyVersion(versionName) {
     );
   return version2;
 }
-function addEntrypoints(manifest, entrypoints, buildOutput, config) {
+function addEntrypoints(manifest, entrypoints, buildOutput) {
   const entriesByType = entrypoints.reduce((map, entrypoint) => {
     map[entrypoint.type] ??= [];
     map[entrypoint.type]?.push(entrypoint);
@@ -2276,13 +2327,17 @@ function addEntrypoints(manifest, entrypoints, buildOutput, config) {
   const sandboxes = entriesByType["sandbox"];
   const sidepanels = entriesByType["sidepanel"];
   if (background) {
-    const script = getEntrypointBundlePath(background, config.outDir, ".js");
-    if (config.browser === "firefox" && config.manifestVersion === 3) {
+    const script = getEntrypointBundlePath(
+      background,
+      wxt.config.outDir,
+      ".js"
+    );
+    if (wxt.config.browser === "firefox" && wxt.config.manifestVersion === 3) {
       manifest.background = {
         type: background.options.type,
         scripts: [script]
       };
-    } else if (config.manifestVersion === 3) {
+    } else if (wxt.config.manifestVersion === 3) {
       manifest.background = {
         type: background.options.type,
         service_worker: script
@@ -2295,29 +2350,29 @@ function addEntrypoints(manifest, entrypoints, buildOutput, config) {
     }
   }
   if (bookmarks) {
-    if (config.browser === "firefox") {
-      config.logger.warn(
+    if (wxt.config.browser === "firefox") {
+      wxt.logger.warn(
         "Bookmarks are not supported by Firefox. chrome_url_overrides.bookmarks was not added to the manifest"
       );
     } else {
       manifest.chrome_url_overrides ??= {};
       manifest.chrome_url_overrides.bookmarks = getEntrypointBundlePath(
         bookmarks,
-        config.outDir,
+        wxt.config.outDir,
         ".html"
       );
     }
   }
   if (history) {
-    if (config.browser === "firefox") {
-      config.logger.warn(
+    if (wxt.config.browser === "firefox") {
+      wxt.logger.warn(
         "Bookmarks are not supported by Firefox. chrome_url_overrides.history was not added to the manifest"
       );
     } else {
       manifest.chrome_url_overrides ??= {};
       manifest.chrome_url_overrides.history = getEntrypointBundlePath(
         history,
-        config.outDir,
+        wxt.config.outDir,
         ".html"
       );
     }
@@ -2326,14 +2381,14 @@ function addEntrypoints(manifest, entrypoints, buildOutput, config) {
     manifest.chrome_url_overrides ??= {};
     manifest.chrome_url_overrides.newtab = getEntrypointBundlePath(
       newtab,
-      config.outDir,
+      wxt.config.outDir,
       ".html"
     );
   }
   if (popup) {
     const default_popup = getEntrypointBundlePath(
       popup,
-      config.outDir,
+      wxt.config.outDir,
       ".html"
     );
     const options2 = {};
@@ -2361,28 +2416,28 @@ function addEntrypoints(manifest, entrypoints, buildOutput, config) {
   if (devtools) {
     manifest.devtools_page = getEntrypointBundlePath(
       devtools,
-      config.outDir,
+      wxt.config.outDir,
       ".html"
     );
   }
   if (options) {
-    const page = getEntrypointBundlePath(options, config.outDir, ".html");
+    const page = getEntrypointBundlePath(options, wxt.config.outDir, ".html");
     manifest.options_ui = {
       open_in_tab: options.options.openInTab,
-      browser_style: config.browser === "firefox" ? options.options.browserStyle : void 0,
-      chrome_style: config.browser !== "firefox" ? options.options.chromeStyle : void 0,
+      browser_style: wxt.config.browser === "firefox" ? options.options.browserStyle : void 0,
+      chrome_style: wxt.config.browser !== "firefox" ? options.options.chromeStyle : void 0,
       page
     };
   }
   if (sandboxes?.length) {
-    if (config.browser === "firefox") {
-      config.logger.warn(
+    if (wxt.config.browser === "firefox") {
+      wxt.logger.warn(
         "Sandboxed pages not supported by Firefox. sandbox.pages was not added to the manifest"
       );
     } else {
       manifest.sandbox = {
         pages: sandboxes.map(
-          (entry) => getEntrypointBundlePath(entry, config.outDir, ".html")
+          (entry) => getEntrypointBundlePath(entry, wxt.config.outDir, ".html")
         )
       };
     }
@@ -2391,33 +2446,33 @@ function addEntrypoints(manifest, entrypoints, buildOutput, config) {
     const defaultSidepanel = sidepanels.find((entry) => entry.name === "sidepanel") ?? sidepanels[0];
     const page = getEntrypointBundlePath(
       defaultSidepanel,
-      config.outDir,
+      wxt.config.outDir,
       ".html"
     );
-    if (config.browser === "firefox") {
+    if (wxt.config.browser === "firefox") {
       manifest.sidebar_action = {
         // TODO: Add options to side panel
         // ...defaultSidepanel.options,
         default_panel: page
       };
-    } else if (config.manifestVersion === 3) {
+    } else if (wxt.config.manifestVersion === 3) {
       manifest.side_panel = {
         default_path: page
       };
     } else {
-      config.logger.warn(
+      wxt.logger.warn(
         "Side panel not supported by Chromium using MV2. side_panel.default_path was not added to the manifest"
       );
     }
   }
   if (contentScripts?.length) {
     const cssMap = getContentScriptsCssMap(buildOutput, contentScripts);
-    if (config.command === "serve" && config.manifestVersion === 3) {
+    if (wxt.config.command === "serve" && wxt.config.manifestVersion === 3) {
       const hostPermissions = new Set(manifest.host_permissions ?? []);
       contentScripts.forEach((script) => {
         const matches = resolvePerBrowserOption(
           script.options.matches,
-          config.browser
+          wxt.config.browser
         );
         matches.forEach((matchPattern) => {
           hostPermissions.add(matchPattern);
@@ -2428,7 +2483,7 @@ function addEntrypoints(manifest, entrypoints, buildOutput, config) {
       );
     } else {
       const hashToEntrypointsMap = contentScripts.reduce((map, script) => {
-        const hash = hashContentScriptOptions(script.options, config);
+        const hash = hashContentScriptOptions(script.options);
         if (map.has(hash))
           map.get(hash)?.push(script);
         else
@@ -2437,10 +2492,10 @@ function addEntrypoints(manifest, entrypoints, buildOutput, config) {
       }, /* @__PURE__ */ new Map());
       const newContentScripts = Array.from(hashToEntrypointsMap.entries()).map(
         ([, scripts]) => ({
-          ...mapWxtOptionsToContentScript(scripts[0].options, config),
+          ...mapWxtOptionsToContentScript(scripts[0].options),
           css: getContentScriptCssFiles(scripts, cssMap),
           js: scripts.map(
-            (entry) => getEntrypointBundlePath(entry, config.outDir, ".js")
+            (entry) => getEntrypointBundlePath(entry, wxt.config.outDir, ".js")
           )
         })
       );
@@ -2450,7 +2505,6 @@ function addEntrypoints(manifest, entrypoints, buildOutput, config) {
       }
     }
     const contentScriptCssResources = getContentScriptCssWebAccessibleResources(
-      config,
       contentScripts,
       cssMap
     );
@@ -2493,9 +2547,9 @@ function discoverIcons(buildOutput) {
   });
   return icons.length > 0 ? Object.fromEntries(icons) : void 0;
 }
-function addDevModeCsp(manifest, config) {
-  const permission = `http://${config.server?.hostname ?? ""}/*`;
-  const allowedCsp = config.server?.origin ?? "http://localhost:*";
+function addDevModeCsp(manifest) {
+  const permission = `http://${wxt.config.server?.hostname ?? ""}/*`;
+  const allowedCsp = wxt.config.server?.origin ?? "http://localhost:*";
   if (manifest.manifest_version === 3) {
     addHostPermission(manifest, permission);
   } else {
@@ -2508,7 +2562,7 @@ function addDevModeCsp(manifest, config) {
     ) : manifest.content_security_policy ?? "script-src 'self'; object-src 'self';"
     // default CSP for MV2
   );
-  if (config.server)
+  if (wxt.config.server)
     csp.add("script-src", allowedCsp);
   if (manifest.manifest_version === 3) {
     manifest.content_security_policy ??= {};
@@ -2517,9 +2571,9 @@ function addDevModeCsp(manifest, config) {
     manifest.content_security_policy = csp.toString();
   }
 }
-function addDevModePermissions(manifest, config) {
+function addDevModePermissions(manifest) {
   addPermission(manifest, "tabs");
-  if (config.manifestVersion === 3)
+  if (wxt.config.manifestVersion === 3)
     addPermission(manifest, "scripting");
 }
 function getContentScriptCssFiles(contentScripts, contentScriptCssMap) {
@@ -2537,7 +2591,7 @@ function getContentScriptCssFiles(contentScripts, contentScriptCssMap) {
     return css;
   return void 0;
 }
-function getContentScriptCssWebAccessibleResources(config, contentScripts, contentScriptCssMap) {
+function getContentScriptCssWebAccessibleResources(contentScripts, contentScriptCssMap) {
   const resources = [];
   contentScripts.forEach((script) => {
     if (script.options.cssInjectionMode !== "ui")
@@ -2545,14 +2599,14 @@ function getContentScriptCssWebAccessibleResources(config, contentScripts, conte
     const cssFile = contentScriptCssMap[script.name];
     if (cssFile == null)
       return;
-    if (config.manifestVersion === 2) {
+    if (wxt.config.manifestVersion === 2) {
       resources.push(cssFile);
     } else {
       resources.push({
         resources: [cssFile],
         matches: resolvePerBrowserOption(
           script.options.matches,
-          config.browser
+          wxt.config.browser
         ).map((matchPattern) => stripPathFromMatchPattern(matchPattern))
       });
     }
@@ -2592,28 +2646,28 @@ function stripPathFromMatchPattern(pattern) {
 }
 
 // src/core/utils/building/rebuild.ts
-async function rebuild(config, allEntrypoints, entrypointGroups, existingOutput = {
+async function rebuild(allEntrypoints, entrypointGroups, existingOutput = {
   steps: [],
   publicAssets: []
 }) {
   const { default: ora } = await import("ora");
   const spinner = ora(`Preparing...`).start();
-  await generateTypesDir(allEntrypoints, config).catch((err) => {
-    config.logger.warn("Failed to update .wxt directory:", err);
-    if (config.command === "build")
+  await generateTypesDir(allEntrypoints).catch((err) => {
+    wxt.logger.warn("Failed to update .wxt directory:", err);
+    if (wxt.config.command === "build")
       throw err;
   });
-  const newOutput = await buildEntrypoints(entrypointGroups, config, spinner);
+  const newOutput = await buildEntrypoints(entrypointGroups, spinner);
   const mergedOutput = {
     steps: [...existingOutput.steps, ...newOutput.steps],
     publicAssets: [...existingOutput.publicAssets, ...newOutput.publicAssets]
   };
-  const { manifest: newManifest, warnings: manifestWarnings } = await generateManifest(allEntrypoints, mergedOutput, config);
+  const { manifest: newManifest, warnings: manifestWarnings } = await generateManifest(allEntrypoints, mergedOutput);
   const finalOutput = {
     manifest: newManifest,
     ...newOutput
   };
-  await writeManifest(newManifest, finalOutput, config);
+  await writeManifest(newManifest, finalOutput);
   spinner.clear().stop();
   return {
     output: {
@@ -2698,30 +2752,33 @@ import consola3 from "consola";
 import managePath from "manage-path";
 import { resolve as resolve13 } from "node:path";
 var managedPath = managePath(process.env);
-var exec = async (config, file, args, options) => {
+var exec = async (file, args, options) => {
   managedPath.restore();
-  managedPath.push(resolve13(config.root, "node_modules/wxt/node_modules/.bin"));
+  managedPath.push(
+    resolve13(wxt.config.root, "node_modules/wxt/node_modules/.bin")
+  );
   const { execa } = await import("./execa-Y2EWTC4S.js");
   return await execa(file, args, options);
 };
 
 // src/core/utils/building/internal-build.ts
-async function internalBuild(config) {
-  const verb = config.command === "serve" ? "Pre-rendering" : "Building";
-  const target = `${config.browser}-mv${config.manifestVersion}`;
-  config.logger.info(
-    `${verb} ${pc5.cyan(target)} for ${pc5.cyan(config.mode)} with ${pc5.green(
-      `${config.builder.name} ${config.builder.version}`
+async function internalBuild() {
+  await wxt.hooks.callHook("build:before", wxt);
+  const verb = wxt.config.command === "serve" ? "Pre-rendering" : "Building";
+  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}`
     )}`
   );
   const startTime = Date.now();
-  await fs12.rm(config.outDir, { recursive: true, force: true });
-  await fs12.ensureDir(config.outDir);
-  const entrypoints = await findEntrypoints(config);
-  config.logger.debug("Detected entrypoints:", entrypoints);
+  await fs12.rm(wxt.config.outDir, { recursive: true, force: true });
+  await fs12.ensureDir(wxt.config.outDir);
+  const entrypoints = await findEntrypoints();
+  wxt.logger.debug("Detected entrypoints:", entrypoints);
   const validationResults = validateEntrypoints(entrypoints);
   if (validationResults.errorCount + validationResults.warningCount > 0) {
-    printValidationResults(config, validationResults);
+    printValidationResults(validationResults);
   }
   if (validationResults.errorCount > 0) {
     throw new ValidationError(`Entrypoint validation failed`, {
@@ -2729,45 +2786,44 @@ async function internalBuild(config) {
     });
   }
   const groups = groupEntrypoints(entrypoints);
-  const { output, warnings } = await rebuild(
-    config,
-    entrypoints,
-    groups,
-    void 0
-  );
+  await wxt.hooks.callHook("entrypoints:grouped", wxt, groups);
+  const { output, warnings } = await rebuild(entrypoints, groups, void 0);
+  await wxt.hooks.callHook("build:done", wxt, output);
   await printBuildSummary(
-    config.logger.success,
+    wxt.logger.success,
     `Built extension in ${formatDuration(Date.now() - startTime)}`,
-    output,
-    config
+    output
   );
   for (const warning of warnings) {
-    config.logger.warn(...warning);
+    wxt.logger.warn(...warning);
   }
-  if (config.analysis.enabled) {
-    await combineAnalysisStats(config);
-    config.logger.info(
+  if (wxt.config.analysis.enabled) {
+    await combineAnalysisStats();
+    wxt.logger.info(
       `Analysis complete:
   ${pc5.gray("\u2514\u2500")} ${pc5.yellow("stats.html")}`
     );
   }
   return output;
 }
-async function combineAnalysisStats(config) {
+async function combineAnalysisStats() {
   const unixFiles = await glob3(`stats-*.json`, {
-    cwd: config.outDir,
+    cwd: wxt.config.outDir,
     absolute: true
   });
   const absolutePaths = unixFiles.map(unnormalizePath);
   await exec(
-    config,
     "rollup-plugin-visualizer",
-    [...absolutePaths, "--template", config.analysis.template],
-    { cwd: config.root, stdio: "inherit" }
+    [...absolutePaths, "--template", wxt.config.analysis.template],
+    { cwd: wxt.config.root, stdio: "inherit" }
   );
 }
-function printValidationResults(config, { errorCount, errors, warningCount }) {
-  (errorCount > 0 ? config.logger.error : config.logger.warn)(
+function printValidationResults({
+  errorCount,
+  errors,
+  warningCount
+}) {
+  (errorCount > 0 ? wxt.logger.error : wxt.logger.warn)(
     `Entrypoint validation failed: ${errorCount} error${errorCount === 1 ? "" : "s"}, ${warningCount} warning${warningCount === 1 ? "" : "s"}`
   );
   const cwd = process.cwd();
@@ -2791,8 +2847,8 @@ function printValidationResults(config, { errorCount, errors, warningCount }) {
 
 // src/core/build.ts
 async function build(config) {
-  const internalConfig = await getInternalConfig(config ?? {}, "build");
-  return await internalBuild(internalConfig);
+  await registerWxt("build", config);
+  return await internalBuild();
 }
 
 // src/core/clean.ts
@@ -2834,11 +2890,11 @@ async function clean(root = process.cwd()) {
 import { relative as relative7 } from "node:path";
 function createWslRunner() {
   return {
-    async openBrowser(config) {
-      config.logger.warn(
+    async openBrowser() {
+      wxt.logger.warn(
         `Cannot open browser when using WSL. Load "${relative7(
           process.cwd(),
-          config.outDir
+          wxt.config.outDir
         )}" as an unpacked extension manually`
       );
     },
@@ -2852,9 +2908,9 @@ import defu4 from "defu";
 function createWebExtRunner() {
   let runner;
   return {
-    async openBrowser(config) {
+    async openBrowser() {
       const startTime = Date.now();
-      if (config.browser === "firefox" && config.manifestVersion === 3) {
+      if (wxt.config.browser === "firefox" && wxt.config.manifestVersion === 3) {
         throw Error(
           "Dev mode does not support Firefox MV3. For alternatives, see https://github.com/wxt-dev/wxt/issues/230#issuecomment-1806881653"
         );
@@ -2862,22 +2918,22 @@ function createWebExtRunner() {
       const webExtLogger = await import("web-ext-run/util/logger");
       webExtLogger.consoleStream.write = ({ level, msg, name }) => {
         if (level >= ERROR_LOG_LEVEL)
-          config.logger.error(name, msg);
+          wxt.logger.error(name, msg);
         if (level >= WARN_LOG_LEVEL)
-          config.logger.warn(msg);
+          wxt.logger.warn(msg);
       };
-      const wxtUserConfig = config.runnerConfig.config;
+      const wxtUserConfig = wxt.config.runnerConfig.config;
       const userConfig = {
         console: wxtUserConfig?.openConsole,
         devtools: wxtUserConfig?.openDevtools,
         startUrl: wxtUserConfig?.startUrls,
-        ...config.browser === "firefox" ? {
+        ...wxt.config.browser === "firefox" ? {
           firefox: wxtUserConfig?.binaries?.firefox,
           firefoxProfile: wxtUserConfig?.firefoxProfile,
           prefs: wxtUserConfig?.firefoxPrefs,
           args: wxtUserConfig?.firefoxArgs
         } : {
-          chromiumBinary: wxtUserConfig?.binaries?.[config.browser],
+          chromiumBinary: wxtUserConfig?.binaries?.[wxt.config.browser],
           chromiumProfile: wxtUserConfig?.chromiumProfile,
           chromiumPref: defu4(
             wxtUserConfig?.chromiumPref,
@@ -2888,8 +2944,8 @@ function createWebExtRunner() {
       };
       const finalConfig = {
         ...userConfig,
-        target: config.browser === "firefox" ? "firefox-desktop" : "chromium",
-        sourceDir: config.outDir,
+        target: wxt.config.browser === "firefox" ? "firefox-desktop" : "chromium",
+        sourceDir: wxt.config.outDir,
         // WXT handles reloads, so disable auto-reload behaviors in web-ext
         noReload: true,
         noInput: true
@@ -2898,12 +2954,12 @@ function createWebExtRunner() {
         // Don't call `process.exit(0)` after starting web-ext
         shouldExitProgram: false
       };
-      config.logger.debug("web-ext config:", finalConfig);
-      config.logger.debug("web-ext options:", options);
+      wxt.logger.debug("web-ext config:", finalConfig);
+      wxt.logger.debug("web-ext options:", options);
       const webExt = await import("web-ext-run");
       runner = await webExt.default.cmd.run(finalConfig, options);
       const duration = Date.now() - startTime;
-      config.logger.success(`Opened browser in ${formatDuration(duration)}`);
+      wxt.logger.success(`Opened browser in ${formatDuration(duration)}`);
     },
     async closeBrowser() {
       return await runner?.exit();
@@ -2927,11 +2983,11 @@ var DEFAULT_CHROMIUM_PREFS = {
 import { relative as relative8 } from "node:path";
 function createSafariRunner() {
   return {
-    async openBrowser(config) {
-      config.logger.warn(
+    async openBrowser() {
+      wxt.logger.warn(
         `Cannot Safari using web-ext. Load "${relative8(
           process.cwd(),
-          config.outDir
+          wxt.config.outDir
         )}" as an unpacked extension manually`
       );
     },
@@ -2944,11 +3000,11 @@ function createSafariRunner() {
 import { relative as relative9 } from "node:path";
 function createManualRunner() {
   return {
-    async openBrowser(config) {
-      config.logger.info(
+    async openBrowser() {
+      wxt.logger.info(
         `Load "${relative9(
           process.cwd(),
-          config.outDir
+          wxt.config.outDir
         )}" as an unpacked extension manually`
       );
     },
@@ -2964,12 +3020,12 @@ async function isWsl() {
 }
 
 // src/core/runners/index.ts
-async function createExtensionRunner(config) {
-  if (config.browser === "safari")
+async function createExtensionRunner() {
+  if (wxt.config.browser === "safari")
     return createSafariRunner();
   if (await isWsl())
     return createWslRunner();
-  if (config.runnerConfig.config?.disabled)
+  if (wxt.config.runnerConfig.config?.disabled)
     return createManualRunner();
   return createWebExtRunner();
 }
@@ -2989,13 +3045,13 @@ async function createServer(inlineConfig) {
     origin
   };
   const buildAndOpenBrowser = async () => {
-    server.currentOutput = await internalBuild(config);
-    await runner.openBrowser(config);
+    server.currentOutput = await internalBuild();
+    await runner.openBrowser();
   };
   const closeAndRecreateRunner = async () => {
     await runner.closeBrowser();
-    config = await getLatestConfig();
-    runner = await createExtensionRunner(config);
+    await wxt.reloadConfig();
+    runner = await createExtensionRunner();
   };
   const server = {
     ...serverInfo,
@@ -3008,7 +3064,7 @@ async function createServer(inlineConfig) {
     currentOutput: void 0,
     async start() {
       await builderServer.listen();
-      config.logger.success(`Started dev server @ ${serverInfo.origin}`);
+      wxt.logger.success(`Started dev server @ ${serverInfo.origin}`);
       await buildAndOpenBrowser();
     },
     async stop() {
@@ -3033,27 +3089,20 @@ async function createServer(inlineConfig) {
     },
     async restartBrowser() {
       await closeAndRecreateRunner();
-      await runner.openBrowser(config);
+      await runner.openBrowser();
     }
   };
-  const getLatestConfig = () => getInternalConfig(inlineConfig ?? {}, "serve", server);
-  let config = await getLatestConfig();
+  await registerWxt("serve", inlineConfig, server);
   let [runner, builderServer] = await Promise.all([
-    createExtensionRunner(config),
-    config.builder.createServer(server)
+    createExtensionRunner(),
+    wxt.config.builder.createServer(server)
   ]);
   server.ws.on("wxt:background-initialized", () => {
     if (server.currentOutput == null)
       return;
-    reloadContentScripts(server.currentOutput.steps, config, server);
-  });
-  const reloadOnChange = createFileReloader({
-    server,
-    getLatestConfig,
-    updateConfig(newConfig) {
-      config = newConfig;
-    }
+    reloadContentScripts(server.currentOutput.steps, server);
   });
+  const reloadOnChange = createFileReloader(server);
   server.watcher.on("all", reloadOnChange);
   return server;
 }
@@ -3061,14 +3110,12 @@ async function getPort() {
   const { default: getPort2, portNumbers } = await import("get-port");
   return await getPort2({ port: portNumbers(3e3, 3010) });
 }
-function createFileReloader(options) {
-  const { server, getLatestConfig, updateConfig } = options;
+function createFileReloader(server) {
   const fileChangedMutex = new Mutex();
   const changeQueue = [];
   return async (event, path7) => {
-    const config = await getLatestConfig();
-    updateConfig(config);
-    if (path7.startsWith(config.outBaseDir))
+    await wxt.reloadConfig();
+    if (path7.startsWith(wxt.config.outBaseDir))
       return;
     changeQueue.push([event, path7]);
     await fileChangedMutex.runExclusive(async () => {
@@ -3077,29 +3124,24 @@ function createFileReloader(options) {
       const fileChanges = changeQueue.splice(0, changeQueue.length).map(([_, file]) => file);
       if (fileChanges.length === 0)
         return;
-      const changes = detectDevChanges(
-        config,
-        fileChanges,
-        server.currentOutput
-      );
+      const changes = detectDevChanges(fileChanges, server.currentOutput);
       if (changes.type === "no-change")
         return;
       if (changes.type === "full-restart") {
-        config.logger.info("Config changed, restarting server...");
+        wxt.logger.info("Config changed, restarting server...");
         server.restart();
         return;
       }
       if (changes.type === "browser-restart") {
-        config.logger.info("Runner config changed, restarting browser...");
+        wxt.logger.info("Runner config changed, restarting browser...");
         server.restartBrowser();
         return;
       }
-      config.logger.info(
-        `Changed: ${Array.from(new Set(fileChanges)).map((file) => pc7.dim(relative10(config.root, file))).join(", ")}`
+      wxt.logger.info(
+        `Changed: ${Array.from(new Set(fileChanges)).map((file) => pc7.dim(relative10(wxt.config.root, file))).join(", ")}`
       );
-      const allEntrypoints = await findEntrypoints(config);
+      const allEntrypoints = await findEntrypoints();
       const { output: newOutput } = await rebuild(
-        config,
         allEntrypoints,
         // TODO: this excludes new entrypoints, so they're not built until the dev command is restarted
         changes.rebuildGroups,
@@ -3114,13 +3156,12 @@ function createFileReloader(options) {
         case "html-reload":
           const { reloadedNames } = reloadHtmlPages(
             changes.rebuildGroups,
-            server,
-            config
+            server
           );
           consola5.success(`Reloaded: ${getFilenameList(reloadedNames)}`);
           break;
         case "content-script-reload":
-          reloadContentScripts(changes.changedSteps, config, server);
+          reloadContentScripts(changes.changedSteps, server);
           const rebuiltNames = changes.rebuildGroups.flat().map((entry) => entry.name);
           consola5.success(`Reloaded: ${getFilenameList(rebuiltNames)}`);
           break;
@@ -3128,30 +3169,33 @@ function createFileReloader(options) {
     });
   };
 }
-function reloadContentScripts(steps, config, server) {
-  if (config.manifestVersion === 3) {
+function reloadContentScripts(steps, server) {
+  if (wxt.config.manifestVersion === 3) {
     steps.forEach((step) => {
       if (server.currentOutput == null)
         return;
       const entry = step.entrypoints;
       if (Array.isArray(entry) || entry.type !== "content-script")
         return;
-      const js = [getEntrypointBundlePath(entry, config.outDir, ".js")];
+      const js = [getEntrypointBundlePath(entry, wxt.config.outDir, ".js")];
       const cssMap = getContentScriptsCssMap(server.currentOutput, [entry]);
       const css = getContentScriptCssFiles([entry], cssMap);
       server.reloadContentScript({
         allFrames: resolvePerBrowserOption(
           entry.options.allFrames,
-          config.browser
+          wxt.config.browser
         ),
         excludeMatches: resolvePerBrowserOption(
           entry.options.excludeMatches,
-          config.browser
+          wxt.config.browser
         ),
-        matches: resolvePerBrowserOption(entry.options.matches, config.browser),
-        runAt: resolvePerBrowserOption(entry.options.runAt, config.browser),
+        matches: resolvePerBrowserOption(
+          entry.options.matches,
+          wxt.config.browser
+        ),
+        runAt: resolvePerBrowserOption(entry.options.runAt, wxt.config.browser),
         // @ts-expect-error: Chrome accepts this, not typed in webextension-polyfill (https://developer.chrome.com/docs/extensions/reference/scripting/#type-RegisteredContentScript)
-        world: resolvePerBrowserOption(entry.options.world, config.browser),
+        world: resolvePerBrowserOption(entry.options.world, wxt.config.browser),
         js,
         css
       });
@@ -3160,10 +3204,10 @@ function reloadContentScripts(steps, config, server) {
     server.reloadExtension();
   }
 }
-function reloadHtmlPages(groups, server, config) {
+function reloadHtmlPages(groups, server) {
   const htmlEntries = groups.flat().filter((entry) => entry.inputPath.endsWith(".html"));
   htmlEntries.forEach((entry) => {
-    const path7 = getEntrypointBundlePath(entry, config.outDir, ".html");
+    const path7 = getEntrypointBundlePath(entry, wxt.config.outDir, ".html");
     server.reloadPage(path7);
   });
   return {
@@ -3244,19 +3288,11 @@ async function initialize(options) {
 }
 async function listTemplates() {
   try {
-    const res = await fetch(
-      "https://api.github.com/repos/wxt-dev/wxt/contents/templates",
-      {
-        headers: {
-          Accept: "application/vnd.github+json",
-          "X-GitHub-Api-Version": "2022-11-28"
-        }
-      }
-    );
+    const res = await fetch("https://ungh.cc/repos/wxt-dev/wxt/files/main");
     if (res.status >= 300)
       throw Error(`Request failed with status ${res.status} ${res.statusText}`);
     const data = await res.json();
-    return data.filter((item) => item.type === "dir").map((item) => ({ name: item.name, path: item.path })).sort((l, r) => {
+    return data.files.map((item) => item.path.match(/templates\/(.+)\/package\.json/)?.[1]).filter((name) => name != null).map((name) => ({ name, path: `templates/${name}` })).sort((l, r) => {
       const lWeight = TEMPLATE_SORT_WEIGHT[l.name] ?? Number.MAX_SAFE_INTEGER;
       const rWeight = TEMPLATE_SORT_WEIGHT[r.name] ?? Number.MAX_SAFE_INTEGER;
       const diff = lWeight - rWeight;
@@ -3307,10 +3343,10 @@ var TEMPLATE_SORT_WEIGHT = {
 
 // src/core/prepare.ts
 async function prepare(config) {
-  const internalConfig = await getInternalConfig(config, "build");
-  internalConfig.logger.info("Generating types...");
-  const entrypoints = await findEntrypoints(internalConfig);
-  await generateTypesDir(entrypoints, internalConfig);
+  await registerWxt("build", config);
+  wxt.logger.info("Generating types...");
+  const entrypoints = await findEntrypoints();
+  await generateTypesDir(entrypoints);
 }
 
 // src/core/zip.ts
@@ -3319,40 +3355,35 @@ import { dirname as dirname5, relative as relative11, resolve as resolve14 } fro
 import fs15 from "fs-extra";
 import { minimatch as minimatch2 } from "minimatch";
 async function zip(config) {
-  const internalConfig = await getInternalConfig(config ?? {}, "build");
-  const output = await internalBuild(internalConfig);
+  await registerWxt("build", config);
+  const output = await internalBuild();
   const start = Date.now();
-  internalConfig.logger.info("Zipping extension...");
+  wxt.logger.info("Zipping extension...");
   const zipFiles = [];
-  const projectName = internalConfig.zip.name ?? kebabCaseAlphanumeric(
-    (await getPackageJson(internalConfig))?.name || dirname5(process.cwd())
+  const projectName = wxt.config.zip.name ?? kebabCaseAlphanumeric(
+    (await getPackageJson())?.name || dirname5(process.cwd())
   );
-  const applyTemplate = (template) => template.replaceAll("{{name}}", projectName).replaceAll("{{browser}}", internalConfig.browser).replaceAll(
+  const applyTemplate = (template) => template.replaceAll("{{name}}", projectName).replaceAll("{{browser}}", wxt.config.browser).replaceAll(
     "{{version}}",
     output.manifest.version_name ?? output.manifest.version
-  ).replaceAll("{{manifestVersion}}", `mv${internalConfig.manifestVersion}`);
-  await fs15.ensureDir(internalConfig.outBaseDir);
-  const outZipFilename = applyTemplate(internalConfig.zip.artifactTemplate);
-  const outZipPath = resolve14(internalConfig.outBaseDir, outZipFilename);
-  await zipdir(internalConfig.outDir, {
+  ).replaceAll("{{manifestVersion}}", `mv${wxt.config.manifestVersion}`);
+  await fs15.ensureDir(wxt.config.outBaseDir);
+  const outZipFilename = applyTemplate(wxt.config.zip.artifactTemplate);
+  const outZipPath = resolve14(wxt.config.outBaseDir, outZipFilename);
+  await zipdir(wxt.config.outDir, {
     saveTo: outZipPath
   });
   zipFiles.push(outZipPath);
-  if (internalConfig.browser === "firefox") {
-    const sourcesZipFilename = applyTemplate(
-      internalConfig.zip.sourcesTemplate
-    );
-    const sourcesZipPath = resolve14(
-      internalConfig.outBaseDir,
-      sourcesZipFilename
-    );
-    await zipdir(internalConfig.zip.sourcesRoot, {
+  if (wxt.config.browser === "firefox") {
+    const sourcesZipFilename = applyTemplate(wxt.config.zip.sourcesTemplate);
+    const sourcesZipPath = resolve14(wxt.config.outBaseDir, sourcesZipFilename);
+    await zipdir(wxt.config.zip.sourcesRoot, {
       saveTo: sourcesZipPath,
       filter(path7) {
-        const relativePath = relative11(internalConfig.zip.sourcesRoot, path7);
-        return internalConfig.zip.includeSources.some(
+        const relativePath = relative11(wxt.config.zip.sourcesRoot, path7);
+        return wxt.config.zip.includeSources.some(
           (pattern) => minimatch2(relativePath, pattern)
-        ) || !internalConfig.zip.excludeSources.some(
+        ) || !wxt.config.zip.excludeSources.some(
           (pattern) => minimatch2(relativePath, pattern)
         );
       }
@@ -3360,9 +3391,9 @@ async function zip(config) {
     zipFiles.push(sourcesZipPath);
   }
   await printFileList(
-    internalConfig.logger.success,
+    wxt.logger.success,
     `Zipped extension in ${formatDuration(Date.now() - start)}`,
-    internalConfig.outBaseDir,
+    wxt.config.outBaseDir,
     zipFiles
   );
   return zipFiles;
@@ -3405,11 +3436,11 @@ var aliasCommandNames = /* @__PURE__ */ new Set();
 function createAliasedCommand(base, name, alias, docsUrl) {
   const aliasedCommand = base.command(name, `Alias for ${alias} (${docsUrl})`).allowUnknownOptions().action(async () => {
     try {
-      const config = await getInternalConfig({}, "build");
+      await registerWxt("build");
       const args = process.argv.slice(
         process.argv.indexOf(aliasedCommand.name) + 1
       );
-      await exec(config, alias, args, {
+      await exec(alias, args, {
         stdio: "inherit"
       });
     } catch {