wxt 0.21.0 → 0.21.2

package/dist/core/utils/building/find-entrypoints.mjs

@@ -2,33 +2,36 @@ import { CSS_EXTENSIONS_PATTERN } from "../paths.mjs";
 import { getEntrypointName, isHtmlEntrypoint, isJsEntrypoint, resolvePerBrowserOptions } from "../entrypoints.mjs";
 import { VIRTUAL_NOOP_BACKGROUND_MODULE_ID } from "../constants.mjs";
 import { wxt } from "../../wxt.mjs";
-import fs from "fs-extra";
-import glob from "fast-glob";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { glob } from "tinyglobby";
 import { relative, resolve } from "path";
 import { parseHTML } from "linkedom";
 import { camelCase } from "scule";
-import pc from "picocolors";
-import { minimatch } from "minimatch";
+import { styleText } from "node:util";
+import picomatch from "picomatch";
 import JSON5 from "json5";
-
 //#region src/core/utils/building/find-entrypoints.ts
 /**
-* Return entrypoints and their configuration by looking through the project's files.
+* Return entrypoints and their configuration by looking through the project's
+* files.
 */
 async function findEntrypoints() {
-	await fs.mkdir(wxt.config.wxtDir, { recursive: true });
+	await mkdir(wxt.config.wxtDir, { recursive: true });
 	try {
-		await fs.writeJson(resolve(wxt.config.wxtDir, "tsconfig.json"), {}, { flag: "wx" });
+		await writeFile(resolve(wxt.config.wxtDir, "tsconfig.json"), JSON.stringify({}), { flag: "wx" });
 	} catch (err) {
 		if (!(err instanceof Error) || !("code" in err) || err.code !== "EEXIST") throw err;
 	}
-	const relativePaths = await glob(Object.keys(PATH_GLOB_TO_TYPE_MAP), { cwd: wxt.config.entrypointsDir });
+	const relativePaths = await glob(Object.keys(PATH_GLOB_TO_TYPE_MAP), {
+		cwd: wxt.config.entrypointsDir,
+		expandDirectories: false
+	});
 	relativePaths.sort();
 	const pathGlobs = Object.keys(PATH_GLOB_TO_TYPE_MAP);
 	const entrypointInfos = relativePaths.reduce((results, relativePath) => {
 		const inputPath = resolve(wxt.config.entrypointsDir, relativePath);
 		const name = getEntrypointName(wxt.config.entrypointsDir, inputPath);
-		const matchingGlob = pathGlobs.find((glob) => minimatch(relativePath, glob));
+		const matchingGlob = pathGlobs.find((glob) => picomatch(glob)(relativePath));
 		if (matchingGlob) {
 			const type = PATH_GLOB_TO_TYPE_MAP[matchingGlob];
 			results.push({
@@ -87,7 +90,7 @@ async function findEntrypoints() {
 	await wxt.hooks.callHook("entrypoints:resolved", wxt, entrypoints);
 	wxt.logger.debug("All entrypoints:", entrypoints);
 	const skippedEntrypointNames = entrypoints.filter((item) => item.skipped).map((item) => item.name);
-	if (skippedEntrypointNames.length) wxt.logger.warn(["The following entrypoints have been skipped:", ...skippedEntrypointNames.map((item) => `${pc.dim("-")} ${pc.cyan(item)}`)].join("\n"));
+	if (skippedEntrypointNames.length) wxt.logger.warn(["The following entrypoints have been skipped:", ...skippedEntrypointNames.map((item) => `${styleText("dim", "-")} ${styleText("cyan", item)}`)].join("\n"));
 	return entrypoints;
 }
 /** Returns a map of input paths to the file's options. */
@@ -104,9 +107,12 @@ async function importEntrypoints(infos) {
 	})()]);
 	return resMap;
 }
-/** Extract `manifest.` and `wxt.` options from meta tags, converting snake_case keys to camelCase */
+/**
+* Extract `manifest.` and `wxt.` options from meta tags, converting snake_case
+* keys to camelCase
+*/
 async function importHtmlEntrypoint(info) {
-	const { document } = parseHTML(await fs.readFile(info.inputPath, "utf-8"));
+	const { document } = parseHTML(await readFile(info.inputPath, "utf-8"));
 	const metaTags = document.querySelectorAll("meta");
 	const res = { title: document.querySelector("title")?.textContent || void 0 };
 	metaTags.forEach((tag) => {
@@ -151,16 +157,30 @@ async function getPopupEntrypoint(info, options) {
 	const strictOptions = resolvePerBrowserOptions({
 		...perBrowserOptions,
 		defaultTitle: title,
-		mv2Key: type
+		actionType: type
 	}, wxt.config.browser);
-	if (strictOptions.mv2Key && strictOptions.mv2Key !== "page_action") strictOptions.mv2Key = "browser_action";
+	if (strictOptions.actionType && strictOptions.actionType !== "page_action") strictOptions.actionType = "browser_action";
+	const opts = {
+		...strictOptions,
+		themeIcons
+	};
+	let _actionType = opts.actionType;
+	Object.defineProperty(opts, "actionType", {
+		get: () => _actionType,
+		set: (v) => _actionType = v,
+		enumerable: true,
+		configurable: true
+	});
+	Object.defineProperty(opts, "mv2Key", {
+		get: () => _actionType,
+		set: (v) => _actionType = v,
+		enumerable: true,
+		configurable: true
+	});
 	return {
 		type: "popup",
 		name: "popup",
-		options: {
-			...strictOptions,
-			themeIcons
-		},
+		options: opts,
 		inputPath: info.inputPath,
 		outputDir: wxt.config.outDir
 	};
@@ -276,6 +296,5 @@ const PATH_GLOB_TO_TYPE_MAP = {
 	[`*/index.${CSS_EXTENSIONS_PATTERN}`]: "unlisted-style"
 };
 const CONTENT_SCRIPT_OUT_DIR = "content-scripts";
-
 //#endregion
-export { findEntrypoints };
+export { findEntrypoints };

package/dist/core/utils/building/group-entrypoints.mjs

@@ -1,7 +1,7 @@
 //#region src/core/utils/building/group-entrypoints.ts
 /**
-* Entrypoints are built in groups. HTML pages can all be built together in a single step,
-* content scripts must be build individually, etc.
+* Entrypoints are built in groups. HTML pages can all be built together in a
+* single step, content scripts must be build individually, etc.
 *
 * This function returns the entrypoints put into these types of groups.
 */
@@ -40,6 +40,5 @@ const ENTRY_TYPE_TO_GROUP_MAP = {
 	"unlisted-style": "individual",
 	"content-script-style": "individual"
 };
-
 //#endregion
-export { groupEntrypoints };
+export { groupEntrypoints };

package/dist/core/utils/building/index.mjs

@@ -1,8 +1,7 @@
-import { buildEntrypoints } from "./build-entrypoints.mjs";
-import { detectDevChanges } from "./detect-dev-changes.mjs";
-import { findEntrypoints } from "./find-entrypoints.mjs";
-import { groupEntrypoints } from "./group-entrypoints.mjs";
-import { rebuild } from "./rebuild.mjs";
-import { internalBuild } from "./internal-build.mjs";
-
-export {  };
+import "./build-entrypoints.mjs";
+import "./detect-dev-changes.mjs";
+import "./find-entrypoints.mjs";
+import "./group-entrypoints.mjs";
+import "./rebuild.mjs";
+import "./internal-build.mjs";
+export {};

package/dist/core/utils/building/internal-build.mjs

@@ -1,41 +1,41 @@
 import { unnormalizePath } from "../paths.mjs";
-import { formatDuration } from "../time.mjs";
 import { wxt } from "../../wxt.mjs";
 import { findEntrypoints } from "./find-entrypoints.mjs";
 import { groupEntrypoints } from "./group-entrypoints.mjs";
+import { formatDuration } from "../time.mjs";
 import { printBuildSummary } from "../log/printBuildSummary.mjs";
 import "../log/index.mjs";
 import { rebuild } from "./rebuild.mjs";
 import { ValidationError, validateEntrypoints } from "../validation.mjs";
-import fs from "fs-extra";
-import glob from "fast-glob";
+import { mkdir, rm } from "node:fs/promises";
+import { glob } from "tinyglobby";
 import { relative } from "node:path";
 import { mergeJsonOutputs } from "@aklinker1/rollup-plugin-visualizer";
-import pc from "picocolors";
+import { styleText } from "node:util";
 import { isCI } from "ci-info";
-
 //#region src/core/utils/building/internal-build.ts
 /**
-* Builds the extension based on an internal config. No more config discovery is performed, the
-* build is based on exactly what is passed in.
+* Builds the extension based on an internal config. No more config discovery is
+* performed, the build is based on exactly what is passed in.
 *
 * This function:
+*
 * 1. Cleans the output directory
-* 2. Executes the rebuild function with a blank previous output so everything is built (see
-*    `rebuild` for more details)
+* 2. Executes the rebuild function with a blank previous output so everything is
+*    built (see `rebuild` for more details)
 * 3. Prints the summary
 */
 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} ${pc.cyan(target)} for ${pc.cyan(wxt.config.mode)} with ${pc.green(`${wxt.builder.name} ${wxt.builder.version}`)}`);
+	wxt.logger.info(`${verb} ${styleText("cyan", target)} for ${styleText("cyan", wxt.config.mode)} with ${styleText("green", `${wxt.builder.name} ${wxt.builder.version}`)}`);
 	const startTime = Date.now();
-	await fs.rm(wxt.config.outDir, {
+	await rm(wxt.config.outDir, {
 		recursive: true,
 		force: true
 	});
-	await fs.ensureDir(wxt.config.outDir);
+	await mkdir(wxt.config.outDir, { recursive: true });
 	const entrypoints = await findEntrypoints();
 	wxt.logger.debug("Detected entrypoints:", entrypoints);
 	const validationResults = validateEntrypoints(entrypoints);
@@ -50,10 +50,10 @@ async function internalBuild() {
 	if (wxt.config.analysis.enabled) {
 		await combineAnalysisStats();
 		const statsPath = relative(wxt.config.root, wxt.config.analysis.outputFile);
-		wxt.logger.info(`Analysis complete:\n  ${pc.gray("└─")} ${pc.yellow(statsPath)}`);
-		if (wxt.config.analysis.open) if (isCI) wxt.logger.debug(`Skipped opening ${pc.yellow(statsPath)} in CI`);
+		wxt.logger.info(`Analysis complete:\n  ${styleText("gray", "└─")} ${styleText("yellow", statsPath)}`);
+		if (wxt.config.analysis.open) if (isCI) wxt.logger.debug(`Skipped opening ${styleText("yellow", statsPath)} in CI`);
 		else {
-			wxt.logger.info(`Opening ${pc.yellow(statsPath)} in browser...`);
+			wxt.logger.info(`Opening ${styleText("yellow", statsPath)} in browser...`);
 			const { default: open } = await import("open");
 			await open(wxt.config.analysis.outputFile);
 		}
@@ -63,14 +63,15 @@ async function internalBuild() {
 async function combineAnalysisStats() {
 	const absolutePaths = (await glob(`${wxt.config.analysis.outputName}-*.json`, {
 		cwd: wxt.config.analysis.outputDir,
-		absolute: true
+		absolute: true,
+		expandDirectories: false
 	})).map(unnormalizePath);
 	await mergeJsonOutputs({
 		inputs: absolutePaths,
 		template: wxt.config.analysis.template,
 		filename: wxt.config.analysis.outputFile
 	});
-	if (!wxt.config.analysis.keepArtifacts) await Promise.all(absolutePaths.map((statsFile) => fs.remove(statsFile)));
+	if (!wxt.config.analysis.keepArtifacts) await Promise.all(absolutePaths.map((statsFile) => rm(statsFile, { force: true })));
 }
 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"}`);
@@ -84,13 +85,12 @@ function printValidationResults({ errorCount, errors, warningCount }) {
 	Array.from(entrypointErrors.entries()).forEach(([entrypoint, errors]) => {
 		wxt.logger.log(relative(cwd, entrypoint.inputPath) + "\n");
 		errors.forEach((err) => {
-			const type = err.type === "error" ? pc.red("ERROR") : pc.yellow("WARN");
-			const received = pc.dim(`(received: ${JSON.stringify(err.value)})`);
+			const type = err.type === "error" ? styleText("red", "ERROR") : styleText("yellow", "WARN");
+			const received = styleText("dim", `(received: ${JSON.stringify(err.value)})`);
 			wxt.logger.log(`  - ${type} ${err.message} ${received}`);
 		});
 		console.log();
 	});
 }
-
 //#endregion
-export { internalBuild };
+export { internalBuild };

package/dist/core/utils/building/rebuild.mjs

@@ -2,30 +2,31 @@ import { wxt } from "../../wxt.mjs";
 import { buildEntrypoints } from "./build-entrypoints.mjs";
 import { generateWxtDir } from "../../generate-wxt-dir.mjs";
 import { generateManifest, writeManifest } from "../manifest.mjs";
-
+import { createSpinner } from "nanospinner";
 //#region src/core/utils/building/rebuild.ts
 /**
-* Given a configuration, list of entrypoints, and an existing, partial output, build the
-* entrypoints and merge the new output with the existing output.
+* Given a configuration, list of entrypoints, and an existing, partial output,
+* build the entrypoints and merge the new output with the existing output.
 *
 * This function will:
+*
 * 1. Generate the .wxt directory's types
 * 2. Build the `entrypointGroups` (and copies public files)
 * 3. Generate the latest manifest for all entrypoints
 * 4. Write the new manifest to the file system
 *
 * @param config Internal config containing all the project information.
-* @param allEntrypoints List of entrypoints used to generate the types inside .wxt directory.
+* @param allEntrypoints List of entrypoints used to generate the types inside
+*   .wxt directory.
 * @param entrypointGroups The list of entrypoint groups to build.
-* @param existingOutput The previous output to combine the rebuild results into. An emptry array if
-*                       this is the first build.
+* @param existingOutput The previous output to combine the rebuild results
+*   into. An empty array if this is the first build.
 */
 async function rebuild(allEntrypoints, entrypointGroups, existingOutput = {
 	steps: [],
 	publicAssets: []
 }) {
-	const { default: ora } = await import("ora");
-	const spinner = ora(`Preparing...`).start();
+	const spinner = createSpinner("Preparing...").start();
 	await generateWxtDir(allEntrypoints).catch((err) => {
 		wxt.logger.warn("Failed to update .wxt directory:", err);
 		if (wxt.config.command === "build") throw err;
@@ -48,6 +49,5 @@ async function rebuild(allEntrypoints, entrypointGroups, existingOutput = {
 		warnings: manifestWarnings
 	};
 }
-
 //#endregion
-export { rebuild };
+export { rebuild };

package/dist/core/utils/cache.mjs

@@ -1,11 +1,10 @@
 import { writeFileIfDifferent } from "./fs.mjs";
-import fs, { ensureDir } from "fs-extra";
+import { mkdir, readFile } from "node:fs/promises";
 import { dirname, resolve } from "path";
-
 //#region src/core/utils/cache.ts
 /**
-* A basic file system cache stored at `<srcDir>/.wxt/cache/<key>`. Just caches a string in a
-* file for the given key.
+* A basic file system cache stored at `<srcDir>/.wxt/cache/<key>`. Just caches
+* a string in a file for the given key.
 *
 * @param srcDir Absolute path to source directory. See `InternalConfig.srcDir`
 */
@@ -14,19 +13,18 @@ function createFsCache(wxtDir) {
 	return {
 		async set(key, value) {
 			const path = getPath(key);
-			await ensureDir(dirname(path));
+			await mkdir(dirname(path), { recursive: true });
 			await writeFileIfDifferent(path, value);
 		},
 		async get(key) {
 			const path = getPath(key);
 			try {
-				return await fs.readFile(path, "utf-8");
+				return await readFile(path, "utf-8");
 			} catch {
 				return;
 			}
 		}
 	};
 }
-
 //#endregion
-export { createFsCache };
+export { createFsCache };

package/dist/core/utils/constants.mjs

@@ -1,9 +1,8 @@
 //#region src/core/utils/constants.ts
 /**
-* Module ID used to build the background in dev mode if the extension doesn't include a background
-* script/service worker.
+* Module ID used to build the background in dev mode if the extension doesn't
+* include a background script/service worker.
 */
 const VIRTUAL_NOOP_BACKGROUND_MODULE_ID = "virtual:user-background";
-
 //#endregion
-export { VIRTUAL_NOOP_BACKGROUND_MODULE_ID };
+export { VIRTUAL_NOOP_BACKGROUND_MODULE_ID };

package/dist/core/utils/content-scripts.mjs

@@ -1,8 +1,8 @@
 import { getEntrypointBundlePath } from "./entrypoints.mjs";
-
 //#region src/core/utils/content-scripts.ts
 /**
-* Returns a unique and consistent string hash based on a content scripts options.
+* Returns a unique and consistent string hash based on a content scripts
+* options.
 *
 * It is able to recognize default values,
 */
@@ -56,6 +56,5 @@ function mapWxtOptionsToRegisteredContentScript(options, js, css) {
 function getContentScriptJs(config, entrypoint) {
 	return [getEntrypointBundlePath(entrypoint, config.outDir, ".js")];
 }
-
 //#endregion
-export { getContentScriptJs, hashContentScriptOptions, mapWxtOptionsToContentScript, mapWxtOptionsToRegisteredContentScript };
+export { getContentScriptJs, hashContentScriptOptions, mapWxtOptionsToContentScript, mapWxtOptionsToRegisteredContentScript };

package/dist/core/utils/content-security-policy.mjs

@@ -14,9 +14,7 @@ var ContentSecurityPolicy = class ContentSecurityPolicy {
 		}, {});
 		else this.data = {};
 	}
-	/**
-	* Ensure a set of values are listed under a directive.
-	*/
+	/** Ensure a set of values are listed under a directive. */
 	add(directive, ...newValues) {
 		const values = this.data[directive] ?? [];
 		newValues.forEach((newValue) => {
@@ -31,6 +29,5 @@ var ContentSecurityPolicy = class ContentSecurityPolicy {
 		}).map((entry) => entry.flat().join(" ")).join("; ") + ";";
 	}
 };
-
 //#endregion
-export { ContentSecurityPolicy };
+export { ContentSecurityPolicy };

package/dist/core/utils/create-file-reloader.mjs

@@ -0,0 +1,158 @@
+import { normalizePath } from "./paths.mjs";
+import { getEntrypointBundlePath, isHtmlEntrypoint } from "./entrypoints.mjs";
+import { filterTruthy, toArray } from "./arrays.mjs";
+import { wxt } from "../wxt.mjs";
+import { detectDevChanges, getRelevantDevChangedFiles } from "./building/detect-dev-changes.mjs";
+import { findEntrypoints } from "./building/find-entrypoints.mjs";
+import { groupEntrypoints } from "./building/group-entrypoints.mjs";
+import { getContentScriptJs, mapWxtOptionsToRegisteredContentScript } from "./content-scripts.mjs";
+import { getContentScriptCssFiles, getContentScriptsCssMap } from "./manifest.mjs";
+import { rebuild } from "./building/rebuild.mjs";
+import "./building/index.mjs";
+import { isBabelSyntaxError, logBabelSyntaxError } from "./syntax-errors.mjs";
+import { relative } from "node:path";
+import { styleText } from "node:util";
+import { Mutex } from "async-mutex";
+//#region src/core/utils/create-file-reloader.ts
+/**
+* Returns a function responsible for reloading different parts of the extension
+* when a file changes.
+*/
+function createFileReloader(server) {
+	const fileChangedMutex = new Mutex();
+	const changeQueue = [];
+	let processLoop;
+	const processQueue = async () => {
+		await fileChangedMutex.runExclusive(async () => {
+			const fileChanges = changeQueue.splice(0, changeQueue.length).map(([_, file]) => file);
+			if (fileChanges.length === 0) return;
+			if (server.currentOutput == null) return;
+			const normalizedFileChanges = fileChanges.map(normalizePath);
+			const relevantFileChanges = getRelevantDevChangedFiles(fileChanges, server.currentOutput);
+			const normalizedEntrypointsDir = normalizePath(wxt.config.entrypointsDir);
+			const hasEntrypointDirChange = normalizedFileChanges.some((file) => file === normalizedEntrypointsDir || file.startsWith(`${normalizedEntrypointsDir}/`));
+			if (relevantFileChanges.length === 0 && !hasEntrypointDirChange) return;
+			await wxt.reloadConfig();
+			const allEntrypoints = await findEntrypoints();
+			const allEntrypointGroups = groupEntrypoints(allEntrypoints);
+			const newEntrypointGroups = getNewEntrypointGroups(normalizedFileChanges, allEntrypointGroups, server.currentOutput);
+			if (relevantFileChanges.length === 0 && newEntrypointGroups.length === 0) return;
+			const changes = detectDevChanges(relevantFileChanges, server.currentOutput);
+			if (changes.type === "full-restart") {
+				wxt.logger.info("Config changed, restarting server...");
+				server.restart();
+				return;
+			}
+			if (changes.type === "browser-restart") {
+				wxt.logger.info("Runner config changed, restarting browser...");
+				server.restartBrowser();
+				return;
+			}
+			const hasNewEntrypoints = newEntrypointGroups.length > 0;
+			if (changes.type === "no-change" && !hasNewEntrypoints) return;
+			const changedFilesToLog = Array.from(new Set([...relevantFileChanges, ...newEntrypointGroups.flatMap((group) => toArray(group)).map((entry) => entry.inputPath)]));
+			wxt.logger.info(`Changed: ${changedFilesToLog.map((file) => styleText("dim", relative(wxt.config.root, file))).join(", ")}`);
+			const rebuildGroups = changes.type === "no-change" ? newEntrypointGroups : mergeEntrypointGroups(getLatestRebuildGroups(changes.rebuildGroups, allEntrypointGroups), newEntrypointGroups);
+			try {
+				const { output: newOutput } = await rebuild(allEntrypoints, rebuildGroups, changes.type === "no-change" ? server.currentOutput : changes.cachedOutput);
+				server.currentOutput = newOutput;
+				if (hasNewEntrypoints || changes.type === "extension-reload") {
+					server.reloadExtension();
+					wxt.logger.success(`Reloaded extension`);
+				} else if (changes.type === "html-reload") {
+					const { reloadedNames } = reloadHtmlPages(rebuildGroups, server);
+					wxt.logger.success(`Reloaded: ${getFilenameList(reloadedNames)}`);
+				} else if (changes.type === "content-script-reload") {
+					reloadContentScripts(changes.changedSteps, server);
+					const rebuiltNames = rebuildGroups.flat().map((entry) => entry.name);
+					wxt.logger.success(`Reloaded: ${getFilenameList(rebuiltNames)}`);
+				}
+			} catch {}
+		}).catch((error) => {
+			if (!isBabelSyntaxError(error)) throw error;
+			logBabelSyntaxError(error);
+		});
+	};
+	const waitForDebounceWindow = async () => {
+		await new Promise((resolve) => {
+			setTimeout(resolve, wxt.config.dev.server.watchDebounce);
+		});
+	};
+	const queueWorker = async () => {
+		while (true) {
+			await processQueue();
+			await waitForDebounceWindow();
+			if (changeQueue.length === 0) break;
+		}
+	};
+	return async (event, path) => {
+		changeQueue.push([event, path]);
+		processLoop ??= queueWorker().finally(() => {
+			processLoop = void 0;
+		});
+		await processLoop;
+	};
+}
+function getNewEntrypointGroups(normalizedFileChanges, allEntrypointGroups, currentOutput) {
+	const changedFiles = new Set(normalizedFileChanges);
+	const builtEntrypointPaths = new Set(currentOutput.steps.flatMap((step) => toArray(step.entrypoints).map((entry) => normalizePath(entry.inputPath))));
+	return allEntrypointGroups.filter((group) => {
+		const groupEntrypoints = toArray(group);
+		const hasNewEntrypoint = groupEntrypoints.some((entry) => !builtEntrypointPaths.has(normalizePath(entry.inputPath)));
+		const changedEntrypoint = groupEntrypoints.some((entry) => changedFiles.has(normalizePath(entry.inputPath)));
+		return hasNewEntrypoint && changedEntrypoint;
+	});
+}
+function getLatestRebuildGroups(rebuildGroups, allEntrypointGroups) {
+	const groupByEntrypointPath = /* @__PURE__ */ new Map();
+	allEntrypointGroups.forEach((group) => {
+		toArray(group).forEach((entry) => {
+			groupByEntrypointPath.set(normalizePath(entry.inputPath), group);
+		});
+	});
+	return mergeEntrypointGroups(rebuildGroups.flatMap((group) => {
+		return filterTruthy(toArray(group).map((entry) => groupByEntrypointPath.get(normalizePath(entry.inputPath))));
+	}));
+}
+function mergeEntrypointGroups(...groups) {
+	const deduped = /* @__PURE__ */ new Map();
+	groups.flat().forEach((group) => {
+		deduped.set(getEntrypointGroupKey(group), group);
+	});
+	return [...deduped.values()];
+}
+function getEntrypointGroupKey(group) {
+	return toArray(group).map((entry) => normalizePath(entry.inputPath)).sort().join("|");
+}
+/**
+* From the server, tell the client to reload content scripts from the provided
+* build step outputs.
+*/
+function reloadContentScripts(steps, server) {
+	if (wxt.config.manifestVersion === 3) steps.forEach((step) => {
+		if (server.currentOutput == null) return;
+		const entry = step.entrypoints;
+		if (Array.isArray(entry) || entry.type !== "content-script") return;
+		const js = getContentScriptJs(wxt.config, entry);
+		const cssMap = getContentScriptsCssMap(server.currentOutput, [entry]);
+		const css = getContentScriptCssFiles([entry], cssMap);
+		server.reloadContentScript({
+			registration: entry.options.registration,
+			contentScript: mapWxtOptionsToRegisteredContentScript(entry.options, js, css)
+		});
+	});
+	else server.reloadExtension();
+}
+function reloadHtmlPages(groups, server) {
+	const htmlEntries = groups.flat().filter(isHtmlEntrypoint);
+	htmlEntries.forEach((entry) => {
+		const path = getEntrypointBundlePath(entry, wxt.config.outDir, ".html");
+		server.reloadPage(path);
+	});
+	return { reloadedNames: htmlEntries.map((entry) => entry.name) };
+}
+function getFilenameList(names) {
+	return names.map((name) => styleText("cyan", name)).join(styleText("dim", ", "));
+}
+//#endregion
+export { createFileReloader, reloadContentScripts };

package/dist/core/utils/entrypoints.d.mts

@@ -0,0 +1,10 @@
+import { Entrypoint } from "../../types.mjs";
+
+//#region src/core/utils/entrypoints.d.ts
+/**
+ * Return's the entrypoint's output path relative to the output directory. Used
+ * for paths in the manifest and rollup's bundle.
+ */
+declare function getEntrypointBundlePath(entrypoint: Entrypoint, outDir: string, ext: string): string;
+//#endregion
+export { getEntrypointBundlePath };

package/dist/core/utils/entrypoints.mjs

@@ -1,6 +1,5 @@
 import { normalizePath } from "./paths.mjs";
 import path, { extname, relative, resolve } from "node:path";
-
 //#region src/core/utils/entrypoints.ts
 function getEntrypointName(entrypointsDir, inputPath) {
 	return path.relative(entrypointsDir, inputPath).split(/[./\\]/, 2)[0];
@@ -9,15 +8,13 @@ function getEntrypointOutputFile(entrypoint, ext) {
 	return resolve(entrypoint.outputDir, `${entrypoint.name}${ext}`);
 }
 /**
-* Return's the entrypoint's output path relative to the output directory. Used for paths in the
-* manifest and rollup's bundle.
+* Return's the entrypoint's output path relative to the output directory. Used
+* for paths in the manifest and rollup's bundle.
 */
 function getEntrypointBundlePath(entrypoint, outDir, ext) {
 	return normalizePath(relative(outDir, getEntrypointOutputFile(entrypoint, ext)));
 }
-/**
-* Given an entrypoint option, resolve it's value based on a target browser.
-*/
+/** Given an entrypoint option, resolve it's value based on a target browser. */
 function resolvePerBrowserOption(option, browser) {
 	if (typeof option === "object" && !Array.isArray(option)) return option[browser];
 	return option;
@@ -25,8 +22,8 @@ function resolvePerBrowserOption(option, browser) {
 /**
 * Given an entrypoint option, resolve it's value based on a target browser.
 *
-* defaultIcon is special, it's the only key that's a record, which can confuse this function. So
-* it's been manually excluded from resolution.
+* DefaultIcon is special, it's the only key that's a record, which can confuse
+* this function. So it's been manually excluded from resolution.
 */
 function resolvePerBrowserOptions(options, browser) {
 	return Object.fromEntries(Object.entries(options).map(([key, value]) => [key, key === "defaultIcon" ? value : resolvePerBrowserOption(value, browser)]));
@@ -54,6 +51,5 @@ function isJsEntrypoint(entrypoint) {
 		".tsx"
 	].includes(ext);
 }
-
 //#endregion
-export { getEntrypointBundlePath, getEntrypointName, isHtmlEntrypoint, isJsEntrypoint, resolvePerBrowserOptions };
+export { getEntrypointBundlePath, getEntrypointName, isHtmlEntrypoint, isJsEntrypoint, resolvePerBrowserOptions };

package/dist/core/utils/env.mjs

@@ -1,25 +1,30 @@
-import { config } from "dotenv";
 import { expand } from "dotenv-expand";
-
+import { existsSync, readFileSync } from "node:fs";
+import { parseEnv } from "node:util";
 //#region src/core/utils/env.ts
-/**
-* Load environment files based on the current mode and browser.
-*/
+/** Load environment files based on the current mode and browser. */
 function loadEnv(mode, browser) {
-	return expand(config({
-		quiet: true,
-		path: [
-			`.env.${mode}.${browser}.local`,
-			`.env.${mode}.${browser}`,
-			`.env.${browser}.local`,
-			`.env.${browser}`,
-			`.env.${mode}.local`,
-			`.env.${mode}`,
-			`.env.local`,
-			`.env`
-		]
+	const envFiles = [
+		`.env`,
+		`.env.local`,
+		`.env.${mode}`,
+		`.env.${mode}.local`,
+		`.env.${browser}`,
+		`.env.${browser}.local`,
+		`.env.${mode}.${browser}`,
+		`.env.${mode}.${browser}.local`
+	];
+	const parsed = Object.fromEntries(envFiles.flatMap((filePath) => {
+		if (!existsSync(filePath)) return [];
+		try {
+			const parsedEnv = parseEnv(readFileSync(filePath, "utf-8"));
+			return Object.entries(parsedEnv);
+		} catch {
+			return [];
+		}
 	}));
+	expand({ parsed });
+	return parsed;
 }
-
 //#endregion
-export { loadEnv };
+export { loadEnv };