wxt 0.16.1 → 0.16.3

package/dist/index.cjs

@@ -2443,6 +2443,26 @@ function unnormalizePath(path10) {
 var CSS_EXTENSIONS = ["css", "scss", "sass", "less", "styl", "stylus"];
 var CSS_EXTENSIONS_PATTERN = `+(${CSS_EXTENSIONS.join("|")})`;
 
+// src/core/wxt.ts
+var import_hookable = require("hookable");
+var wxt;
+async function registerWxt(command, inlineConfig = {}, server) {
+  const config = await resolveConfig(inlineConfig, command, server);
+  const hooks = (0, import_hookable.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 import_fs_extra.default.readFile(file, "utf-8").catch(() => void 0);
@@ -2450,10 +2470,10 @@ async function writeFileIfDifferent(file, newContents) {
     await import_fs_extra.default.writeFile(file, newContents);
   }
 }
-async function getPublicFiles(config) {
-  if (!await import_fs_extra.default.exists(config.publicDir))
+async function getPublicFiles() {
+  if (!await import_fs_extra.default.exists(wxt.config.publicDir))
     return [];
-  const files = await (0, import_fast_glob.default)("**/*", { cwd: config.publicDir });
+  const files = await (0, import_fast_glob.default)("**/*", { cwd: wxt.config.publicDir });
   return files.map(unnormalizePath);
 }
 
@@ -2461,7 +2481,7 @@ async function getPublicFiles(config) {
 var import_fs_extra2 = __toESM(require("fs-extra"), 1);
 var import_path = require("path");
 var import_picocolors = __toESM(require("picocolors"), 1);
-async function buildEntrypoints(groups, config, spinner) {
+async function buildEntrypoints(groups, spinner) {
   const steps = [];
   for (let i = 0; i < groups.length; i++) {
     const group = groups[i];
@@ -2469,22 +2489,22 @@ async function buildEntrypoints(groups, config, spinner) {
     const groupNameColored = groupNames.join(import_picocolors.default.dim(", "));
     spinner.text = import_picocolors.default.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 = (0, import_path.resolve)(config.publicDir, file);
-    const outPath = (0, import_path.resolve)(config.outDir, file);
+    const srcPath = (0, import_path.resolve)(wxt.config.publicDir, file);
+    const outPath = (0, import_path.resolve)(wxt.config.outDir, file);
     await import_fs_extra2.default.ensureDir((0, import_path.dirname)(outPath));
     await import_fs_extra2.default.copyFile(srcPath, outPath);
     publicAssets.push({
@@ -2510,16 +2530,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" };
@@ -2637,15 +2657,15 @@ var VIRTUAL_NOOP_BACKGROUND_MODULE_ID = "virtual:user-background";
 
 // src/core/utils/building/find-entrypoints.ts
 var import_picocolors2 = __toESM(require("picocolors"), 1);
-async function findEntrypoints(config) {
+async function findEntrypoints() {
   const relativePaths = await (0, import_fast_glob2.default)(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 = (0, import_path2.resolve)(config.entrypointsDir, relativePath);
-    const name = getEntrypointName(config.entrypointsDir, inputPath);
+    const inputPath = (0, import_path2.resolve)(wxt.config.entrypointsDir, relativePath);
+    const name = getEntrypointName(wxt.config.entrypointsDir, inputPath);
     const matchingGlob = pathGlobs.find(
       (glob5) => (0, import_minimatch.minimatch)(relativePath, glob5)
     );
@@ -2655,36 +2675,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: (0, import_path2.resolve)(config.outDir, CONTENT_SCRIPT_OUT_DIR),
+            outputDir: (0, import_path2.resolve)(wxt.config.outDir, CONTENT_SCRIPT_OUT_DIR),
             options: {
               include: void 0,
               exclude: void 0
@@ -2694,7 +2714,7 @@ async function findEntrypoints(config) {
           return {
             ...info,
             type,
-            outputDir: config.outDir,
+            outputDir: wxt.config.outDir,
             options: {
               include: void 0,
               exclude: void 0
@@ -2703,9 +2723,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",
@@ -2713,10 +2733,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) => `${import_picocolors2.default.dim("-")} ${import_picocolors2.default.cyan(item)}`).join("\n")}`
     );
@@ -2724,26 +2744,27 @@ ${skippedEntrypointNames.map((item) => `${import_picocolors2.default.dim("-")} $
   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] ??= [];
@@ -2757,7 +2778,7 @@ function preventDuplicateEntrypointNames(config, files) {
       if (absolutePaths.length > 1) {
         lines.push(`- ${name}`);
         absolutePaths.forEach((absolutePath) => {
-          lines.push(`  - ${(0, import_path2.relative)(config.root, absolutePath)}`);
+          lines.push(`  - ${(0, import_path2.relative)(wxt.config.root, absolutePath)}`);
         });
       }
       return lines;
@@ -2773,9 +2794,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) {
@@ -2790,7 +2811,11 @@ function getHtmlBaseOptions(document) {
   }
   return options;
 }
-async function getPopupEntrypoint(config, { inputPath, name, skipped }) {
+async function getPopupEntrypoint({
+  inputPath,
+  name,
+  skipped
+}) {
   const content = await import_fs_extra3.default.readFile(inputPath, "utf-8");
   const { document } = (0, import_linkedom.parseHTML)(content);
   const options = getHtmlBaseOptions(document);
@@ -2802,7 +2827,7 @@ async function getPopupEntrypoint(config, { inputPath, name, skipped }) {
     try {
       options.defaultIcon = import_json5.default.parse(defaultIconContent);
     } catch (err) {
-      config.logger.fatal(
+      wxt.logger.fatal(
         `Failed to parse default_icon meta tag content as JSON5. content=${defaultIconContent}`,
         err
       );
@@ -2821,11 +2846,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 import_fs_extra3.default.readFile(inputPath, "utf-8");
   const { document } = (0, import_linkedom.parseHTML)(content);
   const options = getHtmlBaseOptions(document);
@@ -2846,27 +2875,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 import_fs_extra3.default.readFile(inputPath, "utf-8");
   const { document } = (0, import_linkedom.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(...)"?`
@@ -2878,18 +2912,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(...)"?`
@@ -2898,24 +2933,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(...)"?`
@@ -2925,7 +2967,7 @@ async function getContentScriptEntrypoint(config, { inputPath, name, skipped })
     type: "content-script",
     name,
     inputPath,
-    outputDir: (0, import_path2.resolve)(config.outDir, CONTENT_SCRIPT_OUT_DIR),
+    outputDir: (0, import_path2.resolve)(wxt.config.outDir, CONTENT_SCRIPT_OUT_DIR),
     options,
     skipped
   };
@@ -3095,23 +3137,23 @@ function parseI18nMessages(messagesJson) {
 }
 
 // src/core/utils/building/generate-wxt-dir.ts
-async function generateTypesDir(entrypoints, config) {
-  await import_fs_extra4.default.ensureDir(config.typesDir);
+async function generateTypesDir(entrypoints) {
+  await import_fs_extra4.default.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 = (0, import_path3.resolve)(config.typesDir, "imports.d.ts");
+async function writeImportsDeclarationFile(unimportOptions) {
+  const filePath = (0, import_path3.resolve)(wxt.config.typesDir, "imports.d.ts");
   const unimport2 = (0, import_unimport.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(
@@ -3120,15 +3162,15 @@ async function writeImportsDeclarationFile(config, unimportOptions) {
   );
   return filePath;
 }
-async function writePathsDeclarationFile(entrypoints, config) {
-  const filePath = (0, import_path3.resolve)(config.typesDir, "paths.d.ts");
+async function writePathsDeclarationFile(entrypoints) {
+  const filePath = (0, import_path3.resolve)(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((path10) => `    | "/${path10}"`).sort().join("\n");
+  ).concat(await getPublicFiles()).map(normalizePath).map((path10) => `    | "/${path10}"`).sort().join("\n");
   const template = `// Generated by wxt
 import "wxt/browser";
 
@@ -3148,9 +3190,9 @@ declare module "wxt/browser" {
   );
   return filePath;
 }
-async function writeI18nDeclarationFile(config) {
-  const filePath = (0, import_path3.resolve)(config.typesDir, "i18n.d.ts");
-  const defaultLocale = config.manifest.default_locale;
+async function writeI18nDeclarationFile() {
+  const filePath = (0, import_path3.resolve)(wxt.config.typesDir, "i18n.d.ts");
+  const defaultLocale = wxt.config.manifest.default_locale;
   const template = `// Generated by wxt
 import "wxt/browser";
 
@@ -3173,7 +3215,7 @@ declare module "wxt/browser" {
   let messages;
   if (defaultLocale) {
     const defaultLocalePath = import_node_path3.default.resolve(
-      config.publicDir,
+      wxt.config.publicDir,
       "_locales",
       defaultLocale,
       "messages.json"
@@ -3201,9 +3243,9 @@ declare module "wxt/browser" {
   );
   return filePath;
 }
-async function writeGlobalsDeclarationFile(config) {
-  const filePath = (0, import_path3.resolve)(config.typesDir, "globals.d.ts");
-  const globals2 = [...getGlobals(config), ...getEntrypointGlobals("")];
+async function writeGlobalsDeclarationFile() {
+  const filePath = (0, import_path3.resolve)(wxt.config.typesDir, "globals.d.ts");
+  const globals2 = [...getGlobals(wxt.config), ...getEntrypointGlobals("")];
   await writeFileIfDifferent(
     filePath,
     [
@@ -3219,8 +3261,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 = (0, import_path3.resolve)(dir, "wxt.d.ts");
   await writeFileIfDifferent(
     filePath,
@@ -3234,10 +3276,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 = (path10) => normalizePath((0, import_path3.relative)(dir, path10));
-  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}"]`,
@@ -3262,15 +3304,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
 var import_c12 = require("c12");
 var import_node_path7 = __toESM(require("path"), 1);
 
@@ -3296,7 +3338,7 @@ function createFsCache(wxtDir) {
   };
 }
 
-// src/core/utils/building/get-internal-config.ts
+// src/core/utils/building/resolve-config.ts
 var import_consola = __toESM(require("consola"), 1);
 
 // src/core/builders/vite/plugins/devHtmlPrerender.ts
@@ -3791,6 +3833,21 @@ function entrypointGroupGlobals(entrypointGroup) {
   };
 }
 
+// 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/index.ts
 async function createViteBuilder(inlineConfig, userConfig, wxtConfig) {
   const vite = await import("vite");
@@ -3827,7 +3884,8 @@ async function createViteBuilder(inlineConfig, userConfig, wxtConfig) {
       tsconfigPaths(wxtConfig),
       noopBackground(),
       globals(wxtConfig),
-      excludeBrowserPolyfill(wxtConfig)
+      excludeBrowserPolyfill(wxtConfig),
+      defineImportMeta()
     );
     if (wxtConfig.analysis.enabled) {
       config.plugins.push(bundleAnalysis());
@@ -4005,9 +4063,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
 var import_defu2 = __toESM(require("defu"), 1);
-async function getInternalConfig(inlineConfig, command, server) {
+async function resolveConfig(inlineConfig, command, server) {
   let userConfig = {};
   let userConfigMetadata;
   if (inlineConfig.configFile !== false) {
@@ -4101,7 +4159,8 @@ async function getInternalConfig(inlineConfig, command, server) {
     server,
     dev: {
       reloadCommand
-    }
+    },
+    hooks: mergedConfig.hooks ?? {}
   };
   const builder = await createViteBuilder(
     inlineConfig,
@@ -4138,6 +4197,10 @@ function mergeInlineConfig(inlineConfig, userConfig) {
     inlineConfig.zip ?? {},
     userConfig.zip ?? {}
   );
+  const hooks = (0, import_defu2.default)(
+    inlineConfig.hooks ?? {},
+    userConfig.hooks ?? {}
+  );
   return {
     root: inlineConfig.root ?? userConfig.root,
     browser: inlineConfig.browser ?? userConfig.browser,
@@ -4172,7 +4235,8 @@ function mergeInlineConfig(inlineConfig, userConfig) {
     dev: {
       ...userConfig.dev,
       ...inlineConfig.dev
-    }
+    },
+    hooks
   };
 }
 function resolveInternalZipConfig(root, mergedConfig) {
@@ -4264,11 +4328,11 @@ ${noImports}`;
 var import_esbuild = require("esbuild");
 var import_node_url = require("url");
 var import_meta = {};
-async function importEntrypointFile(path10, config) {
-  config.logger.debug("Loading file metadata:", path10);
+async function importEntrypointFile(path10) {
+  wxt.logger.debug("Loading file metadata:", path10);
   const normalPath = normalizePath(path10);
   const unimport2 = (0, import_unimport5.createUnimport)({
-    ...getUnimportOptions(config),
+    ...getUnimportOptions(wxt.config),
     // Only allow specific imports, not all from the project
     dirs: []
   });
@@ -4276,18 +4340,18 @@ async function importEntrypointFile(path10, config) {
   const text = await import_fs_extra8.default.readFile(path10, "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 = (0, import_jiti.default)(
     typeof __filename !== "undefined" ? __filename : (0, import_node_url.fileURLToPath)(import_meta.url),
     {
       cache: false,
-      debug: config.debug,
+      debug: wxt.config.debug,
       esmResolve: true,
       alias: {
         "webextension-polyfill": (0, import_node_path8.resolve)(
-          config.root,
+          wxt.config.root,
           "node_modules/wxt/dist/virtual/mock-browser.js"
         )
       },
@@ -4319,7 +4383,7 @@ async function importEntrypointFile(path10, config) {
     const res = await jiti(path10);
     return res.default;
   } catch (err) {
-    const filePath = (0, import_node_path8.relative)(config.root, path10);
+    const filePath = (0, import_node_path8.relative)(wxt.config.root, path10);
     if (err instanceof ReferenceError) {
       const variableName = err.message.replace(" is not defined", "");
       throw Error(
@@ -4327,7 +4391,7 @@ async function importEntrypointFile(path10, config) {
         { cause: err }
       );
     } else {
-      config.logger.error(err);
+      wxt.logger.error(err);
       throw Error(`Failed to load entrypoint: ${filePath}`, { cause: err });
     }
   }
@@ -4421,7 +4485,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
@@ -4433,8 +4497,10 @@ async function printBuildSummary(log, header, output, config) {
       return diff;
     return l.fileName.localeCompare(r.fileName);
   });
-  const files = chunks.map((chunk) => (0, import_path7.resolve)(config.outDir, chunk.fileName));
-  await printFileList(log, header, config.outDir, files);
+  const files = chunks.map(
+    (chunk) => (0, import_path7.resolve)(wxt.config.outDir, chunk.fileName)
+  );
+  await printFileList(log, header, wxt.config.outDir, files);
 }
 var DEFAULT_SORT_WEIGHT = 100;
 var CHUNK_SORT_WEIGHTS = {
@@ -4454,7 +4520,7 @@ function getChunkSortWeight(filename) {
 var import_picocolors4 = __toESM(require("picocolors"), 1);
 
 // package.json
-var version = "0.16.1";
+var version = "0.16.3";
 
 // src/core/utils/log/printHeader.ts
 var import_consola2 = require("consola");
@@ -4510,8 +4576,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];
@@ -4537,31 +4603,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
   };
@@ -4570,12 +4636,12 @@ function mapWxtOptionsToContentScript(options, config) {
 // src/core/utils/package.ts
 var import_node_path10 = require("path");
 var import_fs_extra10 = __toESM(require("fs-extra"), 1);
-async function getPackageJson(config) {
-  const file = (0, import_node_path10.resolve)(config.root, "package.json");
+async function getPackageJson() {
+  const file = (0, import_node_path10.resolve)(wxt.config.root, "package.json");
   try {
     return await import_fs_extra10.default.readJson(file);
   } catch (err) {
-    config.logger.debug(
+    wxt.logger.debug(
       `Failed to read package.json at: ${file}. Returning undefined.`
     );
     return {};
@@ -4585,40 +4651,40 @@ async function getPackageJson(config) {
 // src/core/utils/manifest.ts
 var import_immer = require("immer");
 var import_defu3 = __toESM(require("defu"), 1);
-async function writeManifest(manifest, output, config) {
-  const str = config.mode === "production" ? JSON.stringify(manifest) : JSON.stringify(manifest, null, 2);
-  await import_fs_extra11.default.ensureDir(config.outDir);
-  await writeFileIfDifferent((0, import_path8.resolve)(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 import_fs_extra11.default.ensureDir(wxt.config.outDir);
+  await writeFileIfDifferent((0, import_path8.resolve)(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 = (0, import_defu3.default)(
     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"
@@ -4628,20 +4694,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 = (0, import_immer.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 = (0, import_immer.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"
@@ -4666,7 +4733,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);
@@ -4683,13 +4750,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
@@ -4702,29 +4773,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"
       );
     }
@@ -4733,14 +4804,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 = {};
@@ -4768,28 +4839,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")
         )
       };
     }
@@ -4798,33 +4869,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);
@@ -4835,7 +4906,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
@@ -4844,10 +4915,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")
           )
         })
       );
@@ -4857,7 +4928,6 @@ function addEntrypoints(manifest, entrypoints, buildOutput, config) {
       }
     }
     const contentScriptCssResources = getContentScriptCssWebAccessibleResources(
-      config,
       contentScripts,
       cssMap
     );
@@ -4900,9 +4970,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 {
@@ -4915,7 +4985,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 ??= {};
@@ -4924,9 +4994,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) {
@@ -4944,7 +5014,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")
@@ -4952,14 +5022,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))
       });
     }
@@ -4999,28 +5069,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: {
@@ -5105,30 +5175,33 @@ var import_consola3 = __toESM(require("consola"), 1);
 var import_manage_path = __toESM(require("manage-path"), 1);
 var import_node_path13 = require("path");
 var managedPath = (0, import_manage_path.default)(process.env);
-var exec = async (config, file, args, options) => {
+var exec = async (file, args, options) => {
   managedPath.restore();
-  managedPath.push((0, import_node_path13.resolve)(config.root, "node_modules/wxt/node_modules/.bin"));
+  managedPath.push(
+    (0, import_node_path13.resolve)(wxt.config.root, "node_modules/wxt/node_modules/.bin")
+  );
   const { execa: execa2 } = await Promise.resolve().then(() => (init_execa(), execa_exports));
   return await execa2(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} ${import_picocolors5.default.cyan(target)} for ${import_picocolors5.default.cyan(config.mode)} with ${import_picocolors5.default.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} ${import_picocolors5.default.cyan(target)} for ${import_picocolors5.default.cyan(wxt.config.mode)} with ${import_picocolors5.default.green(
+      `${wxt.config.builder.name} ${wxt.config.builder.version}`
     )}`
   );
   const startTime = Date.now();
-  await import_fs_extra12.default.rm(config.outDir, { recursive: true, force: true });
-  await import_fs_extra12.default.ensureDir(config.outDir);
-  const entrypoints = await findEntrypoints(config);
-  config.logger.debug("Detected entrypoints:", entrypoints);
+  await import_fs_extra12.default.rm(wxt.config.outDir, { recursive: true, force: true });
+  await import_fs_extra12.default.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`, {
@@ -5136,45 +5209,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:
   ${import_picocolors5.default.gray("\u2514\u2500")} ${import_picocolors5.default.yellow("stats.html")}`
     );
   }
   return output;
 }
-async function combineAnalysisStats(config) {
+async function combineAnalysisStats() {
   const unixFiles = await (0, import_fast_glob3.default)(`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();
@@ -5198,8 +5270,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
@@ -5251,11 +5323,11 @@ function defineRunnerConfig(config) {
 var import_node_path16 = require("path");
 function createWslRunner() {
   return {
-    async openBrowser(config) {
-      config.logger.warn(
+    async openBrowser() {
+      wxt.logger.warn(
         `Cannot open browser when using WSL. Load "${(0, import_node_path16.relative)(
           process.cwd(),
-          config.outDir
+          wxt.config.outDir
         )}" as an unpacked extension manually`
       );
     },
@@ -5269,9 +5341,9 @@ var import_defu4 = __toESM(require("defu"), 1);
 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"
         );
@@ -5279,22 +5351,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: (0, import_defu4.default)(
             wxtUserConfig?.chromiumPref,
@@ -5305,8 +5377,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
@@ -5315,12 +5387,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();
@@ -5344,11 +5416,11 @@ var DEFAULT_CHROMIUM_PREFS = {
 var import_node_path17 = require("path");
 function createSafariRunner() {
   return {
-    async openBrowser(config) {
-      config.logger.warn(
+    async openBrowser() {
+      wxt.logger.warn(
         `Cannot Safari using web-ext. Load "${(0, import_node_path17.relative)(
           process.cwd(),
-          config.outDir
+          wxt.config.outDir
         )}" as an unpacked extension manually`
       );
     },
@@ -5361,11 +5433,11 @@ function createSafariRunner() {
 var import_node_path18 = require("path");
 function createManualRunner() {
   return {
-    async openBrowser(config) {
-      config.logger.info(
+    async openBrowser() {
+      wxt.logger.info(
         `Load "${(0, import_node_path18.relative)(
           process.cwd(),
-          config.outDir
+          wxt.config.outDir
         )}" as an unpacked extension manually`
       );
     },
@@ -5381,12 +5453,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();
 }
@@ -5406,13 +5478,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,
@@ -5425,7 +5497,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() {
@@ -5450,27 +5522,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;
 }
@@ -5478,14 +5543,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 import_async_mutex.Mutex();
   const changeQueue = [];
   return async (event, path10) => {
-    const config = await getLatestConfig();
-    updateConfig(config);
-    if (path10.startsWith(config.outBaseDir))
+    await wxt.reloadConfig();
+    if (path10.startsWith(wxt.config.outBaseDir))
       return;
     changeQueue.push([event, path10]);
     await fileChangedMutex.runExclusive(async () => {
@@ -5494,29 +5557,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) => import_picocolors7.default.dim((0, import_node_path19.relative)(config.root, file))).join(", ")}`
+      wxt.logger.info(
+        `Changed: ${Array.from(new Set(fileChanges)).map((file) => import_picocolors7.default.dim((0, import_node_path19.relative)(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,
@@ -5531,13 +5589,12 @@ function createFileReloader(options) {
         case "html-reload":
           const { reloadedNames } = reloadHtmlPages(
             changes.rebuildGroups,
-            server,
-            config
+            server
           );
           import_consola5.consola.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);
           import_consola5.consola.success(`Reloaded: ${getFilenameList(rebuiltNames)}`);
           break;
@@ -5545,30 +5602,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,
+          wxt.config.browser
         ),
-        matches: resolvePerBrowserOption(entry.options.matches, config.browser),
-        runAt: resolvePerBrowserOption(entry.options.runAt, 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
       });
@@ -5577,10 +5637,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 path10 = getEntrypointBundlePath(entry, config.outDir, ".html");
+    const path10 = getEntrypointBundlePath(entry, wxt.config.outDir, ".html");
     server.reloadPage(path10);
   });
   return {
@@ -5661,19 +5721,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;
@@ -5724,10 +5776,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
@@ -5736,40 +5788,35 @@ var import_node_path21 = require("path");
 var import_fs_extra15 = __toESM(require("fs-extra"), 1);
 var import_minimatch2 = require("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 || (0, import_node_path21.dirname)(process.cwd())
+  const projectName = wxt.config.zip.name ?? kebabCaseAlphanumeric(
+    (await getPackageJson())?.name || (0, import_node_path21.dirname)(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 import_fs_extra15.default.ensureDir(internalConfig.outBaseDir);
-  const outZipFilename = applyTemplate(internalConfig.zip.artifactTemplate);
-  const outZipPath = (0, import_node_path21.resolve)(internalConfig.outBaseDir, outZipFilename);
-  await (0, import_zip_dir.default)(internalConfig.outDir, {
+  ).replaceAll("{{manifestVersion}}", `mv${wxt.config.manifestVersion}`);
+  await import_fs_extra15.default.ensureDir(wxt.config.outBaseDir);
+  const outZipFilename = applyTemplate(wxt.config.zip.artifactTemplate);
+  const outZipPath = (0, import_node_path21.resolve)(wxt.config.outBaseDir, outZipFilename);
+  await (0, import_zip_dir.default)(wxt.config.outDir, {
     saveTo: outZipPath
   });
   zipFiles.push(outZipPath);
-  if (internalConfig.browser === "firefox") {
-    const sourcesZipFilename = applyTemplate(
-      internalConfig.zip.sourcesTemplate
-    );
-    const sourcesZipPath = (0, import_node_path21.resolve)(
-      internalConfig.outBaseDir,
-      sourcesZipFilename
-    );
-    await (0, import_zip_dir.default)(internalConfig.zip.sourcesRoot, {
+  if (wxt.config.browser === "firefox") {
+    const sourcesZipFilename = applyTemplate(wxt.config.zip.sourcesTemplate);
+    const sourcesZipPath = (0, import_node_path21.resolve)(wxt.config.outBaseDir, sourcesZipFilename);
+    await (0, import_zip_dir.default)(wxt.config.zip.sourcesRoot, {
       saveTo: sourcesZipPath,
       filter(path10) {
-        const relativePath = (0, import_node_path21.relative)(internalConfig.zip.sourcesRoot, path10);
-        return internalConfig.zip.includeSources.some(
+        const relativePath = (0, import_node_path21.relative)(wxt.config.zip.sourcesRoot, path10);
+        return wxt.config.zip.includeSources.some(
           (pattern) => (0, import_minimatch2.minimatch)(relativePath, pattern)
-        ) || !internalConfig.zip.excludeSources.some(
+        ) || !wxt.config.zip.excludeSources.some(
           (pattern) => (0, import_minimatch2.minimatch)(relativePath, pattern)
         );
       }
@@ -5777,9 +5824,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;