wxt 0.16.1 → 0.16.3

package/dist/{chunk-7RB7TV6M.js → chunk-4IVGHIAG.js}

@@ -1,5 +1,73 @@
 // package.json
-var version = "0.16.1";
+var version = "0.16.3";
+
+// src/core/utils/fs.ts
+import fs from "fs-extra";
+import glob from "fast-glob";
+
+// src/core/utils/paths.ts
+import systemPath from "node:path";
+import normalize from "normalize-path";
+function normalizePath(path6) {
+  return normalize(path6);
+}
+function unnormalizePath(path6) {
+  return systemPath.normalize(path6);
+}
+var CSS_EXTENSIONS = ["css", "scss", "sass", "less", "styl", "stylus"];
+var CSS_EXTENSIONS_PATTERN = `+(${CSS_EXTENSIONS.join("|")})`;
+
+// src/core/utils/fs.ts
+async function writeFileIfDifferent(file, newContents) {
+  const existingContents = await fs.readFile(file, "utf-8").catch(() => void 0);
+  if (existingContents !== newContents) {
+    await fs.writeFile(file, newContents);
+  }
+}
+async function getPublicFiles() {
+  if (!await fs.exists(wxt.config.publicDir))
+    return [];
+  const files = await glob("**/*", { cwd: wxt.config.publicDir });
+  return files.map(unnormalizePath);
+}
+
+// src/core/utils/building/build-entrypoints.ts
+import fs2 from "fs-extra";
+import { dirname, resolve } from "path";
+import pc from "picocolors";
+async function buildEntrypoints(groups, spinner) {
+  const steps = [];
+  for (let i = 0; i < groups.length; i++) {
+    const group = groups[i];
+    const groupNames = [group].flat().map((e) => e.name);
+    const groupNameColored = groupNames.join(pc.dim(", "));
+    spinner.text = pc.dim(`[${i + 1}/${groups.length}]`) + ` ${groupNameColored}`;
+    try {
+      steps.push(await wxt.config.builder.build(group));
+    } catch (err) {
+      throw Error(`Failed to build ${groupNames.join(", ")}`, { cause: err });
+    }
+  }
+  const publicAssets = await copyPublicDirectory();
+  return { publicAssets, steps };
+}
+async function copyPublicDirectory() {
+  const files = await getPublicFiles();
+  if (files.length === 0)
+    return [];
+  const publicAssets = [];
+  for (const file of files) {
+    const srcPath = resolve(wxt.config.publicDir, file);
+    const outPath = resolve(wxt.config.outDir, file);
+    await fs2.ensureDir(dirname(outPath));
+    await fs2.copyFile(srcPath, outPath);
+    publicAssets.push({
+      type: "asset",
+      fileName: file
+    });
+  }
+  return publicAssets;
+}
 
 // src/core/utils/arrays.ts
 function every(array, predicate) {
@@ -15,29 +83,17 @@ function some(array, predicate) {
   return false;
 }
 
-// src/core/utils/paths.ts
-import systemPath from "node:path";
-import normalize from "normalize-path";
-function normalizePath(path6) {
-  return normalize(path6);
-}
-function unnormalizePath(path6) {
-  return systemPath.normalize(path6);
-}
-var CSS_EXTENSIONS = ["css", "scss", "sass", "less", "styl", "stylus"];
-var CSS_EXTENSIONS_PATTERN = `+(${CSS_EXTENSIONS.join("|")})`;
-
 // 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" };
@@ -121,15 +177,23 @@ function findEffectedSteps(changedFile, currentOutput) {
   return changes;
 }
 
+// src/core/utils/building/find-entrypoints.ts
+import { relative as relative2, resolve as resolve3 } from "path";
+import fs3 from "fs-extra";
+import { minimatch } from "minimatch";
+import { parseHTML } from "linkedom";
+import JSON5 from "json5";
+import glob2 from "fast-glob";
+
 // src/core/utils/entrypoints.ts
-import path, { relative, resolve } from "node:path";
+import path, { relative, resolve as resolve2 } from "node:path";
 function getEntrypointName(entrypointsDir, inputPath) {
   const relativePath = path.relative(entrypointsDir, inputPath);
   const name = relativePath.split(/[\.\/\\]/, 2)[0];
   return name;
 }
 function getEntrypointOutputFile(entrypoint, ext) {
-  return resolve(entrypoint.outputDir, `${entrypoint.name}${ext}`);
+  return resolve2(entrypoint.outputDir, `${entrypoint.name}${ext}`);
 }
 function getEntrypointBundlePath(entrypoint, outDir, ext) {
   return normalizePath(
@@ -142,71 +206,371 @@ function resolvePerBrowserOption(option, browser) {
   return option;
 }
 
+// src/core/utils/constants.ts
+var VIRTUAL_NOOP_BACKGROUND_MODULE_ID = "virtual:user-background";
+
 // src/core/utils/building/find-entrypoints.ts
-import { relative as relative6, resolve as resolve13 } from "path";
-import fs12 from "fs-extra";
-import { minimatch } from "minimatch";
-import { parseHTML as parseHTML2 } from "linkedom";
-import JSON5 from "json5";
+import pc2 from "picocolors";
+async function findEntrypoints() {
+  const relativePaths = await glob2(Object.keys(PATH_GLOB_TO_TYPE_MAP), {
+    cwd: wxt.config.entrypointsDir
+  });
+  relativePaths.sort();
+  const pathGlobs = Object.keys(PATH_GLOB_TO_TYPE_MAP);
+  const entrypointInfos = relativePaths.reduce((results, relativePath) => {
+    const inputPath = resolve3(wxt.config.entrypointsDir, relativePath);
+    const name = getEntrypointName(wxt.config.entrypointsDir, inputPath);
+    const matchingGlob = pathGlobs.find(
+      (glob4) => minimatch(relativePath, glob4)
+    );
+    if (matchingGlob) {
+      const type = PATH_GLOB_TO_TYPE_MAP[matchingGlob];
+      results.push({
+        name,
+        inputPath,
+        type,
+        skipped: wxt.config.filterEntrypoints != null && !wxt.config.filterEntrypoints.has(name)
+      });
+    }
+    return results;
+  }, []);
+  preventNoEntrypoints(entrypointInfos);
+  preventDuplicateEntrypointNames(entrypointInfos);
+  let hasBackground = false;
+  const entrypoints = await Promise.all(
+    entrypointInfos.map(async (info) => {
+      const { type } = info;
+      switch (type) {
+        case "popup":
+          return await getPopupEntrypoint(info);
+        case "options":
+          return await getOptionsEntrypoint(info);
+        case "background":
+          hasBackground = true;
+          return await getBackgroundEntrypoint(info);
+        case "content-script":
+          return await getContentScriptEntrypoint(info);
+        case "unlisted-page":
+          return await getUnlistedPageEntrypoint(info);
+        case "unlisted-script":
+          return await getUnlistedScriptEntrypoint(info);
+        case "content-script-style":
+          return {
+            ...info,
+            type,
+            outputDir: resolve3(wxt.config.outDir, CONTENT_SCRIPT_OUT_DIR),
+            options: {
+              include: void 0,
+              exclude: void 0
+            }
+          };
+        default:
+          return {
+            ...info,
+            type,
+            outputDir: wxt.config.outDir,
+            options: {
+              include: void 0,
+              exclude: void 0
+            }
+          };
+      }
+    })
+  );
+  if (wxt.config.command === "serve" && !hasBackground) {
+    entrypoints.push(
+      await getBackgroundEntrypoint({
+        inputPath: VIRTUAL_NOOP_BACKGROUND_MODULE_ID,
+        name: "background",
+        type: "background",
+        skipped: false
+      })
+    );
+  }
+  wxt.logger.debug("All entrypoints:", entrypoints);
+  const skippedEntrypointNames = entrypointInfos.filter((item) => item.skipped).map((item) => item.name);
+  if (skippedEntrypointNames.length) {
+    wxt.logger.warn(
+      `Filter excluded the following entrypoints:
+${skippedEntrypointNames.map((item) => `${pc2.dim("-")} ${pc2.cyan(item)}`).join("\n")}`
+    );
+  }
+  const targetEntrypoints = entrypoints.filter((entry) => {
+    const { include, exclude } = entry.options;
+    if (include?.length && exclude?.length) {
+      wxt.logger.warn(
+        `The ${entry.name} entrypoint lists both include and exclude, but only one can be used per entrypoint. Entrypoint ignored.`
+      );
+      return false;
+    }
+    if (exclude?.length && !include?.length) {
+      return !exclude.includes(wxt.config.browser);
+    }
+    if (include?.length && !exclude?.length) {
+      return include.includes(wxt.config.browser);
+    }
+    if (skippedEntrypointNames.includes(entry.name)) {
+      return false;
+    }
+    return true;
+  });
+  wxt.logger.debug(`${wxt.config.browser} entrypoints:`, targetEntrypoints);
+  await wxt.hooks.callHook("entrypoints:resolved", wxt, targetEntrypoints);
+  return targetEntrypoints;
+}
+function preventDuplicateEntrypointNames(files) {
+  const namesToPaths = files.reduce(
+    (map, { name, inputPath }) => {
+      map[name] ??= [];
+      map[name].push(inputPath);
+      return map;
+    },
+    {}
+  );
+  const errorLines = Object.entries(namesToPaths).reduce(
+    (lines, [name, absolutePaths]) => {
+      if (absolutePaths.length > 1) {
+        lines.push(`- ${name}`);
+        absolutePaths.forEach((absolutePath) => {
+          lines.push(`  - ${relative2(wxt.config.root, absolutePath)}`);
+        });
+      }
+      return lines;
+    },
+    []
+  );
+  if (errorLines.length > 0) {
+    const errorContent = errorLines.join("\n");
+    throw Error(
+      `Multiple entrypoints with the same name detected, only one entrypoint for each name is allowed.
 
-// src/core/utils/fs.ts
-import fs from "fs-extra";
-import glob from "fast-glob";
-async function writeFileIfDifferent(file, newContents) {
-  const existingContents = await fs.readFile(file, "utf-8").catch(() => void 0);
-  if (existingContents !== newContents) {
-    await fs.writeFile(file, newContents);
+${errorContent}`
+    );
   }
 }
-async function getPublicFiles(config) {
-  if (!await fs.exists(config.publicDir))
-    return [];
-  const files = await glob("**/*", { cwd: config.publicDir });
-  return files.map(unnormalizePath);
+function preventNoEntrypoints(files) {
+  if (files.length === 0) {
+    throw Error(`No entrypoints found in ${wxt.config.entrypointsDir}`);
+  }
 }
-
-// src/core/utils/building/build-entrypoints.ts
-import fs2 from "fs-extra";
-import { dirname, resolve as resolve2 } from "path";
-import pc from "picocolors";
-async function buildEntrypoints(groups, config, spinner) {
-  const steps = [];
-  for (let i = 0; i < groups.length; i++) {
-    const group = groups[i];
-    const groupNames = [group].flat().map((e) => e.name);
-    const groupNameColored = groupNames.join(pc.dim(", "));
-    spinner.text = pc.dim(`[${i + 1}/${groups.length}]`) + ` ${groupNameColored}`;
+function getHtmlBaseOptions(document) {
+  const options = {};
+  const includeContent = document.querySelector("meta[name='manifest.include']")?.getAttribute("content");
+  if (includeContent) {
+    options.include = JSON5.parse(includeContent);
+  }
+  const excludeContent = document.querySelector("meta[name='manifest.exclude']")?.getAttribute("content");
+  if (excludeContent) {
+    options.exclude = JSON5.parse(excludeContent);
+  }
+  return options;
+}
+async function getPopupEntrypoint({
+  inputPath,
+  name,
+  skipped
+}) {
+  const content = await fs3.readFile(inputPath, "utf-8");
+  const { document } = parseHTML(content);
+  const options = getHtmlBaseOptions(document);
+  const title = document.querySelector("title");
+  if (title != null)
+    options.defaultTitle = title.textContent ?? void 0;
+  const defaultIconContent = document.querySelector("meta[name='manifest.default_icon']")?.getAttribute("content");
+  if (defaultIconContent) {
     try {
-      steps.push(await config.builder.build(group));
+      options.defaultIcon = JSON5.parse(defaultIconContent);
     } catch (err) {
-      throw Error(`Failed to build ${groupNames.join(", ")}`, { cause: err });
+      wxt.logger.fatal(
+        `Failed to parse default_icon meta tag content as JSON5. content=${defaultIconContent}`,
+        err
+      );
     }
   }
-  const publicAssets = await copyPublicDirectory(config);
-  return { publicAssets, steps };
-}
-async function copyPublicDirectory(config) {
-  const files = await getPublicFiles(config);
-  if (files.length === 0)
-    return [];
-  const publicAssets = [];
-  for (const file of files) {
-    const srcPath = resolve2(config.publicDir, file);
-    const outPath = resolve2(config.outDir, file);
-    await fs2.ensureDir(dirname(outPath));
-    await fs2.copyFile(srcPath, outPath);
-    publicAssets.push({
-      type: "asset",
-      fileName: file
-    });
+  const mv2TypeContent = document.querySelector("meta[name='manifest.type']")?.getAttribute("content");
+  if (mv2TypeContent) {
+    options.mv2Key = mv2TypeContent === "page_action" ? "page_action" : "browser_action";
   }
-  return publicAssets;
-}
-
-// src/core/utils/building/generate-wxt-dir.ts
-import { createUnimport } from "unimport";
-import fs3 from "fs-extra";
-import { relative as relative2, resolve as resolve3 } from "path";
+  const browserStyleContent = document.querySelector("meta[name='manifest.browser_style']")?.getAttribute("content");
+  if (browserStyleContent) {
+    options.browserStyle = browserStyleContent === "true";
+  }
+  return {
+    type: "popup",
+    name: "popup",
+    options,
+    inputPath,
+    outputDir: wxt.config.outDir,
+    skipped
+  };
+}
+async function getOptionsEntrypoint({
+  inputPath,
+  name,
+  skipped
+}) {
+  const content = await fs3.readFile(inputPath, "utf-8");
+  const { document } = parseHTML(content);
+  const options = getHtmlBaseOptions(document);
+  const openInTabContent = document.querySelector("meta[name='manifest.open_in_tab']")?.getAttribute("content");
+  if (openInTabContent) {
+    options.openInTab = openInTabContent === "true";
+  }
+  const chromeStyleContent = document.querySelector("meta[name='manifest.chrome_style']")?.getAttribute("content");
+  if (chromeStyleContent) {
+    options.chromeStyle = chromeStyleContent === "true";
+  }
+  const browserStyleContent = document.querySelector("meta[name='manifest.browser_style']")?.getAttribute("content");
+  if (browserStyleContent) {
+    options.browserStyle = browserStyleContent === "true";
+  }
+  return {
+    type: "options",
+    name: "options",
+    options,
+    inputPath,
+    outputDir: wxt.config.outDir,
+    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(wxt.config.entrypointsDir, inputPath),
+    inputPath,
+    outputDir: wxt.config.outDir,
+    options: getHtmlBaseOptions(document),
+    skipped
+  };
+}
+async function getUnlistedScriptEntrypoint({
+  inputPath,
+  name,
+  skipped
+}) {
+  const defaultExport = await importEntrypointFile(inputPath);
+  if (defaultExport == null) {
+    throw Error(
+      `${name}: Default export not found, did you forget to call "export default defineUnlistedScript(...)"?`
+    );
+  }
+  const { main: _, ...moduleOptions } = defaultExport;
+  const options = moduleOptions;
+  return {
+    type: "unlisted-script",
+    name,
+    inputPath,
+    outputDir: wxt.config.outDir,
+    options,
+    skipped
+  };
+}
+async function getBackgroundEntrypoint({
+  inputPath,
+  name,
+  skipped
+}) {
+  let options = {};
+  if (inputPath !== VIRTUAL_NOOP_BACKGROUND_MODULE_ID) {
+    const defaultExport = await importEntrypointFile(inputPath);
+    if (defaultExport == null) {
+      throw Error(
+        `${name}: Default export not found, did you forget to call "export default defineBackground(...)"?`
+      );
+    }
+    const { main: _, ...moduleOptions } = defaultExport;
+    options = moduleOptions;
+  }
+  if (wxt.config.manifestVersion !== 3) {
+    delete options.type;
+  }
+  return {
+    type: "background",
+    name,
+    inputPath,
+    outputDir: wxt.config.outDir,
+    options: {
+      ...options,
+      type: resolvePerBrowserOption(options.type, wxt.config.browser),
+      persistent: resolvePerBrowserOption(
+        options.persistent,
+        wxt.config.browser
+      )
+    },
+    skipped
+  };
+}
+async function getContentScriptEntrypoint({
+  inputPath,
+  name,
+  skipped
+}) {
+  const { main: _, ...options } = await importEntrypointFile(inputPath);
+  if (options == null) {
+    throw Error(
+      `${name}: Default export not found, did you forget to call "export default defineContentScript(...)"?`
+    );
+  }
+  return {
+    type: "content-script",
+    name,
+    inputPath,
+    outputDir: resolve3(wxt.config.outDir, CONTENT_SCRIPT_OUT_DIR),
+    options,
+    skipped
+  };
+}
+var PATH_GLOB_TO_TYPE_MAP = {
+  "sandbox.html": "sandbox",
+  "sandbox/index.html": "sandbox",
+  "*.sandbox.html": "sandbox",
+  "*.sandbox/index.html": "sandbox",
+  "bookmarks.html": "bookmarks",
+  "bookmarks/index.html": "bookmarks",
+  "history.html": "history",
+  "history/index.html": "history",
+  "newtab.html": "newtab",
+  "newtab/index.html": "newtab",
+  "sidepanel.html": "sidepanel",
+  "sidepanel/index.html": "sidepanel",
+  "*.sidepanel.html": "sidepanel",
+  "*.sidepanel/index.html": "sidepanel",
+  "devtools.html": "devtools",
+  "devtools/index.html": "devtools",
+  "background.[jt]s": "background",
+  "background/index.[jt]s": "background",
+  [VIRTUAL_NOOP_BACKGROUND_MODULE_ID]: "background",
+  "content.[jt]s?(x)": "content-script",
+  "content/index.[jt]s?(x)": "content-script",
+  "*.content.[jt]s?(x)": "content-script",
+  "*.content/index.[jt]s?(x)": "content-script",
+  [`content.${CSS_EXTENSIONS_PATTERN}`]: "content-script-style",
+  [`*.content.${CSS_EXTENSIONS_PATTERN}`]: "content-script-style",
+  [`content/index.${CSS_EXTENSIONS_PATTERN}`]: "content-script-style",
+  [`*.content/index.${CSS_EXTENSIONS_PATTERN}`]: "content-script-style",
+  "popup.html": "popup",
+  "popup/index.html": "popup",
+  "options.html": "options",
+  "options/index.html": "options",
+  "*.html": "unlisted-page",
+  "*/index.html": "unlisted-page",
+  "*.[jt]s?(x)": "unlisted-script",
+  "*/index.[jt]s?(x)": "unlisted-script",
+  [`*.${CSS_EXTENSIONS_PATTERN}`]: "unlisted-style",
+  [`*/index.${CSS_EXTENSIONS_PATTERN}`]: "unlisted-style"
+};
+var CONTENT_SCRIPT_OUT_DIR = "content-scripts";
+
+// src/core/utils/building/generate-wxt-dir.ts
+import { createUnimport } from "unimport";
+import fs4 from "fs-extra";
+import { relative as relative3, resolve as resolve4 } from "path";
 
 // src/core/utils/unimport.ts
 import { defu } from "defu";
@@ -327,23 +691,23 @@ function parseI18nMessages(messagesJson) {
 }
 
 // src/core/utils/building/generate-wxt-dir.ts
-async function generateTypesDir(entrypoints, config) {
-  await fs3.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 = resolve3(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(
@@ -352,15 +716,15 @@ async function writeImportsDeclarationFile(config, unimportOptions) {
   );
   return filePath;
 }
-async function writePathsDeclarationFile(entrypoints, config) {
-  const filePath = resolve3(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((path6) => `    | "/${path6}"`).sort().join("\n");
+  ).concat(await getPublicFiles()).map(normalizePath).map((path6) => `    | "/${path6}"`).sort().join("\n");
   const template = `// Generated by wxt
 import "wxt/browser";
 
@@ -380,9 +744,9 @@ declare module "wxt/browser" {
   );
   return filePath;
 }
-async function writeI18nDeclarationFile(config) {
-  const filePath = resolve3(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";
 
@@ -405,12 +769,12 @@ declare module "wxt/browser" {
   let messages;
   if (defaultLocale) {
     const defaultLocalePath = path2.resolve(
-      config.publicDir,
+      wxt.config.publicDir,
       "_locales",
       defaultLocale,
       "messages.json"
     );
-    const content = JSON.parse(await fs3.readFile(defaultLocalePath, "utf-8"));
+    const content = JSON.parse(await fs4.readFile(defaultLocalePath, "utf-8"));
     messages = parseI18nMessages(content);
   } else {
     messages = parseI18nMessages({});
@@ -433,9 +797,9 @@ declare module "wxt/browser" {
   );
   return filePath;
 }
-async function writeGlobalsDeclarationFile(config) {
-  const filePath = resolve3(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,
     [
@@ -451,25 +815,25 @@ async function writeGlobalsDeclarationFile(config) {
   );
   return filePath;
 }
-async function writeMainDeclarationFile(references, config) {
-  const dir = config.wxtDir;
-  const filePath = resolve3(dir, "wxt.d.ts");
+async function writeMainDeclarationFile(references) {
+  const dir = wxt.config.wxtDir;
+  const filePath = resolve4(dir, "wxt.d.ts");
   await writeFileIfDifferent(
     filePath,
     [
       "// Generated by wxt",
       `/// <reference types="wxt/vite-builder-env" />`,
       ...references.map(
-        (ref) => `/// <reference types="./${normalizePath(relative2(dir, ref))}" />`
+        (ref) => `/// <reference types="./${normalizePath(relative3(dir, ref))}" />`
       )
     ].join("\n") + "\n"
   );
   return filePath;
 }
-async function writeTsConfigFile(mainReference, config) {
-  const dir = config.wxtDir;
-  const getTsconfigPath = (path6) => normalizePath(relative2(dir, path6));
-  const paths = Object.entries(config.alias).flatMap(([alias, absolutePath]) => {
+async function writeTsConfigFile(mainReference) {
+  const dir = wxt.config.wxtDir;
+  const getTsconfigPath = (path6) => normalizePath(relative3(dir, path6));
+  const paths = Object.entries(wxt.config.alias).flatMap(([alias, absolutePath]) => {
     const aliasPath = getTsconfigPath(absolutePath);
     return [
       `      "${alias}": ["${aliasPath}"]`,
@@ -477,7 +841,7 @@ async function writeTsConfigFile(mainReference, config) {
     ];
   }).join(",\n");
   await writeFileIfDifferent(
-    resolve3(dir, "tsconfig.json"),
+    resolve4(dir, "tsconfig.json"),
     `{
   "compilerOptions": {
     "target": "ESNext",
@@ -494,23 +858,23 @@ ${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 path4 from "node:path";
 
 // src/core/utils/cache.ts
-import fs4, { ensureDir } from "fs-extra";
-import { dirname as dirname2, resolve as resolve4 } from "path";
+import fs5, { ensureDir } from "fs-extra";
+import { dirname as dirname2, resolve as resolve5 } from "path";
 function createFsCache(wxtDir) {
-  const getPath = (key) => resolve4(wxtDir, "cache", encodeURIComponent(key));
+  const getPath = (key) => resolve5(wxtDir, "cache", encodeURIComponent(key));
   return {
     async set(key, value) {
       const path6 = getPath(key);
@@ -520,7 +884,7 @@ function createFsCache(wxtDir) {
     async get(key) {
       const path6 = getPath(key);
       try {
-        return await fs4.readFile(path6, "utf-8");
+        return await fs5.readFile(path6, "utf-8");
       } catch {
         return void 0;
       }
@@ -528,16 +892,16 @@ 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
-import { parseHTML } from "linkedom";
-import { dirname as dirname3, relative as relative3, resolve as resolve5 } from "node:path";
+import { parseHTML as parseHTML2 } from "linkedom";
+import { dirname as dirname3, relative as relative4, resolve as resolve6 } from "node:path";
 var reactRefreshPreamble = "";
 function devHtmlPrerender(config) {
   const htmlReloadId = "@wxt/reload-html";
-  const resolvedHtmlReloadId = resolve5(
+  const resolvedHtmlReloadId = resolve6(
     config.root,
     "node_modules/wxt/dist/virtual/reload-html.js"
   );
@@ -562,7 +926,7 @@ function devHtmlPrerender(config) {
         const server = config.server;
         if (config.command !== "serve" || server == null || !id.endsWith(".html"))
           return;
-        const { document } = parseHTML(code);
+        const { document } = parseHTML2(code);
         const _pointToDevServer = (querySelector, attr) => pointToDevServer(config, server, id, document, querySelector, attr);
         _pointToDevServer("script[type=module]", "src");
         _pointToDevServer("link[rel=stylesheet]", "href");
@@ -585,7 +949,7 @@ function devHtmlPrerender(config) {
         const name = getEntrypointName(config.entrypointsDir, ctx.filename);
         const url = `${server.origin}/${name}.html`;
         const serverHtml = await server.transformHtml(url, html, originalUrl);
-        const { document } = parseHTML(serverHtml);
+        const { document } = parseHTML2(serverHtml);
         const reactRefreshScript = Array.from(
           document.querySelectorAll("script[type=module]")
         ).find((script) => script.innerHTML.includes("@react-refresh"));
@@ -642,16 +1006,16 @@ function pointToDevServer(config, server, id, document, querySelector, attr) {
     );
     if (matchingAlias) {
       const [alias, replacement] = matchingAlias;
-      resolvedAbsolutePath = resolve5(
+      resolvedAbsolutePath = resolve6(
         config.root,
         src.replace(alias, replacement)
       );
     } else {
-      resolvedAbsolutePath = resolve5(dirname3(id), src);
+      resolvedAbsolutePath = resolve6(dirname3(id), src);
     }
     if (resolvedAbsolutePath) {
       const relativePath = normalizePath(
-        relative3(config.root, resolvedAbsolutePath)
+        relative4(config.root, resolvedAbsolutePath)
       );
       if (relativePath.startsWith(".")) {
         let path6 = normalizePath(resolvedAbsolutePath);
@@ -771,8 +1135,8 @@ function download(config) {
 }
 
 // src/core/builders/vite/plugins/multipageMove.ts
-import { dirname as dirname4, extname, resolve as resolve6, join } from "node:path";
-import fs5, { ensureDir as ensureDir2 } from "fs-extra";
+import { dirname as dirname4, extname, resolve as resolve7, join } from "node:path";
+import fs6, { ensureDir as ensureDir2 } from "fs-extra";
 function multipageMove(entrypoints, config) {
   return {
     name: "wxt:multipage-move",
@@ -799,10 +1163,10 @@ function multipageMove(entrypoints, config) {
           );
           continue;
         }
-        const oldAbsPath = resolve6(config.outDir, oldBundlePath);
-        const newAbsPath = resolve6(config.outDir, newBundlePath);
+        const oldAbsPath = resolve7(config.outDir, oldBundlePath);
+        const newAbsPath = resolve7(config.outDir, newBundlePath);
         await ensureDir2(dirname4(newAbsPath));
-        await fs5.move(oldAbsPath, newAbsPath, { overwrite: true });
+        await fs6.move(oldAbsPath, newAbsPath, { overwrite: true });
         const renamedChunk = {
           ...bundle[oldBundlePath],
           fileName: newBundlePath
@@ -815,16 +1179,16 @@ function multipageMove(entrypoints, config) {
   };
 }
 async function removeEmptyDirs(dir) {
-  const files = await fs5.readdir(dir);
+  const files = await fs6.readdir(dir);
   for (const file of files) {
     const filePath = join(dir, file);
-    const stats = await fs5.stat(filePath);
+    const stats = await fs6.stat(filePath);
     if (stats.isDirectory()) {
       await removeEmptyDirs(filePath);
     }
   }
   try {
-    await fs5.rmdir(dir);
+    await fs6.rmdir(dir);
   } catch {
   }
 }
@@ -865,8 +1229,8 @@ function unimport(config) {
 }
 
 // src/core/builders/vite/plugins/virtualEntrypoint.ts
-import fs6 from "fs-extra";
-import { resolve as resolve7 } from "path";
+import fs7 from "fs-extra";
+import { resolve as resolve8 } from "path";
 function virtualEntrypoint(type, config) {
   const virtualId = `virtual:wxt-${type}?`;
   const resolvedVirtualId = `\0${virtualId}`;
@@ -883,8 +1247,8 @@ function virtualEntrypoint(type, config) {
       if (!id.startsWith(resolvedVirtualId))
         return;
       const inputPath = id.replace(resolvedVirtualId, "");
-      const template = await fs6.readFile(
-        resolve7(
+      const template = await fs7.readFile(
+        resolve8(
           config.root,
           `node_modules/wxt/dist/virtual/${type}-entrypoint.js`
         ),
@@ -909,9 +1273,6 @@ function tsconfigPaths(config) {
   };
 }
 
-// src/core/utils/constants.ts
-var VIRTUAL_NOOP_BACKGROUND_MODULE_ID = "virtual:user-background";
-
 // src/core/builders/vite/plugins/noopBackground.ts
 function noopBackground() {
   const virtualModuleId = VIRTUAL_NOOP_BACKGROUND_MODULE_ID;
@@ -1048,6 +1409,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");
@@ -1084,7 +1460,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());
@@ -1262,9 +1639,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) {
@@ -1358,7 +1735,8 @@ async function getInternalConfig(inlineConfig, command, server) {
     server,
     dev: {
       reloadCommand
-    }
+    },
+    hooks: mergedConfig.hooks ?? {}
   };
   const builder = await createViteBuilder(
     inlineConfig,
@@ -1395,6 +1773,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,
@@ -1429,7 +1811,8 @@ function mergeInlineConfig(inlineConfig, userConfig) {
     dev: {
       ...userConfig.dev,
       ...inlineConfig.dev
-    }
+    },
+    hooks
   };
 }
 function resolveInternalZipConfig(root, mergedConfig) {
@@ -1497,8 +1880,8 @@ var ENTRY_TYPE_TO_GROUP_MAP = {
 // src/core/utils/building/import-entrypoint.ts
 import createJITI from "jiti";
 import { createUnimport as createUnimport3 } from "unimport";
-import fs7 from "fs-extra";
-import { relative as relative4, resolve as resolve8 } from "node:path";
+import fs8 from "fs-extra";
+import { relative as relative5, resolve as resolve9 } from "node:path";
 
 // src/core/utils/strings.ts
 function kebabCaseAlphanumeric(str) {
@@ -1520,30 +1903,30 @@ ${noImports}`;
 // src/core/utils/building/import-entrypoint.ts
 import { transformSync } from "esbuild";
 import { fileURLToPath } from "node:url";
-async function importEntrypointFile(path6, config) {
-  config.logger.debug("Loading file metadata:", path6);
+async function importEntrypointFile(path6) {
+  wxt.logger.debug("Loading file metadata:", path6);
   const normalPath = normalizePath(path6);
   const unimport2 = createUnimport3({
-    ...getUnimportOptions(config),
+    ...getUnimportOptions(wxt.config),
     // Only allow specific imports, not all from the project
     dirs: []
   });
   await unimport2.init();
-  const text = await fs7.readFile(path6, "utf-8");
+  const text = await fs8.readFile(path6, "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": resolve8(
-          config.root,
+        "webextension-polyfill": resolve9(
+          wxt.config.root,
           "node_modules/wxt/dist/virtual/mock-browser.js"
         )
       },
@@ -1575,7 +1958,7 @@ async function importEntrypointFile(path6, config) {
     const res = await jiti(path6);
     return res.default;
   } catch (err) {
-    const filePath = relative4(config.root, path6);
+    const filePath = relative5(wxt.config.root, path6);
     if (err instanceof ReferenceError) {
       const variableName = err.message.replace(" is not defined", "");
       throw Error(
@@ -1583,7 +1966,7 @@ async function importEntrypointFile(path6, config) {
         { cause: err }
       );
     } else {
-      config.logger.error(err);
+      wxt.logger.error(err);
       throw Error(`Failed to load entrypoint: ${filePath}`, { cause: err });
     }
   }
@@ -1598,16 +1981,16 @@ function getEsbuildOptions(opts) {
 }
 
 // src/core/utils/building/internal-build.ts
-import pc4 from "picocolors";
-import fs11 from "fs-extra";
+import pc5 from "picocolors";
+import fs12 from "fs-extra";
 
 // src/core/utils/log/printBuildSummary.ts
-import { resolve as resolve9 } from "path";
+import { resolve as resolve10 } from "path";
 
 // src/core/utils/log/printFileList.ts
 import path5 from "node:path";
-import pc2 from "picocolors";
-import fs8 from "fs-extra";
+import pc3 from "picocolors";
+import fs9 from "fs-extra";
 import { filesize } from "filesize";
 
 // src/core/utils/log/printTable.ts
@@ -1648,36 +2031,36 @@ async function printFileList(log, header, baseDir, files) {
       ];
       const prefix = i === files.length - 1 ? "  \u2514\u2500" : "  \u251C\u2500";
       const color = getChunkColor(file);
-      const stats = await fs8.lstat(file);
+      const stats = await fs9.lstat(file);
       totalSize += stats.size;
       const size = String(filesize(stats.size));
       return [
-        `${pc2.gray(prefix)} ${pc2.dim(parts[0])}${color(parts[1])}`,
-        pc2.dim(size)
+        `${pc3.gray(prefix)} ${pc3.dim(parts[0])}${color(parts[1])}`,
+        pc3.dim(size)
       ];
     })
   );
-  fileRows.push([`${pc2.cyan("\u03A3 Total size:")} ${String(filesize(totalSize))}`]);
+  fileRows.push([`${pc3.cyan("\u03A3 Total size:")} ${String(filesize(totalSize))}`]);
   printTable(log, header, fileRows);
 }
-var DEFAULT_COLOR = pc2.blue;
+var DEFAULT_COLOR = pc3.blue;
 var CHUNK_COLORS = {
-  ".js.map": pc2.gray,
-  ".cjs.map": pc2.gray,
-  ".mjs.map": pc2.gray,
-  ".html": pc2.green,
-  ".css": pc2.magenta,
-  ".js": pc2.cyan,
-  ".cjs": pc2.cyan,
-  ".mjs": pc2.cyan,
-  ".zip": pc2.yellow
+  ".js.map": pc3.gray,
+  ".cjs.map": pc3.gray,
+  ".mjs.map": pc3.gray,
+  ".html": pc3.green,
+  ".css": pc3.magenta,
+  ".js": pc3.cyan,
+  ".cjs": pc3.cyan,
+  ".mjs": pc3.cyan,
+  ".zip": pc3.yellow
 };
 function getChunkColor(filename) {
   return Object.entries(CHUNK_COLORS).find(([key]) => filename.endsWith(key))?.[1] ?? DEFAULT_COLOR;
 }
 
 // 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
@@ -1689,8 +2072,10 @@ async function printBuildSummary(log, header, output, config) {
       return diff;
     return l.fileName.localeCompare(r.fileName);
   });
-  const files = chunks.map((chunk) => resolve9(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 = {
@@ -1707,15 +2092,15 @@ function getChunkSortWeight(filename) {
 }
 
 // src/core/utils/log/printHeader.ts
-import pc3 from "picocolors";
+import pc4 from "picocolors";
 import { consola as consola2 } from "consola";
 
 // src/core/utils/building/internal-build.ts
-import glob2 from "fast-glob";
+import glob3 from "fast-glob";
 
 // src/core/utils/manifest.ts
-import fs10 from "fs-extra";
-import { resolve as resolve11 } from "path";
+import fs11 from "fs-extra";
+import { resolve as resolve12 } from "path";
 
 // src/core/utils/content-security-policy.ts
 var ContentSecurityPolicy = class _ContentSecurityPolicy {
@@ -1761,8 +2146,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];
@@ -1788,45 +2173,45 @@ 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
   };
 }
 
 // src/core/utils/package.ts
-import { resolve as resolve10 } from "node:path";
-import fs9 from "fs-extra";
-async function getPackageJson(config) {
-  const file = resolve10(config.root, "package.json");
+import { resolve as resolve11 } from "node:path";
+import fs10 from "fs-extra";
+async function getPackageJson() {
+  const file = resolve11(wxt.config.root, "package.json");
   try {
-    return await fs9.readJson(file);
+    return await fs10.readJson(file);
   } catch (err) {
-    config.logger.debug(
+    wxt.logger.debug(
       `Failed to read package.json at: ${file}. Returning undefined.`
     );
     return {};
@@ -1836,40 +2221,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 fs10.ensureDir(config.outDir);
-  await writeFileIfDifferent(resolve11(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"
@@ -1879,20 +2264,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"
@@ -1917,7 +2303,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);
@@ -1934,13 +2320,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
@@ -1953,29 +2343,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"
       );
     }
@@ -1984,14 +2374,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 = {};
@@ -2019,28 +2409,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")
         )
       };
     }
@@ -2049,33 +2439,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);
@@ -2086,7 +2476,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
@@ -2095,10 +2485,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")
           )
         })
       );
@@ -2108,7 +2498,6 @@ function addEntrypoints(manifest, entrypoints, buildOutput, config) {
       }
     }
     const contentScriptCssResources = getContentScriptCssWebAccessibleResources(
-      config,
       contentScripts,
       cssMap
     );
@@ -2151,9 +2540,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 {
@@ -2166,7 +2555,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 ??= {};
@@ -2175,9 +2564,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) {
@@ -2195,7 +2584,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")
@@ -2203,14 +2592,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))
       });
     }
@@ -2250,28 +2639,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: {
@@ -2288,7 +2677,7 @@ async function rebuild(config, allEntrypoints, entrypointGroups, existingOutput
 }
 
 // src/core/utils/building/internal-build.ts
-import { relative as relative5 } from "node:path";
+import { relative as relative6 } from "node:path";
 
 // src/core/utils/validation.ts
 function validateEntrypoints(entrypoints) {
@@ -2354,32 +2743,35 @@ import consola3 from "consola";
 
 // src/core/utils/exec.ts
 import managePath from "manage-path";
-import { resolve as resolve12 } from "node: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(resolve12(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-4F7CCWCA.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} ${pc4.cyan(target)} for ${pc4.cyan(config.mode)} with ${pc4.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 fs11.rm(config.outDir, { recursive: true, force: true });
-  await fs11.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`, {
@@ -2387,45 +2779,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:
-  ${pc4.gray("\u2514\u2500")} ${pc4.yellow("stats.html")}`
+  ${pc5.gray("\u2514\u2500")} ${pc5.yellow("stats.html")}`
     );
   }
   return output;
 }
-async function combineAnalysisStats(config) {
-  const unixFiles = await glob2(`stats-*.json`, {
-    cwd: config.outDir,
+async function combineAnalysisStats() {
+  const unixFiles = await glob3(`stats-*.json`, {
+    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();
@@ -2436,355 +2827,40 @@ function printValidationResults(config, { errorCount, errors, warningCount }) {
     return map;
   }, /* @__PURE__ */ new Map());
   Array.from(entrypointErrors.entries()).forEach(([entrypoint, errors2]) => {
-    consola3.log(relative5(cwd, entrypoint.inputPath));
+    consola3.log(relative6(cwd, entrypoint.inputPath));
     console.log();
     errors2.forEach((err) => {
-      const type = err.type === "error" ? pc4.red("ERROR") : pc4.yellow("WARN");
-      const recieved = pc4.dim(`(recieved: ${JSON.stringify(err.value)})`);
+      const type = err.type === "error" ? pc5.red("ERROR") : pc5.yellow("WARN");
+      const recieved = pc5.dim(`(recieved: ${JSON.stringify(err.value)})`);
       consola3.log(`  - ${type} ${err.message} ${recieved}`);
     });
     console.log();
   });
 }
 
-// src/core/utils/building/find-entrypoints.ts
-import glob3 from "fast-glob";
-import pc5 from "picocolors";
-async function findEntrypoints(config) {
-  const relativePaths = await glob3(Object.keys(PATH_GLOB_TO_TYPE_MAP), {
-    cwd: config.entrypointsDir
-  });
-  relativePaths.sort();
-  const pathGlobs = Object.keys(PATH_GLOB_TO_TYPE_MAP);
-  const entrypointInfos = relativePaths.reduce((results, relativePath) => {
-    const inputPath = resolve13(config.entrypointsDir, relativePath);
-    const name = getEntrypointName(config.entrypointsDir, inputPath);
-    const matchingGlob = pathGlobs.find(
-      (glob4) => minimatch(relativePath, glob4)
-    );
-    if (matchingGlob) {
-      const type = PATH_GLOB_TO_TYPE_MAP[matchingGlob];
-      results.push({
-        name,
-        inputPath,
-        type,
-        skipped: config.filterEntrypoints != null && !config.filterEntrypoints.has(name)
-      });
-    }
-    return results;
-  }, []);
-  preventNoEntrypoints(config, entrypointInfos);
-  preventDuplicateEntrypointNames(config, 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);
-        case "options":
-          return await getOptionsEntrypoint(config, info);
-        case "background":
-          hasBackground = true;
-          return await getBackgroundEntrypoint(config, info);
-        case "content-script":
-          return await getContentScriptEntrypoint(config, info);
-        case "unlisted-page":
-          return await getUnlistedPageEntrypoint(config, info);
-        case "unlisted-script":
-          return await getUnlistedScriptEntrypoint(config, info);
-        case "content-script-style":
-          return {
-            ...info,
-            type,
-            outputDir: resolve13(config.outDir, CONTENT_SCRIPT_OUT_DIR),
-            options: {
-              include: void 0,
-              exclude: void 0
-            }
-          };
-        default:
-          return {
-            ...info,
-            type,
-            outputDir: config.outDir,
-            options: {
-              include: void 0,
-              exclude: void 0
-            }
-          };
-      }
-    })
-  );
-  if (config.command === "serve" && !hasBackground) {
-    entrypoints.push(
-      await getBackgroundEntrypoint(config, {
-        inputPath: VIRTUAL_NOOP_BACKGROUND_MODULE_ID,
-        name: "background",
-        type: "background",
-        skipped: false
-      })
-    );
-  }
-  config.logger.debug("All entrypoints:", entrypoints);
-  const skippedEntrypointNames = entrypointInfos.filter((item) => item.skipped).map((item) => item.name);
-  if (skippedEntrypointNames.length) {
-    config.logger.warn(
-      `Filter excluded the following entrypoints:
-${skippedEntrypointNames.map((item) => `${pc5.dim("-")} ${pc5.cyan(item)}`).join("\n")}`
-    );
-  }
-  const targetEntrypoints = entrypoints.filter((entry) => {
-    const { include, exclude } = entry.options;
-    if (include?.length && exclude?.length) {
-      config.logger.warn(
-        `The ${entry.name} entrypoint lists both include and exclude, but only one can be used per entrypoint. Entrypoint ignored.`
-      );
-      return false;
-    }
-    if (exclude?.length && !include?.length) {
-      return !exclude.includes(config.browser);
-    }
-    if (include?.length && !exclude?.length) {
-      return include.includes(config.browser);
-    }
-    if (skippedEntrypointNames.includes(entry.name)) {
-      return false;
-    }
-    return true;
-  });
-  config.logger.debug(`${config.browser} entrypoints:`, targetEntrypoints);
-  return targetEntrypoints;
-}
-function preventDuplicateEntrypointNames(config, files) {
-  const namesToPaths = files.reduce(
-    (map, { name, inputPath }) => {
-      map[name] ??= [];
-      map[name].push(inputPath);
-      return map;
-    },
-    {}
-  );
-  const errorLines = Object.entries(namesToPaths).reduce(
-    (lines, [name, absolutePaths]) => {
-      if (absolutePaths.length > 1) {
-        lines.push(`- ${name}`);
-        absolutePaths.forEach((absolutePath) => {
-          lines.push(`  - ${relative6(config.root, absolutePath)}`);
-        });
-      }
-      return lines;
+// 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;
     },
-    []
-  );
-  if (errorLines.length > 0) {
-    const errorContent = errorLines.join("\n");
-    throw Error(
-      `Multiple entrypoints with the same name detected, only one entrypoint for each name is allowed.
-
-${errorContent}`
-    );
-  }
-}
-function preventNoEntrypoints(config, files) {
-  if (files.length === 0) {
-    throw Error(`No entrypoints found in ${config.entrypointsDir}`);
-  }
-}
-function getHtmlBaseOptions(document) {
-  const options = {};
-  const includeContent = document.querySelector("meta[name='manifest.include']")?.getAttribute("content");
-  if (includeContent) {
-    options.include = JSON5.parse(includeContent);
-  }
-  const excludeContent = document.querySelector("meta[name='manifest.exclude']")?.getAttribute("content");
-  if (excludeContent) {
-    options.exclude = JSON5.parse(excludeContent);
-  }
-  return options;
-}
-async function getPopupEntrypoint(config, { inputPath, name, skipped }) {
-  const content = await fs12.readFile(inputPath, "utf-8");
-  const { document } = parseHTML2(content);
-  const options = getHtmlBaseOptions(document);
-  const title = document.querySelector("title");
-  if (title != null)
-    options.defaultTitle = title.textContent ?? void 0;
-  const defaultIconContent = document.querySelector("meta[name='manifest.default_icon']")?.getAttribute("content");
-  if (defaultIconContent) {
-    try {
-      options.defaultIcon = JSON5.parse(defaultIconContent);
-    } catch (err) {
-      config.logger.fatal(
-        `Failed to parse default_icon meta tag content as JSON5. content=${defaultIconContent}`,
-        err
-      );
+    async reloadConfig() {
+      wxt.config = await resolveConfig(inlineConfig, command, server);
     }
-  }
-  const mv2TypeContent = document.querySelector("meta[name='manifest.type']")?.getAttribute("content");
-  if (mv2TypeContent) {
-    options.mv2Key = mv2TypeContent === "page_action" ? "page_action" : "browser_action";
-  }
-  const browserStyleContent = document.querySelector("meta[name='manifest.browser_style']")?.getAttribute("content");
-  if (browserStyleContent) {
-    options.browserStyle = browserStyleContent === "true";
-  }
-  return {
-    type: "popup",
-    name: "popup",
-    options,
-    inputPath,
-    outputDir: config.outDir,
-    skipped
   };
+  wxt.hooks.addHooks(config.hooks);
+  await wxt.hooks.callHook("ready", wxt);
 }
-async function getOptionsEntrypoint(config, { inputPath, name, skipped }) {
-  const content = await fs12.readFile(inputPath, "utf-8");
-  const { document } = parseHTML2(content);
-  const options = getHtmlBaseOptions(document);
-  const openInTabContent = document.querySelector("meta[name='manifest.open_in_tab']")?.getAttribute("content");
-  if (openInTabContent) {
-    options.openInTab = openInTabContent === "true";
-  }
-  const chromeStyleContent = document.querySelector("meta[name='manifest.chrome_style']")?.getAttribute("content");
-  if (chromeStyleContent) {
-    options.chromeStyle = chromeStyleContent === "true";
-  }
-  const browserStyleContent = document.querySelector("meta[name='manifest.browser_style']")?.getAttribute("content");
-  if (browserStyleContent) {
-    options.browserStyle = browserStyleContent === "true";
-  }
-  return {
-    type: "options",
-    name: "options",
-    options,
-    inputPath,
-    outputDir: config.outDir,
-    skipped
-  };
-}
-async function getUnlistedPageEntrypoint(config, { inputPath, name, skipped }) {
-  const content = await fs12.readFile(inputPath, "utf-8");
-  const { document } = parseHTML2(content);
-  return {
-    type: "unlisted-page",
-    name: getEntrypointName(config.entrypointsDir, inputPath),
-    inputPath,
-    outputDir: config.outDir,
-    options: getHtmlBaseOptions(document),
-    skipped
-  };
-}
-async function getUnlistedScriptEntrypoint(config, { inputPath, name, skipped }) {
-  const defaultExport = await importEntrypointFile(
-    inputPath,
-    config
-  );
-  if (defaultExport == null) {
-    throw Error(
-      `${name}: Default export not found, did you forget to call "export default defineUnlistedScript(...)"?`
-    );
-  }
-  const { main: _, ...moduleOptions } = defaultExport;
-  const options = moduleOptions;
-  return {
-    type: "unlisted-script",
-    name,
-    inputPath,
-    outputDir: config.outDir,
-    options,
-    skipped
-  };
-}
-async function getBackgroundEntrypoint(config, { inputPath, name, skipped }) {
-  let options = {};
-  if (inputPath !== VIRTUAL_NOOP_BACKGROUND_MODULE_ID) {
-    const defaultExport = await importEntrypointFile(
-      inputPath,
-      config
-    );
-    if (defaultExport == null) {
-      throw Error(
-        `${name}: Default export not found, did you forget to call "export default defineBackground(...)"?`
-      );
-    }
-    const { main: _, ...moduleOptions } = defaultExport;
-    options = moduleOptions;
-  }
-  if (config.manifestVersion !== 3) {
-    delete options.type;
-  }
-  return {
-    type: "background",
-    name,
-    inputPath,
-    outputDir: config.outDir,
-    options: {
-      ...options,
-      type: resolvePerBrowserOption(options.type, config.browser),
-      persistent: resolvePerBrowserOption(options.persistent, config.browser)
-    },
-    skipped
-  };
-}
-async function getContentScriptEntrypoint(config, { inputPath, name, skipped }) {
-  const { main: _, ...options } = await importEntrypointFile(inputPath, config);
-  if (options == null) {
-    throw Error(
-      `${name}: Default export not found, did you forget to call "export default defineContentScript(...)"?`
-    );
-  }
-  return {
-    type: "content-script",
-    name,
-    inputPath,
-    outputDir: resolve13(config.outDir, CONTENT_SCRIPT_OUT_DIR),
-    options,
-    skipped
-  };
-}
-var PATH_GLOB_TO_TYPE_MAP = {
-  "sandbox.html": "sandbox",
-  "sandbox/index.html": "sandbox",
-  "*.sandbox.html": "sandbox",
-  "*.sandbox/index.html": "sandbox",
-  "bookmarks.html": "bookmarks",
-  "bookmarks/index.html": "bookmarks",
-  "history.html": "history",
-  "history/index.html": "history",
-  "newtab.html": "newtab",
-  "newtab/index.html": "newtab",
-  "sidepanel.html": "sidepanel",
-  "sidepanel/index.html": "sidepanel",
-  "*.sidepanel.html": "sidepanel",
-  "*.sidepanel/index.html": "sidepanel",
-  "devtools.html": "devtools",
-  "devtools/index.html": "devtools",
-  "background.[jt]s": "background",
-  "background/index.[jt]s": "background",
-  [VIRTUAL_NOOP_BACKGROUND_MODULE_ID]: "background",
-  "content.[jt]s?(x)": "content-script",
-  "content/index.[jt]s?(x)": "content-script",
-  "*.content.[jt]s?(x)": "content-script",
-  "*.content/index.[jt]s?(x)": "content-script",
-  [`content.${CSS_EXTENSIONS_PATTERN}`]: "content-script-style",
-  [`*.content.${CSS_EXTENSIONS_PATTERN}`]: "content-script-style",
-  [`content/index.${CSS_EXTENSIONS_PATTERN}`]: "content-script-style",
-  [`*.content/index.${CSS_EXTENSIONS_PATTERN}`]: "content-script-style",
-  "popup.html": "popup",
-  "popup/index.html": "popup",
-  "options.html": "options",
-  "options/index.html": "options",
-  "*.html": "unlisted-page",
-  "*/index.html": "unlisted-page",
-  "*.[jt]s?(x)": "unlisted-script",
-  "*/index.[jt]s?(x)": "unlisted-script",
-  [`*.${CSS_EXTENSIONS_PATTERN}`]: "unlisted-style",
-  [`*/index.${CSS_EXTENSIONS_PATTERN}`]: "unlisted-style"
-};
-var CONTENT_SCRIPT_OUT_DIR = "content-scripts";
 
 export {
+  wxt,
+  registerWxt,
   detectDevChanges,
   getEntrypointBundlePath,
   resolvePerBrowserOption,
@@ -2796,7 +2872,7 @@ export {
   tsconfigPaths,
   globals,
   webextensionPolyfillMock,
-  getInternalConfig,
+  resolveConfig,
   kebabCaseAlphanumeric,
   printFileList,
   version,