wxt 0.17.4 → 0.17.6

package/dist/cli.js

@@ -13,21 +13,229 @@ import glob from "fast-glob";
 // src/core/utils/paths.ts
 import systemPath from "node:path";
 import normalize from "normalize-path";
-function normalizePath(path8) {
-  return normalize(path8);
+function normalizePath(path10) {
+  return normalize(path10);
 }
-function unnormalizePath(path8) {
-  return systemPath.normalize(path8);
+function unnormalizePath(path10) {
+  return systemPath.normalize(path10);
 }
 var CSS_EXTENSIONS = ["css", "scss", "sass", "less", "styl", "stylus"];
 var CSS_EXTENSIONS_PATTERN = `+(${CSS_EXTENSIONS.join("|")})`;
 
 // src/core/wxt.ts
 import { createHooks } from "hookable";
+
+// src/core/package-managers/index.ts
+import {
+  detectPackageManager,
+  addDependency,
+  addDevDependency,
+  ensureDependencyInstalled,
+  installDependencies,
+  removeDependency
+} from "nypm";
+
+// src/core/package-managers/npm.ts
+import path from "node:path";
+import { ensureDir } from "fs-extra";
+var npm = {
+  overridesKey: "overrides",
+  async downloadDependency(id, downloadDir) {
+    await ensureDir(downloadDir);
+    const { execa } = await import("./execa-Y2EWTC4S.js");
+    const res = await execa("npm", ["pack", id, "--json"], {
+      cwd: downloadDir
+    });
+    const packed = JSON.parse(res.stdout);
+    return path.resolve(downloadDir, packed[0].filename);
+  },
+  async listDependencies(options) {
+    const args = ["ls", "--json"];
+    if (options?.all) {
+      args.push("--depth", "Infinity");
+    }
+    const { execa } = await import("./execa-Y2EWTC4S.js");
+    const res = await execa("npm", args, { cwd: options?.cwd });
+    const project = JSON.parse(res.stdout);
+    return flattenNpmListOutput([project]);
+  }
+};
+function flattenNpmListOutput(projects) {
+  const queue = projects.flatMap(
+    (project) => {
+      const acc = [];
+      if (project.dependencies)
+        acc.push(project.dependencies);
+      if (project.devDependencies)
+        acc.push(project.devDependencies);
+      return acc;
+    }
+  );
+  const dependencies = [];
+  while (queue.length > 0) {
+    Object.entries(queue.pop()).forEach(([name, meta]) => {
+      dependencies.push({
+        name,
+        version: meta.version
+      });
+      if (meta.dependencies)
+        queue.push(meta.dependencies);
+      if (meta.devDependencies)
+        queue.push(meta.devDependencies);
+    });
+  }
+  return dedupeDependencies(dependencies);
+}
+function dedupeDependencies(dependencies) {
+  const hashes = /* @__PURE__ */ new Set();
+  return dependencies.filter((dep) => {
+    const hash = `${dep.name}@${dep.version}`;
+    if (hashes.has(hash)) {
+      return false;
+    } else {
+      hashes.add(hash);
+      return true;
+    }
+  });
+}
+
+// src/core/package-managers/bun.ts
+var bun = {
+  overridesKey: "overrides",
+  // But also supports "resolutions"
+  downloadDependency(...args) {
+    return npm.downloadDependency(...args);
+  },
+  async listDependencies(options) {
+    const args = ["pm", "ls"];
+    if (options?.all) {
+      args.push("--all");
+    }
+    const { execa } = await import("./execa-Y2EWTC4S.js");
+    const res = await execa("bun", args, { cwd: options?.cwd });
+    return dedupeDependencies(
+      res.stdout.split("\n").slice(1).map((line) => line.trim()).map((line) => /.* (@?\S+)@(\S+)$/.exec(line)).filter((match) => !!match).map(([_, name, version2]) => ({ name, version: version2 }))
+    );
+  }
+};
+
+// src/core/package-managers/yarn.ts
+var yarn = {
+  overridesKey: "resolutions",
+  downloadDependency(...args) {
+    return npm.downloadDependency(...args);
+  },
+  async listDependencies(options) {
+    const args = ["list", "--json"];
+    if (options?.all) {
+      args.push("--depth", "Infinity");
+    }
+    const { execa } = await import("./execa-Y2EWTC4S.js");
+    const res = await execa("yarn", args, { cwd: options?.cwd });
+    const tree = res.stdout.split("\n").map((line) => JSON.parse(line)).find((line) => line.type === "tree")?.data;
+    if (tree == null)
+      throw Error("'yarn list --json' did not output a tree");
+    const queue = [...tree.trees];
+    const dependencies = [];
+    while (queue.length > 0) {
+      const { name: treeName, children } = queue.pop();
+      const match = /(@?\S+)@(\S+)$/.exec(treeName);
+      if (match) {
+        const [_, name, version2] = match;
+        dependencies.push({ name, version: version2 });
+      }
+      if (children != null) {
+        queue.push(...children);
+      }
+    }
+    return dedupeDependencies(dependencies);
+  }
+};
+
+// src/core/package-managers/pnpm.ts
+var pnpm = {
+  overridesKey: "resolutions",
+  // "pnpm.overrides" has a higher priority, but I don't want to deal with nesting
+  downloadDependency(...args) {
+    return npm.downloadDependency(...args);
+  },
+  async listDependencies(options) {
+    const args = ["ls", "-r", "--json"];
+    if (options?.all) {
+      args.push("--depth", "Infinity");
+    }
+    if (typeof process !== "undefined" && process.env.WXT_PNPM_IGNORE_WORKSPACE === "true") {
+      args.push("--ignore-workspace");
+    }
+    const { execa } = await import("./execa-Y2EWTC4S.js");
+    const res = await execa("pnpm", args, { cwd: options?.cwd });
+    const projects = JSON.parse(res.stdout);
+    return flattenNpmListOutput(projects);
+  }
+};
+
+// src/core/package-managers/index.ts
+async function createWxtPackageManager(root) {
+  const pm = await detectPackageManager(root, {
+    includeParentDirs: true
+  });
+  const requirePm = (cb) => {
+    if (pm == null)
+      throw Error("Could not detect package manager");
+    return cb(pm);
+  };
+  return {
+    get name() {
+      return requirePm((pm2) => pm2.name);
+    },
+    get command() {
+      return requirePm((pm2) => pm2.command);
+    },
+    get version() {
+      return requirePm((pm2) => pm2.version);
+    },
+    get majorVersion() {
+      return requirePm((pm2) => pm2.majorVersion);
+    },
+    get lockFile() {
+      return requirePm((pm2) => pm2.lockFile);
+    },
+    get files() {
+      return requirePm((pm2) => pm2.files);
+    },
+    addDependency,
+    addDevDependency,
+    ensureDependencyInstalled,
+    installDependencies,
+    removeDependency,
+    get overridesKey() {
+      return requirePm((pm2) => packageManagers[pm2.name].overridesKey);
+    },
+    downloadDependency(...args) {
+      return requirePm(
+        (pm2) => packageManagers[pm2.name].downloadDependency(...args)
+      );
+    },
+    listDependencies(...args) {
+      return requirePm(
+        (pm2) => packageManagers[pm2.name].listDependencies(...args)
+      );
+    }
+  };
+}
+var packageManagers = {
+  npm,
+  pnpm,
+  bun,
+  yarn
+};
+
+// src/core/wxt.ts
 var wxt;
 async function registerWxt(command, inlineConfig = {}, server) {
   const config = await resolveConfig(inlineConfig, command, server);
   const hooks = createHooks();
+  const pm = await createWxtPackageManager(config.root);
   wxt = {
     config,
     hooks,
@@ -36,7 +244,8 @@ async function registerWxt(command, inlineConfig = {}, server) {
     },
     async reloadConfig() {
       wxt.config = await resolveConfig(inlineConfig, command, server);
-    }
+    },
+    pm
   };
   wxt.hooks.addHooks(config.hooks);
   await wxt.hooks.callHook("ready", wxt);
@@ -212,9 +421,9 @@ import JSON5 from "json5";
 import glob2 from "fast-glob";
 
 // src/core/utils/entrypoints.ts
-import path, { relative, resolve as resolve2 } from "node:path";
+import path2, { relative, resolve as resolve2 } from "node:path";
 function getEntrypointName(entrypointsDir, inputPath) {
-  const relativePath = path.relative(entrypointsDir, inputPath);
+  const relativePath = path2.relative(entrypointsDir, inputPath);
   const name = relativePath.split(/[\.\/\\]/, 2)[0];
   return name;
 }
@@ -258,7 +467,7 @@ async function findEntrypoints() {
     const inputPath = resolve3(wxt.config.entrypointsDir, relativePath);
     const name = getEntrypointName(wxt.config.entrypointsDir, inputPath);
     const matchingGlob = pathGlobs.find(
-      (glob5) => minimatch(relativePath, glob5)
+      (glob6) => minimatch(relativePath, glob6)
     );
     if (matchingGlob) {
       const type = PATH_GLOB_TO_TYPE_MAP[matchingGlob];
@@ -673,7 +882,7 @@ function getEntrypointGlobals(entrypointName) {
 }
 
 // src/core/utils/building/generate-wxt-dir.ts
-import path2 from "node:path";
+import path3 from "node:path";
 
 // src/core/utils/i18n.ts
 var predefinedMessages = {
@@ -756,7 +965,7 @@ async function writePathsDeclarationFile(entrypoints) {
       wxt.config.outDir,
       isHtmlEntrypoint(entry) ? ".html" : ".js"
     )
-  ).concat(await getPublicFiles()).map(normalizePath).map((path8) => `    | "/${path8}"`).sort().join("\n");
+  ).concat(await getPublicFiles()).map(normalizePath).map((path10) => `    | "/${path10}"`).sort().join("\n");
   const template = `// Generated by wxt
 import "wxt/browser";
 
@@ -800,7 +1009,7 @@ declare module "wxt/browser" {
 `;
   let messages;
   if (defaultLocale) {
-    const defaultLocalePath = path2.resolve(
+    const defaultLocalePath = path3.resolve(
       wxt.config.publicDir,
       "_locales",
       defaultLocale,
@@ -864,7 +1073,7 @@ async function writeMainDeclarationFile(references) {
 }
 async function writeTsConfigFile(mainReference) {
   const dir = wxt.config.wxtDir;
-  const getTsconfigPath = (path8) => normalizePath(relative3(dir, path8));
+  const getTsconfigPath = (path10) => normalizePath(relative3(dir, path10));
   const paths = Object.entries(wxt.config.alias).flatMap(([alias, absolutePath]) => {
     const aliasPath = getTsconfigPath(absolutePath);
     return [
@@ -900,23 +1109,23 @@ ${paths}
 
 // src/core/utils/building/resolve-config.ts
 import { loadConfig } from "c12";
-import path4 from "node:path";
+import path5 from "node:path";
 
 // src/core/utils/cache.ts
-import fs5, { ensureDir } from "fs-extra";
+import fs5, { ensureDir as ensureDir2 } from "fs-extra";
 import { dirname as dirname2, resolve as resolve5 } from "path";
 function createFsCache(wxtDir) {
   const getPath = (key) => resolve5(wxtDir, "cache", encodeURIComponent(key));
   return {
     async set(key, value) {
-      const path8 = getPath(key);
-      await ensureDir(dirname2(path8));
-      await writeFileIfDifferent(path8, value);
+      const path10 = getPath(key);
+      await ensureDir2(dirname2(path10));
+      await writeFileIfDifferent(path10, value);
     },
     async get(key) {
-      const path8 = getPath(key);
+      const path10 = getPath(key);
       try {
-        return await fs5.readFile(path8, "utf-8");
+        return await fs5.readFile(path10, "utf-8");
       } catch {
         return void 0;
       }
@@ -1050,10 +1259,10 @@ function pointToDevServer(config, server, id, document, querySelector, attr) {
         relative4(config.root, resolvedAbsolutePath)
       );
       if (relativePath.startsWith(".")) {
-        let path8 = normalizePath(resolvedAbsolutePath);
-        if (!path8.startsWith("/"))
-          path8 = "/" + path8;
-        element.setAttribute(attr, `${server.origin}/@fs${path8}`);
+        let path10 = normalizePath(resolvedAbsolutePath);
+        if (!path10.startsWith("/"))
+          path10 = "/" + path10;
+        element.setAttribute(attr, `${server.origin}/@fs${path10}`);
       } else {
         const url = new URL(relativePath, server.origin);
         element.setAttribute(attr, url.href);
@@ -1168,7 +1377,7 @@ function download(config) {
 
 // src/core/builders/vite/plugins/multipageMove.ts
 import { dirname as dirname4, extname, resolve as resolve7, join } from "node:path";
-import fs6, { ensureDir as ensureDir2 } from "fs-extra";
+import fs6, { ensureDir as ensureDir3 } from "fs-extra";
 function multipageMove(entrypoints, config) {
   return {
     name: "wxt:multipage-move",
@@ -1197,7 +1406,7 @@ function multipageMove(entrypoints, config) {
         }
         const oldAbsPath = resolve7(config.outDir, oldBundlePath);
         const newAbsPath = resolve7(config.outDir, newBundlePath);
-        await ensureDir2(dirname4(newAbsPath));
+        await ensureDir3(dirname4(newAbsPath));
         await fs6.move(oldAbsPath, newAbsPath, { overwrite: true });
         const renamedChunk = {
           ...bundle[oldBundlePath],
@@ -1347,12 +1556,12 @@ function cssEntrypoints(entrypoint, config) {
 
 // src/core/builders/vite/plugins/bundleAnalysis.ts
 import { visualizer } from "@aklinker1/rollup-plugin-visualizer";
-import path3 from "node:path";
+import path4 from "node:path";
 var increment = 0;
 function bundleAnalysis(config) {
   return visualizer({
     template: "raw-data",
-    filename: path3.resolve(
+    filename: path4.resolve(
       config.analysis.outputDir,
       `${config.analysis.outputName}-${increment++}.json`
     )
@@ -1672,6 +1881,7 @@ function isModuleInstalled(name) {
 }
 
 // src/core/utils/building/resolve-config.ts
+import fs9 from "fs-extra";
 async function resolveConfig(inlineConfig, command, server) {
   let userConfig = {};
   let userConfigMetadata;
@@ -1697,21 +1907,27 @@ async function resolveConfig(inlineConfig, command, server) {
   const manifestVersion = mergedConfig.manifestVersion ?? (browser === "firefox" || browser === "safari" ? 2 : 3);
   const mode = mergedConfig.mode ?? (command === "build" ? "production" : "development");
   const env = { browser, command, manifestVersion, mode };
-  const root = path4.resolve(
+  const root = path5.resolve(
     inlineConfig.root ?? userConfig.root ?? process.cwd()
   );
-  const wxtDir = path4.resolve(root, ".wxt");
+  const wxtDir = path5.resolve(root, ".wxt");
   const wxtModuleDir = await resolveWxtModuleDir();
-  const srcDir = path4.resolve(root, mergedConfig.srcDir ?? root);
-  const entrypointsDir = path4.resolve(
+  const srcDir = path5.resolve(root, mergedConfig.srcDir ?? root);
+  const entrypointsDir = path5.resolve(
     srcDir,
     mergedConfig.entrypointsDir ?? "entrypoints"
   );
+  if (await isDirMissing(entrypointsDir)) {
+    logMissingDir(logger, "Entrypoints", entrypointsDir);
+  }
   const filterEntrypoints = !!mergedConfig.filterEntrypoints?.length ? new Set(mergedConfig.filterEntrypoints) : void 0;
-  const publicDir = path4.resolve(srcDir, mergedConfig.publicDir ?? "public");
-  const typesDir = path4.resolve(wxtDir, "types");
-  const outBaseDir = path4.resolve(root, mergedConfig.outDir ?? ".output");
-  const outDir = path4.resolve(outBaseDir, `${browser}-mv${manifestVersion}`);
+  const publicDir = path5.resolve(srcDir, mergedConfig.publicDir ?? "public");
+  if (await isDirMissing(publicDir)) {
+    logMissingDir(logger, "Public", publicDir);
+  }
+  const typesDir = path5.resolve(wxtDir, "types");
+  const outBaseDir = path5.resolve(root, mergedConfig.outDir ?? ".output");
+  const outDir = path5.resolve(outBaseDir, `${browser}-mv${manifestVersion}`);
   const reloadCommand = mergedConfig.dev?.reloadCommand ?? "Alt+R";
   const runnerConfig = await loadConfig({
     name: "web-ext",
@@ -1728,14 +1944,14 @@ async function resolveConfig(inlineConfig, command, server) {
       "~": srcDir,
       "@@": root,
       "~~": root
-    }).map(([key, value]) => [key, path4.resolve(root, value)])
+    }).map(([key, value]) => [key, path5.resolve(root, value)])
   );
-  const analysisOutputFile = path4.resolve(
+  const analysisOutputFile = path5.resolve(
     root,
     mergedConfig.analysis?.outputFile ?? "stats.html"
   );
-  const analysisOutputDir = path4.dirname(analysisOutputFile);
-  const analysisOutputName = path4.parse(analysisOutputFile).name;
+  const analysisOutputDir = path5.dirname(analysisOutputFile);
+  const analysisOutputName = path5.parse(analysisOutputFile).name;
   const finalConfig = {
     browser,
     command,
@@ -1860,6 +2076,7 @@ function mergeInlineConfig(inlineConfig, userConfig) {
   };
 }
 function resolveInternalZipConfig(root, mergedConfig) {
+  const downloadedPackagesDir = path5.resolve(root, ".wxt/local_modules");
   return {
     name: void 0,
     sourcesTemplate: "{{name}}-{{version}}-sources.zip",
@@ -1878,7 +2095,9 @@ function resolveInternalZipConfig(root, mergedConfig) {
       "**/*.+(test|spec).?(c|m)+(j|t)s?(x)",
       // From user
       ...mergedConfig.zip?.excludeSources ?? []
-    ]
+    ],
+    downloadPackages: mergedConfig.zip?.downloadPackages ?? [],
+    downloadedPackagesDir
   };
 }
 async function getUnimportOptions(wxtDir, logger, config) {
@@ -1910,7 +2129,7 @@ async function getUnimportOptions(wxtDir, logger, config) {
     dirs: ["components", "composables", "hooks", "utils"],
     eslintrc: {
       enabled,
-      filePath: path4.resolve(wxtDir, "eslintrc-auto-import.json"),
+      filePath: path5.resolve(wxtDir, "eslintrc-auto-import.json"),
       globalsPropValue: true
     }
   };
@@ -1921,7 +2140,17 @@ async function getUnimportOptions(wxtDir, logger, config) {
 }
 async function resolveWxtModuleDir() {
   const requireResolve = __require?.resolve ?? (await import("node:module")).default.createRequire(import.meta.url).resolve;
-  return path4.resolve(requireResolve("wxt"), "../..");
+  return path5.resolve(requireResolve("wxt"), "../..");
+}
+async function isDirMissing(dir) {
+  return !await fs9.exists(dir);
+}
+function logMissingDir(logger, name, expected) {
+  logger.warn(
+    `${name} directory not found: ./${normalizePath(
+      path5.relative(process.cwd(), expected)
+    )}`
+  );
 }
 
 // src/core/utils/building/group-entrypoints.ts
@@ -1966,7 +2195,7 @@ var ENTRY_TYPE_TO_GROUP_MAP = {
 // src/core/utils/building/import-entrypoint.ts
 import createJITI from "jiti";
 import { createUnimport as createUnimport3 } from "unimport";
-import fs9 from "fs-extra";
+import fs10 from "fs-extra";
 import { relative as relative5, resolve as resolve10 } from "node:path";
 
 // src/core/utils/strings.ts
@@ -1989,16 +2218,16 @@ ${noImports}`;
 // src/core/utils/building/import-entrypoint.ts
 import { transformSync } from "esbuild";
 import { fileURLToPath } from "node:url";
-async function importEntrypointFile(path8) {
-  wxt.logger.debug("Loading file metadata:", path8);
-  const normalPath = normalizePath(path8);
+async function importEntrypointFile(path10) {
+  wxt.logger.debug("Loading file metadata:", path10);
+  const normalPath = normalizePath(path10);
   const unimport2 = createUnimport3({
     ...wxt.config.imports,
     // Only allow specific imports, not all from the project
     dirs: []
   });
   await unimport2.init();
-  const text = await fs9.readFile(path8, "utf-8");
+  const text = await fs10.readFile(path10, "utf-8");
   const textNoImports = removeProjectImportStatements(text);
   const { code } = await unimport2.injectImports(textNoImports);
   wxt.logger.debug(
@@ -2041,10 +2270,10 @@ async function importEntrypointFile(path8) {
     }
   );
   try {
-    const res = await jiti(path8);
+    const res = await jiti(path10);
     return res.default;
   } catch (err) {
-    const filePath = relative5(wxt.config.root, path8);
+    const filePath = relative5(wxt.config.root, path10);
     if (err instanceof ReferenceError) {
       const variableName = err.message.replace(" is not defined", "");
       throw Error(
@@ -2073,15 +2302,15 @@ function getEsbuildOptions(opts) {
 
 // src/core/utils/building/internal-build.ts
 import pc5 from "picocolors";
-import fs12 from "fs-extra";
+import fs13 from "fs-extra";
 
 // src/core/utils/log/printBuildSummary.ts
 import { resolve as resolve11 } from "path";
 
 // src/core/utils/log/printFileList.ts
-import path5 from "node:path";
+import path6 from "node:path";
 import pc3 from "picocolors";
-import fs10 from "fs-extra";
+import fs11 from "fs-extra";
 import { filesize } from "filesize";
 
 // src/core/utils/log/printTable.ts
@@ -2117,12 +2346,12 @@ async function printFileList(log, header, baseDir, files) {
   const fileRows = await Promise.all(
     files.map(async (file, i) => {
       const parts = [
-        path5.relative(process.cwd(), baseDir) + path5.sep,
-        path5.relative(baseDir, file)
+        path6.relative(process.cwd(), baseDir) + path6.sep,
+        path6.relative(baseDir, file)
       ];
       const prefix = i === files.length - 1 ? "  \u2514\u2500" : "  \u251C\u2500";
       const color = getChunkColor(file);
-      const stats = await fs10.lstat(file);
+      const stats = await fs11.lstat(file);
       totalSize += stats.size;
       const size = String(filesize(stats.size));
       return [
@@ -2186,7 +2415,7 @@ function getChunkSortWeight(filename) {
 import pc4 from "picocolors";
 
 // package.json
-var version = "0.17.4";
+var version = "0.17.6";
 
 // src/core/utils/log/printHeader.ts
 import { consola as consola2 } from "consola";
@@ -2199,7 +2428,7 @@ function printHeader() {
 import glob3 from "fast-glob";
 
 // src/core/utils/manifest.ts
-import fs11 from "fs-extra";
+import fs12 from "fs-extra";
 import { resolve as resolve12 } from "path";
 
 // src/core/utils/content-security-policy.ts
@@ -2310,7 +2539,7 @@ function mapWxtOptionsToRegisteredContentScript(options, js, css) {
 import defu2 from "defu";
 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 fs12.ensureDir(wxt.config.outDir);
   await writeFileIfDifferent(resolve12(wxt.config.outDir, "manifest.json"), str);
   output.publicAssets.unshift({
     type: "asset",
@@ -2366,11 +2595,14 @@ async function generateManifest(entrypoints, buildOutput) {
     addDevModePermissions(manifest);
   wxt.config.transformManifest(manifest);
   await wxt.hooks.callHook("build:manifestGenerated", wxt, manifest);
-  if (wxt.config.manifestVersion === 2)
+  if (wxt.config.manifestVersion === 2) {
     convertWebAccessibleResourcesToMv2(manifest);
+    convertActionToMv2(manifest);
+  }
   if (wxt.config.manifestVersion === 3) {
     validateMv3WebAccessbileResources(manifest);
   }
+  stripKeys(manifest);
   if (manifest.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"
@@ -2746,6 +2978,11 @@ function convertWebAccessibleResourcesToMv2(manifest) {
     )
   );
 }
+function convertActionToMv2(manifest) {
+  if (manifest.action == null || manifest.browser_action != null || manifest.page_action != null)
+    return;
+  manifest.browser_action = manifest.action;
+}
 function validateMv3WebAccessbileResources(manifest) {
   if (manifest.web_accessible_resources == null)
     return;
@@ -2760,6 +2997,46 @@ function validateMv3WebAccessbileResources(manifest) {
     );
   }
 }
+function stripKeys(manifest) {
+  let keysToRemove = [];
+  if (wxt.config.manifestVersion === 2) {
+    keysToRemove.push(...mv3OnlyKeys);
+    if (wxt.config.browser === "firefox")
+      keysToRemove.push(...firefoxMv3OnlyKeys);
+  } else {
+    keysToRemove.push(...mv2OnlyKeys);
+  }
+  keysToRemove.forEach((key) => {
+    delete manifest[key];
+  });
+}
+var mv2OnlyKeys = [
+  "page_action",
+  "browser_action",
+  "automation",
+  "content_capabilities",
+  "converted_from_user_script",
+  "current_locale",
+  "differential_fingerprint",
+  "event_rules",
+  "file_browser_handlers",
+  "file_system_provider_capabilities",
+  "input_components",
+  "nacl_modules",
+  "natively_connectable",
+  "offline_enabled",
+  "platforms",
+  "replacement_web_app",
+  "system_indicator",
+  "user_scripts"
+];
+var mv3OnlyKeys = [
+  "action",
+  "export",
+  "optional_host_permissions",
+  "side_panel"
+];
+var firefoxMv3OnlyKeys = ["host_permissions"];
 
 // src/core/utils/building/rebuild.ts
 async function rebuild(allEntrypoints, entrypointGroups, existingOutput = {
@@ -2874,8 +3151,8 @@ async function internalBuild() {
     )}`
   );
   const startTime = Date.now();
-  await fs12.rm(wxt.config.outDir, { recursive: true, force: true });
-  await fs12.ensureDir(wxt.config.outDir);
+  await fs13.rm(wxt.config.outDir, { recursive: true, force: true });
+  await fs13.ensureDir(wxt.config.outDir);
   const entrypoints = await findEntrypoints();
   wxt.logger.debug("Detected entrypoints:", entrypoints);
   const validationResults = validateEntrypoints(entrypoints);
@@ -2921,7 +3198,7 @@ async function combineAnalysisStats() {
     filename: wxt.config.analysis.outputFile
   });
   if (!wxt.config.analysis.keepArtifacts) {
-    await Promise.all(absolutePaths.map((statsFile) => fs12.remove(statsFile)));
+    await Promise.all(absolutePaths.map((statsFile) => fs13.remove(statsFile)));
   }
 }
 function printValidationResults({
@@ -2958,9 +3235,9 @@ async function build(config) {
 }
 
 // src/core/clean.ts
-import path6 from "node:path";
+import path7 from "node:path";
 import glob4 from "fast-glob";
-import fs13 from "fs-extra";
+import fs14 from "fs-extra";
 import { consola as consola4 } from "consola";
 import pc6 from "picocolors";
 async function clean(root = process.cwd()) {
@@ -2973,7 +3250,7 @@ async function clean(root = process.cwd()) {
   ];
   consola4.debug("Looking for:", tempDirs.map(pc6.cyan).join(", "));
   const directories = await glob4(tempDirs, {
-    cwd: path6.resolve(root),
+    cwd: path7.resolve(root),
     absolute: true,
     onlyDirectories: true,
     deep: 2
@@ -2984,11 +3261,11 @@ async function clean(root = process.cwd()) {
   }
   consola4.debug(
     "Found:",
-    directories.map((dir) => pc6.cyan(path6.relative(root, dir))).join(", ")
+    directories.map((dir) => pc6.cyan(path7.relative(root, dir))).join(", ")
   );
   for (const directory of directories) {
-    await fs13.rm(directory, { force: true, recursive: true });
-    consola4.debug("Deleted " + pc6.cyan(path6.relative(root, directory)));
+    await fs14.rm(directory, { force: true, recursive: true });
+    consola4.debug("Deleted " + pc6.cyan(path7.relative(root, directory)));
   }
 }
 
@@ -3192,8 +3469,8 @@ async function createServer(inlineConfig) {
     reloadContentScript(payload) {
       server.ws.send("wxt:reload-content-script", payload);
     },
-    reloadPage(path8) {
-      server.ws.send("wxt:reload-page", path8);
+    reloadPage(path10) {
+      server.ws.send("wxt:reload-page", path10);
     },
     reloadExtension() {
       server.ws.send("wxt:reload-extension");
@@ -3224,11 +3501,11 @@ async function getPort() {
 function createFileReloader(server) {
   const fileChangedMutex = new Mutex();
   const changeQueue = [];
-  return async (event, path8) => {
+  return async (event, path10) => {
     await wxt.reloadConfig();
-    if (path8.startsWith(wxt.config.outBaseDir))
+    if (path10.startsWith(wxt.config.outBaseDir))
       return;
-    changeQueue.push([event, path8]);
+    changeQueue.push([event, path10]);
     await fileChangedMutex.runExclusive(async () => {
       if (server.currentOutput == null)
         return;
@@ -3307,8 +3584,8 @@ function reloadContentScripts(steps, server) {
 function reloadHtmlPages(groups, server) {
   const htmlEntries = groups.flat().filter(isHtmlEntrypoint);
   htmlEntries.forEach((entry) => {
-    const path8 = getEntrypointBundlePath(entry, wxt.config.outDir, ".html");
-    server.reloadPage(path8);
+    const path10 = getEntrypointBundlePath(entry, wxt.config.outDir, ".html");
+    server.reloadPage(path10);
   });
   return {
     reloadedNames: htmlEntries.map((entry) => entry.name)
@@ -3338,8 +3615,8 @@ function getExternalOutputDependencies(server) {
 import prompts from "prompts";
 import { consola as consola6 } from "consola";
 import { downloadTemplate } from "giget";
-import fs14 from "fs-extra";
-import path7 from "node:path";
+import fs15 from "fs-extra";
+import path8 from "node:path";
 import pc8 from "picocolors";
 async function initialize(options) {
   consola6.info("Initalizing new project");
@@ -3387,7 +3664,7 @@ async function initialize(options) {
   input.template ??= defaultTemplate;
   input.packageManager ??= options.packageManager;
   await cloneProject(input);
-  const cdPath = path7.relative(process.cwd(), path7.resolve(input.directory));
+  const cdPath = path8.relative(process.cwd(), path8.resolve(input.directory));
   console.log();
   consola6.log(
     `\u2728 WXT project created with the ${TEMPLATE_COLORS[input.template.name]?.(input.template.name) ?? input.template.name} template.`
@@ -3430,9 +3707,9 @@ async function cloneProject({
       dir: directory,
       force: true
     });
-    await fs14.move(
-      path7.join(directory, "_gitignore"),
-      path7.join(directory, ".gitignore")
+    await fs15.move(
+      path8.join(directory, "_gitignore"),
+      path8.join(directory, ".gitignore")
     ).catch(
       (err) => consola6.warn("Failed to move _gitignore to .gitignore:", err)
     );
@@ -3464,10 +3741,11 @@ async function prepare(config) {
 }
 
 // src/core/zip.ts
-import zipdir from "zip-dir";
-import { dirname as dirname5, relative as relative11, resolve as resolve13 } from "node:path";
-import fs15 from "fs-extra";
+import path9 from "node:path";
+import fs16 from "fs-extra";
 import { minimatch as minimatch2 } from "minimatch";
+import JSZip from "jszip";
+import glob5 from "fast-glob";
 async function zip(config) {
   await registerWxt("build", config);
   const output = await internalBuild();
@@ -3475,32 +3753,33 @@ async function zip(config) {
   wxt.logger.info("Zipping extension...");
   const zipFiles = [];
   const projectName = wxt.config.zip.name ?? kebabCaseAlphanumeric(
-    (await getPackageJson())?.name || dirname5(process.cwd())
+    (await getPackageJson())?.name || path9.dirname(process.cwd())
   );
   const applyTemplate = (template) => template.replaceAll("{{name}}", projectName).replaceAll("{{browser}}", wxt.config.browser).replaceAll(
     "{{version}}",
     output.manifest.version_name ?? output.manifest.version
   ).replaceAll("{{manifestVersion}}", `mv${wxt.config.manifestVersion}`);
-  await fs15.ensureDir(wxt.config.outBaseDir);
+  await fs16.ensureDir(wxt.config.outBaseDir);
   const outZipFilename = applyTemplate(wxt.config.zip.artifactTemplate);
-  const outZipPath = resolve13(wxt.config.outBaseDir, outZipFilename);
-  await zipdir(wxt.config.outDir, {
-    saveTo: outZipPath
-  });
+  const outZipPath = path9.resolve(wxt.config.outBaseDir, outZipFilename);
+  await zipDir(wxt.config.outDir, outZipPath);
   zipFiles.push(outZipPath);
   if (wxt.config.browser === "firefox") {
+    const { overrides, files: downloadedPackages } = await downloadPrivatePackages();
     const sourcesZipFilename = applyTemplate(wxt.config.zip.sourcesTemplate);
-    const sourcesZipPath = resolve13(wxt.config.outBaseDir, sourcesZipFilename);
-    await zipdir(wxt.config.zip.sourcesRoot, {
-      saveTo: sourcesZipPath,
-      filter(path8) {
-        const relativePath = relative11(wxt.config.zip.sourcesRoot, path8);
-        return wxt.config.zip.includeSources.some(
-          (pattern) => minimatch2(relativePath, pattern)
-        ) || !wxt.config.zip.excludeSources.some(
-          (pattern) => minimatch2(relativePath, pattern)
-        );
-      }
+    const sourcesZipPath = path9.resolve(
+      wxt.config.outBaseDir,
+      sourcesZipFilename
+    );
+    await zipDir(wxt.config.zip.sourcesRoot, sourcesZipPath, {
+      include: wxt.config.zip.includeSources,
+      exclude: wxt.config.zip.excludeSources,
+      transform(file, content) {
+        if (file.endsWith("package.json")) {
+          return addOverridesToPackageJson(content, overrides);
+        }
+      },
+      additionalFiles: downloadedPackages
     });
     zipFiles.push(sourcesZipPath);
   }
@@ -3512,6 +3791,81 @@ async function zip(config) {
   );
   return zipFiles;
 }
+async function zipDir(directory, outputPath, options) {
+  const archive = new JSZip();
+  const files = (await glob5("**/*", {
+    cwd: directory,
+    // Ignore node_modules, otherwise this glob step takes forever
+    ignore: ["**/node_modules"],
+    onlyFiles: true
+  })).filter((relativePath) => {
+    return wxt.config.zip.includeSources.some(
+      (pattern) => minimatch2(relativePath, pattern)
+    ) || !wxt.config.zip.excludeSources.some(
+      (pattern) => minimatch2(relativePath, pattern)
+    );
+  });
+  const filesToZip = [
+    ...files,
+    ...(options?.additionalFiles ?? []).map(
+      (file) => path9.relative(directory, file)
+    )
+  ];
+  for (const file of filesToZip) {
+    const absolutePath = path9.resolve(directory, file);
+    if (file.endsWith(".json")) {
+      const content = await fs16.readFile(absolutePath, "utf-8");
+      archive.file(
+        file,
+        await options?.transform?.(file, content) || content
+      );
+    } else {
+      const content = await fs16.readFile(absolutePath);
+      archive.file(file, content);
+    }
+  }
+  await options?.additionalWork?.(archive);
+  const buffer = await archive.generateAsync({ type: "base64" });
+  await fs16.writeFile(outputPath, buffer, "base64");
+}
+async function downloadPrivatePackages() {
+  const overrides = {};
+  const files = [];
+  if (wxt.config.zip.downloadPackages.length > 0) {
+    const _downloadPackages = new Set(wxt.config.zip.downloadPackages);
+    const allPackages = await wxt.pm.listDependencies({
+      all: true,
+      cwd: wxt.config.root
+    });
+    const downloadPackages = allPackages.filter(
+      (pkg) => _downloadPackages.has(pkg.name)
+    );
+    for (const pkg of downloadPackages) {
+      wxt.logger.info(`Downloading package: ${pkg.name}@${pkg.version}`);
+      const id = `${pkg.name}@${pkg.version}`;
+      const tgzPath = await wxt.pm.downloadDependency(
+        id,
+        wxt.config.zip.downloadedPackagesDir
+      );
+      files.push(tgzPath);
+      overrides[id] = "file://./" + normalizePath(path9.relative(wxt.config.root, tgzPath));
+    }
+  }
+  return { overrides, files };
+}
+function addOverridesToPackageJson(content, overrides) {
+  if (Object.keys(overrides).length === 0)
+    return content;
+  const oldPackage = JSON.parse(content);
+  const newPackage = {
+    ...oldPackage,
+    [wxt.pm.overridesKey]: {
+      ...oldPackage[wxt.pm.overridesKey],
+      ...overrides
+    }
+  };
+  return JSON.stringify(newPackage, null, 2);
+}
 
 // src/cli/cli-utils.ts
 import consola7, { LogLevels as LogLevels2 } from "consola";