wxt 0.14.4 → 0.14.6

package/dist/index.cjs

@@ -130,12 +130,12 @@ var require_isexe = __commonJS({
         if (typeof Promise !== "function") {
           throw new TypeError("callback not provided");
         }
-        return new Promise(function(resolve14, reject) {
+        return new Promise(function(resolve15, reject) {
           isexe(path10, options || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
-              resolve14(is);
+              resolve15(is);
             }
           });
         });
@@ -202,27 +202,27 @@ var require_which = __commonJS({
         opt = {};
       const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
       const found = [];
-      const step = (i) => new Promise((resolve14, reject) => {
+      const step = (i) => new Promise((resolve15, reject) => {
         if (i === pathEnv.length)
-          return opt.all && found.length ? resolve14(found) : reject(getNotFoundError(cmd));
+          return opt.all && found.length ? resolve15(found) : reject(getNotFoundError(cmd));
         const ppRaw = pathEnv[i];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
         const pCmd = path10.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-        resolve14(subStep(p, i, 0));
+        resolve15(subStep(p, i, 0));
       });
-      const subStep = (p, i, ii) => new Promise((resolve14, reject) => {
+      const subStep = (p, i, ii) => new Promise((resolve15, reject) => {
         if (ii === pathExt.length)
-          return resolve14(step(i + 1));
+          return resolve15(step(i + 1));
         const ext = pathExt[ii];
         isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
           if (!er && is) {
             if (opt.all)
               found.push(p + ext);
             else
-              return resolve14(p + ext);
+              return resolve15(p + ext);
           }
-          return resolve14(subStep(p, i, ii + 1));
+          return resolve15(subStep(p, i, ii + 1));
         });
       });
       return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
@@ -1529,7 +1529,7 @@ var init_kill = __esm({
         return spawnedPromise;
       }
       let timeoutId;
-      const timeoutPromise = new Promise((resolve14, reject) => {
+      const timeoutPromise = new Promise((resolve15, reject) => {
         timeoutId = setTimeout(() => {
           timeoutKill(spawned, killSignal, reject);
         }, timeout);
@@ -2013,9 +2013,9 @@ var init_promise = __esm({
         Reflect.defineProperty(spawned, property, { ...descriptor, value });
       }
     };
-    getSpawnedPromise = (spawned) => new Promise((resolve14, reject) => {
+    getSpawnedPromise = (spawned) => new Promise((resolve15, reject) => {
       spawned.on("exit", (exitCode, signal) => {
-        resolve14({ exitCode, signal });
+        resolve15({ exitCode, signal });
       });
       spawned.on("error", (error) => {
         reject(error);
@@ -2497,11 +2497,27 @@ function every(array, predicate) {
       return false;
   return true;
 }
+function some(array, predicate) {
+  for (let i = 0; i < array.length; i++)
+    if (predicate(array[i], i))
+      return true;
+  return false;
+}
 
 // src/core/utils/building/detect-dev-changes.ts
-function detectDevChanges(changedFiles, currentOutput) {
-  if (currentOutput == null)
-    return { type: "no-change" };
+function detectDevChanges(config, changedFiles, currentOutput) {
+  const isConfigChange = some(
+    changedFiles,
+    (file) => file === config.userConfigMetadata.configFile
+  );
+  if (isConfigChange)
+    return { type: "full-restart" };
+  const isRunnerChange = some(
+    changedFiles,
+    (file) => file === config.runnerConfig.configFile
+  );
+  if (isRunnerChange)
+    return { type: "browser-restart" };
   const changedSteps = new Set(
     changedFiles.flatMap(
       (changedFile) => findEffectedSteps(changedFile, currentOutput)
@@ -2533,7 +2549,7 @@ function detectDevChanges(changedFiles, currentOutput) {
       unchangedOutput.publicAssets.push(asset);
     }
   }
-  const isOnlyHtmlChanges = changedFiles.length > 0 && every(changedFiles, ([_, file]) => file.endsWith(".html"));
+  const isOnlyHtmlChanges = changedFiles.length > 0 && every(changedFiles, (file) => file.endsWith(".html"));
   if (isOnlyHtmlChanges) {
     return {
       type: "html-reload",
@@ -2561,7 +2577,7 @@ function detectDevChanges(changedFiles, currentOutput) {
 }
 function findEffectedSteps(changedFile, currentOutput) {
   const changes = [];
-  const changedPath = normalizePath(changedFile[1]);
+  const changedPath = normalizePath(changedFile);
   const isChunkEffected = (chunk) => (
     // If it's an HTML file with the same path, is is effected because HTML files need to be pre-rendered
     // fileName is normalized, relative bundle path
@@ -3912,6 +3928,9 @@ async function createViteBuilder(inlineConfig, userConfig, wxtConfig) {
         async listen() {
           await viteServer.listen(info.port);
         },
+        async close() {
+          await viteServer.close();
+        },
         transformHtml(...args) {
           return viteServer.transformIndexHtml(...args);
         },
@@ -3977,6 +3996,7 @@ async function getInternalConfig(inlineConfig, command, server) {
   const typesDir = import_node_path7.default.resolve(wxtDir, "types");
   const outBaseDir = import_node_path7.default.resolve(root, mergedConfig.outDir ?? ".output");
   const outDir = import_node_path7.default.resolve(outBaseDir, `${browser}-mv${manifestVersion}`);
+  const reloadCommand = mergedConfig.dev?.reloadCommand ?? "Alt+R";
   const runnerConfig = await (0, import_c12.loadConfig)({
     name: "web-ext",
     cwd: root,
@@ -4029,7 +4049,10 @@ async function getInternalConfig(inlineConfig, command, server) {
     experimental: {
       includeBrowserPolyfill: mergedConfig.experimental?.includeBrowserPolyfill ?? true
     },
-    server
+    server,
+    dev: {
+      reloadCommand
+    }
   };
   const builder = await createViteBuilder(
     inlineConfig,
@@ -4096,7 +4119,11 @@ function mergeInlineConfig(inlineConfig, userConfig) {
       ...inlineConfig.experimental
     },
     vite: void 0,
-    transformManifest: void 0
+    transformManifest: void 0,
+    dev: {
+      ...userConfig.dev,
+      ...inlineConfig.dev
+    }
   };
 }
 function resolveInternalZipConfig(root, mergedConfig) {
@@ -4373,7 +4400,7 @@ function getChunkSortWeight(filename) {
 var import_picocolors4 = __toESM(require("picocolors"), 1);
 
 // package.json
-var version = "0.14.4";
+var version = "0.14.6";
 
 // src/core/utils/log/printHeader.ts
 var import_consola2 = require("consola");
@@ -4514,6 +4541,7 @@ async function writeManifest(manifest, output, config) {
   });
 }
 async function generateManifest(entrypoints, buildOutput, config) {
+  const warnings = [];
   const pkg = await getPackageJson(config);
   let versionName = config.manifest.version_name ?? config.manifest.version ?? pkg?.version;
   if (versionName == null) {
@@ -4531,21 +4559,26 @@ async function generateManifest(entrypoints, buildOutput, config) {
     short_name: pkg?.shortName,
     icons: discoverIcons(buildOutput)
   };
-  if (config.command === "serve") {
-    baseManifest.commands = {
-      "wxt:reload-extension": {
-        description: "Reload the extension during development",
-        suggested_key: {
-          default: "Alt+R"
-        }
-      }
-    };
-  }
   const userManifest = config.manifest;
   const manifest = (0, import_defu3.default)(
     userManifest,
     baseManifest
   );
+  if (config.command === "serve" && 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"
+      ]);
+    } else {
+      manifest.commands ??= {};
+      manifest.commands["wxt:reload-extension"] = {
+        description: "Reload the extension during development",
+        suggested_key: {
+          default: config.dev.reloadCommand
+        }
+      };
+    }
+  }
   manifest.version = version2;
   manifest.version_name = // Firefox doesn't support version_name
   config.browser === "firefox" || versionName === version2 ? void 0 : versionName;
@@ -4564,7 +4597,10 @@ async function generateManifest(entrypoints, buildOutput, config) {
       "Manifest 'version' is missing. Either:\n1. Add a version in your <rootDir>/package.json\n2. Pass the version via the manifest option in your wxt.config.ts"
     );
   }
-  return finalManifest;
+  return {
+    manifest: finalManifest,
+    warnings
+  };
 }
 function simplifyVersion(versionName) {
   const version2 = /^((0|[1-9][0-9]{0,8})([.](0|[1-9][0-9]{0,8})){0,3}).*$/.exec(
@@ -4925,11 +4961,7 @@ async function rebuild(config, allEntrypoints, entrypointGroups, existingOutput
     steps: [...existingOutput.steps, ...newOutput.steps],
     publicAssets: [...existingOutput.publicAssets, ...newOutput.publicAssets]
   };
-  const newManifest = await generateManifest(
-    allEntrypoints,
-    mergedOutput,
-    config
-  );
+  const { manifest: newManifest, warnings: manifestWarnings } = await generateManifest(allEntrypoints, mergedOutput, config);
   const finalOutput = {
     manifest: newManifest,
     ...newOutput
@@ -4945,11 +4977,76 @@ async function rebuild(config, allEntrypoints, entrypointGroups, existingOutput
         ...finalOutput.publicAssets
       ]
     },
-    manifest: newManifest
+    manifest: newManifest,
+    warnings: manifestWarnings
   };
 }
 
 // src/core/utils/building/internal-build.ts
+var import_manage_path = __toESM(require("manage-path"), 1);
+var import_node_path13 = require("path");
+
+// src/core/utils/validation.ts
+function validateEntrypoints(entrypoints) {
+  const errors = entrypoints.flatMap((entrypoint) => {
+    switch (entrypoint.type) {
+      case "content-script":
+        return validateContentScriptEntrypoint(entrypoint);
+      default:
+        return validateBaseEntrypoint(entrypoint);
+    }
+  });
+  let errorCount = 0;
+  let warningCount = 0;
+  for (const err of errors) {
+    if (err.type === "warning")
+      warningCount++;
+    else
+      errorCount++;
+  }
+  return {
+    errors,
+    errorCount,
+    warningCount
+  };
+}
+function validateContentScriptEntrypoint(definition) {
+  const errors = validateBaseEntrypoint(definition);
+  if (definition.options.matches == null) {
+    errors.push({
+      type: "error",
+      message: "`matches` is required",
+      value: definition.options.matches,
+      entrypoint: definition
+    });
+  }
+  return errors;
+}
+function validateBaseEntrypoint(definition) {
+  const errors = [];
+  if (definition.options.exclude != null && !Array.isArray(definition.options.exclude)) {
+    errors.push({
+      type: "error",
+      message: "`exclude` must be an array of browser names",
+      value: definition.options.exclude,
+      entrypoint: definition
+    });
+  }
+  if (definition.options.include != null && !Array.isArray(definition.options.include)) {
+    errors.push({
+      type: "error",
+      message: "`include` must be an array of browser names",
+      value: definition.options.include,
+      entrypoint: definition
+    });
+  }
+  return errors;
+}
+var ValidationError = class extends Error {
+};
+
+// src/core/utils/building/internal-build.ts
+var import_consola3 = __toESM(require("consola"), 1);
 async function internalBuild(config) {
   const verb = config.command === "serve" ? "Pre-rendering" : "Building";
   const target = `${config.browser}-mv${config.manifestVersion}`;
@@ -4963,14 +5060,31 @@ async function internalBuild(config) {
   await import_fs_extra12.default.ensureDir(config.outDir);
   const entrypoints = await findEntrypoints(config);
   config.logger.debug("Detected entrypoints:", entrypoints);
+  const validationResults = validateEntrypoints(entrypoints);
+  if (validationResults.errorCount + validationResults.warningCount > 0) {
+    printValidationResults(config, validationResults);
+  }
+  if (validationResults.errorCount > 0) {
+    throw new ValidationError(`Entrypoint validation failed`, {
+      cause: validationResults
+    });
+  }
   const groups = groupEntrypoints(entrypoints);
-  const { output } = await rebuild(config, entrypoints, groups, void 0);
+  const { output, warnings } = await rebuild(
+    config,
+    entrypoints,
+    groups,
+    void 0
+  );
   await printBuildSummary(
     config.logger.success,
     `Built extension in ${formatDuration(Date.now() - startTime)}`,
     output,
     config
   );
+  for (const warning of warnings) {
+    config.logger.warn(...warning);
+  }
   if (config.analysis.enabled) {
     await combineAnalysisStats(config);
     config.logger.info(
@@ -4987,11 +5101,35 @@ async function combineAnalysisStats(config) {
     absolute: true
   });
   const absolutePaths = unixFiles.map(unnormalizePath);
+  const alterPath = (0, import_manage_path.default)(process.env);
+  alterPath.push((0, import_node_path13.resolve)(config.root, "node_modules/wxt/node_modules/.bin"));
   await execaCommand2(
     `rollup-plugin-visualizer ${absolutePaths.join(" ")} --template ${config.analysis.template}`,
     { cwd: config.root, stdio: "inherit" }
   );
 }
+function printValidationResults(config, { errorCount, errors, warningCount }) {
+  (errorCount > 0 ? config.logger.error : config.logger.warn)(
+    `Entrypoint validation failed: ${errorCount} error${errorCount === 1 ? "" : "s"}, ${warningCount} warning${warningCount === 1 ? "" : "s"}`
+  );
+  const cwd = process.cwd();
+  const entrypointErrors = errors.reduce((map, error) => {
+    const entryErrors = map.get(error.entrypoint) ?? [];
+    entryErrors.push(error);
+    map.set(error.entrypoint, entryErrors);
+    return map;
+  }, /* @__PURE__ */ new Map());
+  Array.from(entrypointErrors.entries()).forEach(([entrypoint, errors2]) => {
+    import_consola3.default.log((0, import_node_path13.relative)(cwd, entrypoint.inputPath));
+    console.log();
+    errors2.forEach((err) => {
+      const type = err.type === "error" ? import_picocolors5.default.red("ERROR") : import_picocolors5.default.yellow("WARN");
+      const recieved = import_picocolors5.default.dim(`(recieved: ${JSON.stringify(err.value)})`);
+      import_consola3.default.log(`  - ${type} ${err.message} ${recieved}`);
+    });
+    console.log();
+  });
+}
 
 // src/core/build.ts
 async function build(config) {
@@ -5000,37 +5138,37 @@ async function build(config) {
 }
 
 // src/core/clean.ts
-var import_node_path13 = __toESM(require("path"), 1);
+var import_node_path14 = __toESM(require("path"), 1);
 var import_fast_glob4 = __toESM(require("fast-glob"), 1);
 var import_fs_extra13 = __toESM(require("fs-extra"), 1);
-var import_consola3 = require("consola");
+var import_consola4 = require("consola");
 var import_picocolors6 = __toESM(require("picocolors"), 1);
 async function clean(root = process.cwd()) {
-  import_consola3.consola.info("Cleaning Project");
+  import_consola4.consola.info("Cleaning Project");
   const tempDirs = [
     "node_modules/.vite",
     "node_modules/.cache",
     "**/.wxt",
     ".output/*"
   ];
-  import_consola3.consola.debug("Looking for:", tempDirs.map(import_picocolors6.default.cyan).join(", "));
+  import_consola4.consola.debug("Looking for:", tempDirs.map(import_picocolors6.default.cyan).join(", "));
   const directories = await (0, import_fast_glob4.default)(tempDirs, {
-    cwd: import_node_path13.default.resolve(root),
+    cwd: import_node_path14.default.resolve(root),
     absolute: true,
     onlyDirectories: true,
     deep: 2
   });
   if (directories.length === 0) {
-    import_consola3.consola.debug("No generated files found.");
+    import_consola4.consola.debug("No generated files found.");
     return;
   }
-  import_consola3.consola.debug(
+  import_consola4.consola.debug(
     "Found:",
-    directories.map((dir) => import_picocolors6.default.cyan(import_node_path13.default.relative(root, dir))).join(", ")
+    directories.map((dir) => import_picocolors6.default.cyan(import_node_path14.default.relative(root, dir))).join(", ")
   );
   for (const directory of directories) {
     await import_fs_extra13.default.rm(directory, { force: true, recursive: true });
-    import_consola3.consola.debug("Deleted " + import_picocolors6.default.cyan(import_node_path13.default.relative(root, directory)));
+    import_consola4.consola.debug("Deleted " + import_picocolors6.default.cyan(import_node_path14.default.relative(root, directory)));
   }
 }
 
@@ -5045,12 +5183,12 @@ function defineRunnerConfig(config) {
 }
 
 // src/core/runners/wsl.ts
-var import_node_path14 = require("path");
+var import_node_path15 = require("path");
 function createWslRunner() {
   return {
     async openBrowser(config) {
       config.logger.warn(
-        `Cannot open browser when using WSL. Load "${(0, import_node_path14.relative)(
+        `Cannot open browser when using WSL. Load "${(0, import_node_path15.relative)(
           process.cwd(),
           config.outDir
         )}" as an unpacked extension manually`
@@ -5066,7 +5204,7 @@ function createWebExtRunner() {
   let runner;
   return {
     async openBrowser(config) {
-      config.logger.info("Opening browser...");
+      const startTime = Date.now();
       if (config.browser === "firefox" && config.manifestVersion === 3) {
         throw Error(
           "Dev mode does not support Firefox MV3. For alternatives, see https://github.com/wxt-dev/wxt/issues/230#issuecomment-1806881653"
@@ -5111,7 +5249,8 @@ function createWebExtRunner() {
       config.logger.debug("web-ext options:", options);
       const webExt = await import("web-ext-run");
       runner = await webExt.default.cmd.run(finalConfig, options);
-      config.logger.success("Opened!");
+      const duration = Date.now() - startTime;
+      config.logger.success(`Opened browser in ${formatDuration(duration)}`);
     },
     async closeBrowser() {
       return await runner?.exit();
@@ -5122,12 +5261,12 @@ var WARN_LOG_LEVEL = 40;
 var ERROR_LOG_LEVEL = 50;
 
 // src/core/runners/safari.ts
-var import_node_path15 = require("path");
+var import_node_path16 = require("path");
 function createSafariRunner() {
   return {
     async openBrowser(config) {
       config.logger.warn(
-        `Cannot Safari using web-ext. Load "${(0, import_node_path15.relative)(
+        `Cannot Safari using web-ext. Load "${(0, import_node_path16.relative)(
           process.cwd(),
           config.outDir
         )}" as an unpacked extension manually`
@@ -5139,12 +5278,12 @@ function createSafariRunner() {
 }
 
 // src/core/runners/manual.ts
-var import_node_path16 = require("path");
+var import_node_path17 = require("path");
 function createManualRunner() {
   return {
     async openBrowser(config) {
       config.logger.info(
-        `Load "${(0, import_node_path16.relative)(
+        `Load "${(0, import_node_path17.relative)(
           process.cwd(),
           config.outDir
         )}" as an unpacked extension manually`
@@ -5173,10 +5312,10 @@ async function createExtensionRunner(config) {
 }
 
 // src/core/create-server.ts
-var import_consola4 = require("consola");
+var import_consola5 = require("consola");
 var import_async_mutex = require("async-mutex");
 var import_picocolors7 = __toESM(require("picocolors"), 1);
-var import_node_path17 = require("path");
+var import_node_path18 = require("path");
 async function createServer(inlineConfig) {
   const port = await getPort();
   const hostname = "localhost";
@@ -5186,19 +5325,36 @@ async function createServer(inlineConfig) {
     hostname,
     origin
   };
+  const buildAndOpenBrowser = async () => {
+    server.currentOutput = await internalBuild(config);
+    await runner.openBrowser(config);
+  };
+  const closeAndRecreateRunner = async () => {
+    await runner.closeBrowser();
+    config = await getLatestConfig();
+    runner = await createExtensionRunner(config);
+  };
   const server = {
     ...serverInfo,
-    watcher: void 0,
-    // Filled out later down below
-    ws: void 0,
-    // Filled out later down below
+    get watcher() {
+      return builderServer.watcher;
+    },
+    get ws() {
+      return builderServer.ws;
+    },
     currentOutput: void 0,
-    // Filled out later down below
     async start() {
       await builderServer.listen();
       config.logger.success(`Started dev server @ ${serverInfo.origin}`);
-      server.currentOutput = await internalBuild(config);
-      await runner.openBrowser(config);
+      await buildAndOpenBrowser();
+    },
+    async stop() {
+      await runner.closeBrowser();
+      await builderServer.close();
+    },
+    async restart() {
+      await closeAndRecreateRunner();
+      await buildAndOpenBrowser();
     },
     transformHtml(url2, html, originalUrl) {
       return builderServer.transformHtml(url2, html, originalUrl);
@@ -5211,17 +5367,21 @@ async function createServer(inlineConfig) {
     },
     reloadExtension() {
       server.ws.send("wxt:reload-extension");
+    },
+    async restartBrowser() {
+      await closeAndRecreateRunner();
+      await runner.openBrowser(config);
     }
   };
   const getLatestConfig = () => getInternalConfig(inlineConfig ?? {}, "serve", server);
   let config = await getLatestConfig();
-  const [runner, builderServer] = await Promise.all([
+  let [runner, builderServer] = await Promise.all([
     createExtensionRunner(config),
     config.builder.createServer(server)
   ]);
-  server.watcher = builderServer.watcher;
-  server.ws = builderServer.ws;
   server.ws.on("wxt:background-initialized", () => {
+    if (server.currentOutput == null)
+      return;
     reloadContentScripts(server.currentOutput.steps, config, server);
   });
   const reloadOnChange = createFileReloader({
@@ -5249,18 +5409,34 @@ function createFileReloader(options) {
       return;
     changeQueue.push([event, path10]);
     await fileChangedMutex.runExclusive(async () => {
-      const fileChanges = changeQueue.splice(0, changeQueue.length);
+      if (server.currentOutput == null)
+        return;
+      const fileChanges = changeQueue.splice(0, changeQueue.length).map(([_, file]) => file);
       if (fileChanges.length === 0)
         return;
-      const changes = detectDevChanges(fileChanges, server.currentOutput);
+      const changes = detectDevChanges(
+        config,
+        fileChanges,
+        server.currentOutput
+      );
       if (changes.type === "no-change")
         return;
+      if (changes.type === "full-restart") {
+        config.logger.info("Config changed, restarting server...");
+        server.restart();
+        return;
+      }
+      if (changes.type === "browser-restart") {
+        config.logger.info("Runner config changed, restarting browser...");
+        server.restartBrowser();
+        return;
+      }
       config.logger.info(
-        `Changed: ${Array.from(new Set(fileChanges.map((change) => change[1]))).map((file) => import_picocolors7.default.dim((0, import_node_path17.relative)(config.root, file))).join(", ")}`
+        `Changed: ${Array.from(new Set(fileChanges)).map((file) => import_picocolors7.default.dim((0, import_node_path18.relative)(config.root, file))).join(", ")}`
       );
       const rebuiltNames = changes.rebuildGroups.flat().map((entry) => {
         return import_picocolors7.default.cyan(
-          (0, import_node_path17.relative)(config.outDir, getEntrypointOutputFile(entry, ""))
+          (0, import_node_path18.relative)(config.outDir, getEntrypointOutputFile(entry, ""))
         );
       }).join(import_picocolors7.default.dim(", "));
       const allEntrypoints = await findEntrypoints(config);
@@ -5283,13 +5459,15 @@ function createFileReloader(options) {
           reloadContentScripts(changes.changedSteps, config, server);
           break;
       }
-      import_consola4.consola.success(`Reloaded: ${rebuiltNames}`);
+      import_consola5.consola.success(`Reloaded: ${rebuiltNames}`);
     });
   };
 }
 function reloadContentScripts(steps, config, server) {
   if (config.manifestVersion === 3) {
     steps.forEach((step) => {
+      if (server.currentOutput == null)
+        return;
       const entry = step.entrypoints;
       if (Array.isArray(entry) || entry.type !== "content-script")
         return;
@@ -5326,13 +5504,13 @@ function reloadHtmlPages(groups, server, config) {
 
 // src/core/initialize.ts
 var import_prompts = __toESM(require("prompts"), 1);
-var import_consola5 = require("consola");
+var import_consola6 = require("consola");
 var import_giget = require("giget");
 var import_fs_extra14 = __toESM(require("fs-extra"), 1);
-var import_node_path18 = __toESM(require("path"), 1);
+var import_node_path19 = __toESM(require("path"), 1);
 var import_picocolors8 = __toESM(require("picocolors"), 1);
 async function initialize(options) {
-  import_consola5.consola.info("Initalizing new project");
+  import_consola6.consola.info("Initalizing new project");
   const templates = await listTemplates();
   const defaultTemplate = templates.find(
     (template) => template.name === options.template?.toLowerCase().trim()
@@ -5377,17 +5555,17 @@ async function initialize(options) {
   input.template ??= defaultTemplate;
   input.packageManager ??= options.packageManager;
   await cloneProject(input);
-  const cdPath = import_node_path18.default.relative(process.cwd(), import_node_path18.default.resolve(input.directory));
+  const cdPath = import_node_path19.default.relative(process.cwd(), import_node_path19.default.resolve(input.directory));
   console.log();
-  import_consola5.consola.log(
+  import_consola6.consola.log(
     `\u2728 WXT project created with the ${TEMPLATE_COLORS[input.template.name]?.(input.template.name) ?? input.template.name} template.`
   );
   console.log();
-  import_consola5.consola.log("Next steps:");
+  import_consola6.consola.log("Next steps:");
   let step = 0;
   if (cdPath !== "")
-    import_consola5.consola.log(`  ${++step}.`, import_picocolors8.default.cyan(`cd ${cdPath}`));
-  import_consola5.consola.log(`  ${++step}.`, import_picocolors8.default.cyan(`${input.packageManager} install`));
+    import_consola6.consola.log(`  ${++step}.`, import_picocolors8.default.cyan(`cd ${cdPath}`));
+  import_consola6.consola.log(`  ${++step}.`, import_picocolors8.default.cyan(`${input.packageManager} install`));
   console.log();
 }
 async function listTemplates() {
@@ -5429,10 +5607,10 @@ async function cloneProject({
       force: true
     });
     await import_fs_extra14.default.move(
-      import_node_path18.default.join(directory, "_gitignore"),
-      import_node_path18.default.join(directory, ".gitignore")
+      import_node_path19.default.join(directory, "_gitignore"),
+      import_node_path19.default.join(directory, ".gitignore")
     ).catch(
-      (err) => import_consola5.consola.warn("Failed to move _gitignore to .gitignore:", err)
+      (err) => import_consola6.consola.warn("Failed to move _gitignore to .gitignore:", err)
     );
     spinner.succeed();
   } catch (err) {
@@ -5463,7 +5641,7 @@ async function prepare(config) {
 
 // src/core/zip.ts
 var import_zip_dir = __toESM(require("zip-dir"), 1);
-var import_node_path19 = require("path");
+var import_node_path20 = require("path");
 var import_fs_extra15 = __toESM(require("fs-extra"), 1);
 var import_minimatch2 = require("minimatch");
 async function zip(config) {
@@ -5473,7 +5651,7 @@ async function zip(config) {
   internalConfig.logger.info("Zipping extension...");
   const zipFiles = [];
   const projectName = internalConfig.zip.name ?? kebabCaseAlphanumeric(
-    (await getPackageJson(internalConfig))?.name || (0, import_node_path19.dirname)(process.cwd())
+    (await getPackageJson(internalConfig))?.name || (0, import_node_path20.dirname)(process.cwd())
   );
   const applyTemplate = (template) => template.replaceAll("{{name}}", projectName).replaceAll("{{browser}}", internalConfig.browser).replaceAll(
     "{{version}}",
@@ -5481,7 +5659,7 @@ async function zip(config) {
   ).replaceAll("{{manifestVersion}}", `mv${internalConfig.manifestVersion}`);
   await import_fs_extra15.default.ensureDir(internalConfig.outBaseDir);
   const outZipFilename = applyTemplate(internalConfig.zip.artifactTemplate);
-  const outZipPath = (0, import_node_path19.resolve)(internalConfig.outBaseDir, outZipFilename);
+  const outZipPath = (0, import_node_path20.resolve)(internalConfig.outBaseDir, outZipFilename);
   await (0, import_zip_dir.default)(internalConfig.outDir, {
     saveTo: outZipPath
   });
@@ -5490,14 +5668,14 @@ async function zip(config) {
     const sourcesZipFilename = applyTemplate(
       internalConfig.zip.sourcesTemplate
     );
-    const sourcesZipPath = (0, import_node_path19.resolve)(
+    const sourcesZipPath = (0, import_node_path20.resolve)(
       internalConfig.outBaseDir,
       sourcesZipFilename
     );
     await (0, import_zip_dir.default)(internalConfig.zip.sourcesRoot, {
       saveTo: sourcesZipPath,
       filter(path10) {
-        const relativePath = (0, import_node_path19.relative)(internalConfig.zip.sourcesRoot, path10);
+        const relativePath = (0, import_node_path20.relative)(internalConfig.zip.sourcesRoot, path10);
         const matchedPattern = internalConfig.zip.ignoredSources.find(
           (pattern) => (0, import_minimatch2.minimatch)(relativePath, pattern)
         );