chore(release): v0.16.1

BREAKING CHANGE: The build output has changed slightly. This isn't a huge deal, and no steps are required for users unless you're doing something weird with the output files after a build.

Before:

```
.output/
  <target>/
    chunks/
      popup-<hash>.js
    popup.html
```

After:

```
.output/
  <target>/
    popup.html
    popup.js
```

This applies for all HTML files, not just the popup.

CHANGELOG.md

@@ -1,5 +1,165 @@
 # Changelog
 
+## v0.16.1
+
+[compare changes](https://github.com/wxt-dev/wxt/compare/v0.16.0...v0.16.1)
+
+### 🩹 Fixes
+
+- Don't require config to run `wxt submit init` ([9318346](https://github.com/wxt-dev/wxt/commit/9318346))
+
+### 📖 Documentation
+
+- Add premid extension to homepage ([#399](https://github.com/wxt-dev/wxt/pull/399))
+
+### 🏡 Chore
+
+- **templates:** Upgrade to wxt `^0.16.0` ([f0b2a12](https://github.com/wxt-dev/wxt/commit/f0b2a12))
+
+### ❤️ Contributors
+
+- Florian Metz ([@Timeraa](http://github.com/Timeraa))
+
+## v0.16.0
+
+[compare changes](https://github.com/wxt-dev/wxt/compare/v0.15.4...v0.16.0)
+
+### 🚀 Enhancements
+
+- ⚠️  ESM background support ([#398](https://github.com/wxt-dev/wxt/pull/398))
+
+### 📖 Documentation
+
+- Document how to opt into ESM ([1e12ce2](https://github.com/wxt-dev/wxt/commit/1e12ce2))
+
+### 🏡 Chore
+
+- **deps-dev:** Bump lint-staged from 15.2.0 to 15.2.1 ([#395](https://github.com/wxt-dev/wxt/pull/395))
+- **deps-dev:** Bump p-map from 7.0.0 to 7.0.1 ([#396](https://github.com/wxt-dev/wxt/pull/396))
+- **deps-dev:** Bump @vitest/coverage-v8 from 1.0.1 to 1.2.2 ([#397](https://github.com/wxt-dev/wxt/pull/397))
+
+#### ⚠️ Breaking Changes
+
+In [#398](https://github.com/wxt-dev/wxt/pull/398), HTML pages' JS entrypoints in the output directory have been moved. Unless you're doing some kind of post-build work referencing files, you don't have to make any changes.
+
+- Before:
+   ```
+   .output/
+     <target>/
+       chunks/
+         some-shared-chunk-<hash>.js
+         popup-<hash>.js
+       popup.html
+   ```
+- After:
+   ```
+   .output/
+     <target>/
+       chunks/
+         some-shared-chunk-<hash>.js
+       popup.html
+       popup.js
+   ```
+
+This effects all HTML files, not just the Popup. The hash has been removed, and it's been moved to the root of the build target folder, not inside the `chunks/` directory. Moving files like this has not historically increased review times or triggered in-depth reviews when submitting updates to the stores.
+
+## v0.15.4
+
+[compare changes](https://github.com/wxt-dev/wxt/compare/v0.15.3...v0.15.4)
+
+### 🩹 Fixes
+
+- **submit:** Load `.env.submit` automatically when running `wxt submit` and `wxt submit init` ([#391](https://github.com/wxt-dev/wxt/pull/391))
+
+## v0.15.3
+
+[compare changes](https://github.com/wxt-dev/wxt/compare/v0.15.2...v0.15.3)
+
+### 🩹 Fixes
+
+- **dev:** Reload `<name>/index.html` entrypoints properly on save ([#390](https://github.com/wxt-dev/wxt/pull/390))
+
+## v0.15.2
+
+[compare changes](https://github.com/wxt-dev/wxt/compare/v0.15.1...v0.15.2)
+
+### 🚀 Enhancements
+
+- Add `submit` command ([#370](https://github.com/wxt-dev/wxt/pull/370))
+
+### 🩹 Fixes
+
+- **dev:** Resolve `script` and `link` aliases ([#387](https://github.com/wxt-dev/wxt/pull/387))
+
+### ❤️ Contributors
+
+- Nenad Novaković ([@dvlden](https://github.com/dvlden))
+
+## v0.15.1
+
+[compare changes](https://github.com/wxt-dev/wxt/compare/v0.15.0...v0.15.1)
+
+### 🚀 Enhancements
+
+- Allow passing custom preferences to chrome, enabling dev mode on `chrome://extensions` and allowing content script sourcemaps automatically ([#384](https://github.com/wxt-dev/wxt/pull/384))
+
+### 🩹 Fixes
+
+- **security:** Upgrade to vite@5.0.12 to resolve CVE-2024-23331 ([39b76d3](https://github.com/wxt-dev/wxt/commit/39b76d3))
+
+### 📖 Documentation
+
+- Fixed doc errors on the guide/extension-api page ([#383](https://github.com/wxt-dev/wxt/pull/383))
+
+### 🏡 Chore
+
+- Fix vite version conflicts in demo extension ([98d2792](https://github.com/wxt-dev/wxt/commit/98d2792))
+
+### ❤️ Contributors
+
+- 0x7a7a ([@0x7a7a](https://github.com/0x7a7a))
+
+## v0.15.0
+
+[compare changes](https://github.com/wxt-dev/wxt/compare/v0.14.7...v0.15.0)
+
+### 🚀 Enhancements
+
+- **zip:** ⚠️  Add `includeSources` and rename `ignoredSources` to `excludeSources` ([#378](https://github.com/wxt-dev/wxt/pull/378))
+
+### 🩹 Fixes
+
+- Generate missing sourcemap in `wxt:unimport` plugin ([#381](https://github.com/wxt-dev/wxt/pull/381))
+- ⚠️  Move browser constants to `import.meta.env` ([#380](https://github.com/wxt-dev/wxt/pull/380))
+- Enable inline sourcemaps by default during development ([#382](https://github.com/wxt-dev/wxt/pull/382))
+
+### 📖 Documentation
+
+- Fix typo ([f9718a1](https://github.com/wxt-dev/wxt/commit/f9718a1))
+
+### 🏡 Chore
+
+- Update contributor docs ([eb758bd](https://github.com/wxt-dev/wxt/commit/eb758bd))
+
+#### ⚠️ Breaking Changes
+
+Renamed `zip.ignoredSources` to `zip.excludeSources` in [#378](https://github.com/wxt-dev/wxt/pull/378)
+
+Renamed undocumented constants for detecting the build config at runtime in [#380](https://github.com/wxt-dev/wxt/pull/380). Now documented here: https://wxt.dev/guide/multiple-browsers.html#runtime
+
+- `__BROWSER__` &rarr; `import.meta.env.BROWSER`
+- `__COMMAND__` &rarr; `import.meta.env.COMMAND`
+- `__MANIFEST_VERSION__` &rarr; `import.meta.env.MANIFEST_VERSION`
+- `__IS_CHROME__` &rarr; `import.meta.env.CHROME`
+- `__IS_FIREFOX__` &rarr; `import.meta.env.FIREFOX`
+- `__IS_SAFARI__` &rarr; `import.meta.env.SAFARI`
+- `__IS_EDGE__` &rarr; `import.meta.env.EDGE`
+- `__IS_OPERA__` &rarr; `import.meta.env.OPERA`
+
+### ❤️ Contributors
+
+- Nenad Novaković ([@dvlden](https://github.com/dvlden))
+
 ## v0.14.7
 
 [compare changes](https://github.com/wxt-dev/wxt/compare/v0.14.6...v0.14.7)

CONTRIBUTING.md

@@ -57,9 +57,17 @@ pnpm test
 pnpm docs:dev
 ```
 
+## Updating Docs
+
+Documentation is written with VitePress, and is located in the `docs/` directory.
+
+The API reference is generated from JSDoc comments in the source code. If there's a typo or change you want to make in there, you'll need to update the source code instead of a file in the `docs/` directory.
+
 ## Testing
 
-WXT has unit and E2E tests. When making a change or adding a feature, make sure to update the tests or add new ones.
+WXT has unit and E2E tests. When making a change or adding a feature, make sure to update the tests or add new ones, if they exist.
+
+> If they don't exist, feel free to create them, but that's a lot for a one-time contributor. A maintainer might add them to your PR though.
 
 To run tests for a specific file, add the filename at the end of the test command:
 

demo/src/entrypoints/background.ts

@@ -1,37 +1,41 @@
 import messages from 'public/_locales/en/messages.json';
 
-export default defineBackground(() => {
-  console.log(browser.runtime.id);
-  logId();
-  console.log({
-    browser: __BROWSER__,
-    chrome: __IS_CHROME__,
-    firefox: __IS_FIREFOX__,
-    manifestVersion: __MANIFEST_VERSION__,
-    messages,
-  });
+export default defineBackground({
+  // type: 'module',
 
-  // @ts-expect-error: should only accept entrypoints or public assets
-  browser.runtime.getURL('/');
-  browser.runtime.getURL('/background.js');
-  browser.runtime.getURL('/icon/128.png');
-  browser.runtime.getURL('/example.html#hash');
-  browser.runtime.getURL('/example.html?query=param');
-  // @ts-expect-error: should only allow hashes/query params on HTML files
-  browser.runtime.getURL('/icon-128.png?query=param');
+  main() {
+    console.log(browser.runtime.id);
+    logId();
+    console.log({
+      browser: import.meta.env.BROWSER,
+      chrome: import.meta.env.CHROME,
+      firefox: import.meta.env.FIREFOX,
+      manifestVersion: import.meta.env.MANIFEST_VERSION,
+      messages,
+    });
 
-  // @ts-expect-error: should only accept known message names
-  browser.i18n.getMessage('test');
-  browser.i18n.getMessage('prompt_for_name');
-  browser.i18n.getMessage('hello', 'Aaron');
-  browser.i18n.getMessage('bye', ['Aaron']);
-  browser.i18n.getMessage('@@extension_id');
+    // @ts-expect-error: should only accept entrypoints or public assets
+    browser.runtime.getURL('/');
+    browser.runtime.getURL('/background.js');
+    browser.runtime.getURL('/icon/128.png');
+    browser.runtime.getURL('/example.html#hash');
+    browser.runtime.getURL('/example.html?query=param');
+    // @ts-expect-error: should only allow hashes/query params on HTML files
+    browser.runtime.getURL('/icon-128.png?query=param');
 
-  console.log('WXT MODE:', {
-    MODE: import.meta.env.MODE,
-    DEV: import.meta.env.DEV,
-    PROD: import.meta.env.PROD,
-  });
+    // @ts-expect-error: should only accept known message names
+    browser.i18n.getMessage('test');
+    browser.i18n.getMessage('prompt_for_name');
+    browser.i18n.getMessage('hello', 'Aaron');
+    browser.i18n.getMessage('bye', ['Aaron']);
+    browser.i18n.getMessage('@@extension_id');
 
-  storage.setItem('session:startTime', Date.now());
+    console.log('WXT MODE:', {
+      MODE: import.meta.env.MODE,
+      DEV: import.meta.env.DEV,
+      PROD: import.meta.env.PROD,
+    });
+
+    storage.setItem('session:startTime', Date.now());
+  },
 });

docs/.vitepress/components/UsingWxtSection.vue

@@ -17,6 +17,7 @@ const chromeExtensionIds = [
   'okifoaikfmpfcamplcfjkpdnhfodpkil', // Doozy: Ai Made Easy
   'lknmjhcajhfbbglglccadlfdjbaiifig', // tl;dv - Record, Transcribe & ChatGPT for Google Meet
   'youtube中文配音/oglffgiaiekgeicdgkdlnlkhliajdlja', // Youtube中文配音
+  'agjnjboanicjcpenljmaaigopkgdnihi', // PreMiD
 ];
 
 const { data } = useListExtensionDetails(chromeExtensionIds);

docs/.vitepress/config.ts

@@ -90,6 +90,7 @@ export default defineConfig({
             { text: 'Assets', link: '/guide/assets.md' },
             { text: 'Content Script UI', link: '/guide/content-script-ui.md' },
             { text: 'Multiple Browsers', link: '/guide/multiple-browsers.md' },
+            { text: 'ES Modules', link: '/guide/esm.md' },
             { text: 'Auto-imports', link: '/guide/auto-imports.md' },
             { text: 'Vite', link: '/guide/vite.md' },
             { text: 'Remote Code', link: '/guide/remote-code.md' },

docs/guide/esm.md

@@ -0,0 +1,38 @@
+# ES Modules
+
+Configure entrypoints to use ESM at runtime.
+
+Currently, ESM entrypoints are opt-in, so you must configure each entrypoint with that in mind.
+
+## HTML Pages <Badge type="warning" text="≥0.0.1" />
+
+In general, you should always make HTML pages import ESM scripts, unless you need to support old browsers.
+
+To make a script ESM, add `type="module"`:
+
+<!-- prettier-ignore -->
+```html
+<script src="./main.ts"></script> <!-- [!code --] -->
+<script src="./main.ts" type="module"></script> <!-- [!code ++] -->
+```
+
+## Background <Badge type="warning" text="≥0.16.0" />
+
+In your background script, set `type: "module"`:
+
+```ts
+export default defineBackground({
+  type: 'module', // !code ++
+  main() {
+    // ...
+  },
+});
+```
+
+:::warning
+Only MV3 support ESM background scripts/service workers. When targetting MV2, the `type` option is ignored and the background is always bundled into a single file as IIFE.
+:::
+
+## Content Scripts
+
+Coming soon. Follow [Content Script ESM Support #357](https://github.com/wxt-dev/wxt/issues/357) for updates.

docs/guide/extension-apis.md

@@ -57,21 +57,19 @@ Here's a basic request/response example:
 // popup/main.ts
 const res = await browser.runtime.sendMessage('ping');
 
-console.log('res'); // "pong"
+console.log(res); // "pong"
 ```
 
 ```ts
 // background.ts
 export default defineBackground(() => {
-  browser.runtime.onMessage.addEventListener(
-    (message, sender, sendResponse) => {
-      console.log(message); // "ping"
+  browser.runtime.onMessage.addListener((message, sender, sendResponse) => {
+    console.log(message); // "ping"
 
-      // Wait 1 second and respond with "pong"
-      setTimeout(() => sendResponse('pong'), 1000);
-      return true;
-    },
-  );
+    // Wait 1 second and respond with "pong"
+    setTimeout(() => sendResponse('pong'), 1000);
+    return true;
+  });
 });
 ```
 

docs/guide/installation.md

@@ -145,5 +145,6 @@ If you're an experienced web extension developer and think the dev manifest look
 You're ready to build your web extension!
 
 - Learn how to [add entrypoints](./entrypoints) like the popup, options page, or content scripts
+- Configure your entrypoints to [use ESM](./esm) at runtime
 - [Configure WXT](./configuration) by creating a `wxt.config.ts` file
 - Checkout [example projects](https://github.com/wxt-dev/wxt-examples) to see how to perfom common tasks with WXT

docs/guide/multiple-browsers.md

@@ -115,19 +115,19 @@ Only `defineBackground` and `defineContentScript` support per-browser options ri
 
 To determine the browser or manifest version at runtime, you can use any of the below variables:
 
-- `__BROWSER__`: A string, the target browser, usually equal to the `--browser` flag
-- `__MANIFEST_VERSION__`: A number, either `2` or `3`, depending on the manifest version targetted
-- `__IS_CHROME__`: A boolean equivalent to `__BROWSER__ === "chrome"`
-- `__IS_FIREFOX__`: A boolean equivalent to `__BROWSER__ === "firefox"`
-- `__IS_EDGE__`: A boolean equivalent to `__BROWSER__ === "edge"`
-- `__IS_SAFARI__`: A boolean equivalent to `__BROWSER__ === "safari"`
-- `__IS_OPERA__`: A boolean equivalent to `__BROWSER__ === "opera"`
-- `__COMMAND__`: A string, `"serve"` when running `wxt` for development or `"build"` in all other cases.
+- `import.meta.env.BROWSER`: A string, the target browser, usually equal to the `--browser` flag
+- `import.meta.env.MANIFEST_VERSION`: A number, either `2` or `3`, depending on the manifest version targetted
+- `import.meta.env.CHROME`: A boolean equivalent to `import.meta.env.BROWSER === "chrome"`
+- `import.meta.env.FIREFOX`: A boolean equivalent to `import.meta.env.BROWSER === "firefox"`
+- `import.meta.env.EDGE`: A boolean equivalent to `import.meta.env.BROWSER === "edge"`
+- `import.meta.env.SAFARI`: A boolean equivalent to `import.meta.env.BROWSER === "safari"`
+- `import.meta.env.OPERA`: A boolean equivalent to `import.meta.env.BROWSER === "opera"`
+- `import.meta.env.COMMAND`: A string, `"serve"` when running `wxt` for development or `"build"` in all other cases.
 
 :::info
 These variables are constants defined at build time based on the build target. They do not actually detect which browser the code is running in.
 
-For example, if you build for `--browser chrome` and publish it on Edge, `__BROWSER__` will be `"chrome"`, not `"edge"`. You have to build a separate ZIP for `--browser edge` before `__BROWSER__` will be `"edge"`.
+For example, if you build for `--browser chrome` and publish it on Edge, `import.meta.env.BROWSER` will be `"chrome"`, not `"edge"`. You have to build a separate ZIP for `--browser edge` before `import.meta.env.BROWSER` will be `"edge"`.
 
 If you need to know the actual browser your code is being ran on, you should use a [user agent parser](https://www.npmjs.com/package/ua-parser-js).
 :::

docs/guide/publishing.md

@@ -1,94 +1,66 @@
+---
+outline: deep
+---
+
 # Publishing
 
-WXT offers several utilities that simplify the publishing process.
+WXT will help you ZIP your extensions and submit them to the stores for review.
 
 ## First Time Publishing
 
-If you're publishing an extension to a store for the first time, you must manually navigate the process. Each store has unique steps and requirements that you need to familiarize yourself with.
+If you're publishing an extension to a store for the first time, you must manually navigate the process. WXT doesn't help you create listings, each store has unique steps and requirements that you need to familiarize yourself with.
 
-Each store requires that a ZIP file be uploaded. You can generate these using the `wxt zip` command:
+For specific details about each store, see the stores sections below.
+
+- [Chrome Web Store](#chrome-web-store)
+- [Firefox Addon Store](#firefox-addon-store)
+- [Edge Addons](#edge-addons)
+
+## Automation
+
+WXT provides two commands to help automate the release process:
+
+- `wxt submit`: Submit new versions of your extension for review (and publish them automatically once approved)
+- `wxt submit init`: Help setup all the required secrets and options for the `wxt submit` command
+
+To get started, run `wxt submit init` and follow the prompts. Once finished, you should have a `.env.submit` file! WXT will use this file to submit your updates.
+
+> In CI, make sure you add all the environment variables to the submit step.
+
+To release an update, build all the ZIPs you plan on releasing:
 
 ```sh
 wxt zip
 wxt zip -b firefox
-# etc
 ```
 
-Generated ZIP files are stored in the `.output` directory.
+Then run the `wxt submit` command, passing in all the ZIP files you want to release. In this case, we'll do a release for all 3 major stores: Chrome Web Store, Edge Addons, and Firefox Addons Store.
 
-## Automation
+If it's your first time running the command, you'll want to test your secrets by passing the `--dry-run` flag:
 
-To automate releasing updates, use the [`publish-browser-extension`](https://www.npmjs.com/package/publish-browser-extension) package.
+```sh
+wxt submit --dry-run \
+  --chrome-zip .output/<your-extension>-<version>-chrome.zip \
+  --firefox-zip .output/<your-extension>-<version>-firefox.zip --firefox-sources-zip .output/<your-extension>-<version>-sources.zip \
+  --edge-zip .output/<your-extension>-<version>-chrome.zip
+```
 
-:::info
-🚧 WXT plans to eventually incorporate the `publish-browser-extension` package into its own `wxt submit` command.
+If the dry run passes, remove the flag and do the actual release:
+
+```sh
+wxt submit \
+  --chrome-zip .output/<your-extension>-<version>-chrome.zip \
+  --firefox-zip .output/<your-extension>-<version>-firefox.zip --firefox-sources-zip .output/<your-extension>-<version>-sources.zip \
+  --edge-zip .output/<your-extension>-<version>-chrome.zip
+```
+
+:::tip
+If you only need to release to a single store, only pass that store's ZIP flag.
 :::
 
-1. Install the necessary dependencies:
-
-   ```sh
-   pnpm add -D publish-browser-extension env-cmd
-   ```
-
-2. Add scripts to your `package.json` file:
-
-   ```json
-   {
-     "scripts": {
-       "submit": "env-cmd -f .env.submit -- publish-extension",
-       "submit:dry": "env-cmd -f .env.submit -- publish-extension --dry-run"
-     }
-   }
-   ```
-
-3. Create a `.env.submit` file and include the code below. If you're not publishing to certain stores, simply ignore their respective variables.
-
-   ```txt
-   CHROME_EXTENSION_ID=""
-   CHROME_CLIENT_ID=""
-   CHROME_CLIENT_SECRET=""
-   CHROME_REFRESH_TOKEN=""
-
-   FIREFOX_EXTENSION_ID=""
-   FIREFOX_JWT_ISSUER=""
-   FIREFOX_JWT_SECRET=""
-
-   EDGE_PRODUCT_ID=""
-   EDGE_CLIENT_ID=""
-   EDGE_CLIENT_SECRET=""
-   EDGE_ACCESS_TOKEN_URL=""
-   ```
-
-   > Each value will be filled in during the next step.
-
-4. Run `npx publish-extension --help` for assistance with filling out all the values. Insert the obtained values within the double quotes.
-
-5. ZIP all the targets you plan to publish, in this case Chrome and Firefox.
-
-   ```sh
-   wxt zip
-   wxt zip -b firefox
-   ```
-
-6. Test your credentials by running the `submit:dry` command:
-
-   ```sh
-   pnpm submit:dry \
-     --chrome-zip .output/your-extension-X.Y.Z-chrome.zip \
-     --firefox-zip .output/your-extension-X.Y.Z-firefox.zip \
-     --firefox-sources-zip .output/your-extension-X.Y.Z-sources.zip \
-     --edge-zip .output/your-extension-X.Y.Z-chrome.zip
-   ```
-
-7. Upload and submit your extension for review:
-
-   ```sh
-   pnpm submit \
-     --chrome-zip .output/your-extension-X.Y.Z-chrome.zip \
-     --firefox-zip .output/your-extension-X.Y.Z-firefox.zip \
-     --firefox-sources-zip .output/your-extension-X.Y.Z-sources.zip \
-     --edge-zip .output/your-extension-X.Y.Z-chrome.zip
-   ```
+:::tip
+See the [Firefox Addon Store](#firefox-addon-store) section for more details about the `--firefox-sources-zip` option.
+:::
 
 ## GitHub Action
 
@@ -98,9 +70,11 @@ Here's an example of a GitHub Action to automate submiting new versions of your
 # TODO
 ```
 
-## Chrome Web Store
+## Stores
 
-✅ Automated &bull; [Developer Dashboard](https://chrome.google.com/webstore/developer/dashboard) &bull; [Publishing Docs](https://developer.chrome.com/docs/webstore/publish/)
+### Chrome Web Store
+
+> ✅ Supported &bull; [Developer Dashboard](https://chrome.google.com/webstore/developer/dashboard) &bull; [Publishing Docs](https://developer.chrome.com/docs/webstore/publish/)
 
 To create a ZIP for Chrome:
 
@@ -108,15 +82,15 @@ To create a ZIP for Chrome:
 wxt zip
 ```
 
-## Firefox Addon Store
+### Firefox Addon Store
 
-✅ Automated &bull; [Developer Dashboard](https://addons.mozilla.org/developers/) &bull; [Publishing Docs](https://extensionworkshop.com/documentation/publish/submitting-an-add-on/)
+> ✅ Supported &bull; [Developer Dashboard](https://addons.mozilla.org/developers/) &bull; [Publishing Docs](https://extensionworkshop.com/documentation/publish/submitting-an-add-on/)
 
 Firefox requires you to upload a ZIP of your source code. This allows them to rebuild your extension and review the code in a readable way. More details can be found in [Firefox's docs](https://extensionworkshop.com/documentation/publish/source-code-submission/).
 
-WXT and `publish-browser-extension` both fully support generating and automatically submitting a source code ZIP.
+WXT fully supports generating and automatically submitting a source code ZIP.
 
-When you run `wxt zip -b firefox`, your sources are zipped into the `.output` directory along with your built extension. WXT is configured to exclude certain files such as config files, hidden files, and tests. However, it's important to manually check the ZIP to ensure it only contains the files necessary to rebuild your extension.
+When you run `wxt zip -b firefox`, your sources are zipped into the `.output` directory alongside the extension. WXT will automatically exclude certain files such as config files, hidden files, and tests. However, it's important to manually check the ZIP to ensure it only contains the files necessary to rebuild your extension.
 
 To customize which files are zipped, add the `zip` option to your config file.
 
@@ -152,22 +126,34 @@ yarn zip:firefox
 
 :::
 
-Ensure that you have a `README.md` or `SOURCE_CODE_REVIEW.md` file with the above commands so that the Firefox team knows how to build your extension.
-
-## Safari
-
-🚧 Not automated at this time
+Make sure the build output is the exact same when running `wxt build -b firefox` in your main project and inside the zipped sources.
 
 :::warning
-🚧 WXT does not currently support automated publishing for Safari. Safari extensions require a native MacOS or iOS app wrapper, which WXT cannot create at this time. For now, if you want to publish to Safari, follow this guide:
-
-https://developer.apple.com/documentation/safariservices/safari_web_extensions/distributing_your_safari_web_extension
+If you use a `.env` files, they can effect the chunk hashes in the output directory. Either delete the .env file before running `wxt zip -b firefox`, or include it in your sources zip with the [`zip.includeSources`](/api/wxt/interfaces/InlineConfig#includesources) option. Be careful to not include any secrets in your `.env` files.
 
+See Issue [#377](https://github.com/wxt-dev/wxt/issues/377) for more details.
 :::
 
-## Edge Addons
+Ensure that you have a `README.md` or `SOURCE_CODE_REVIEW.md` file with the above commands so that the Firefox team knows how to build your extension.
 
-✅ Automated &bull; [Developer Dashboard](https://aka.ms/PartnerCenterLogin) &bull; [Publishing Docs](https://learn.microsoft.com/en-us/microsoft-edge/extensions-chromium/publish/publish-extension)
+### Safari
+
+> 🚧 Not supported yet
+
+WXT does not currently support automated publishing for Safari. Safari extensions require a native MacOS or iOS app wrapper, which WXT does not create yet. For now, if you want to publish to Safari, follow this guide:
+
+- [Converting a web extension for Safari](https://developer.apple.com/documentation/safariservices/safari_web_extensions/converting_a_web_extension_for_safari) - "Convert your existing extension to a Safari web extension using Xcode’s command-line tool."
+
+When running the `safari-web-extension-converter` CLI tool, pass the `.output/safari-mv2` or `.output/safari-mv3` directory, not your source code directory.
+
+```sh
+pnpm wxt build -b safari
+xcrun safari-web-extension-converter .output/safari-mv2
+```
+
+### Edge Addons
+
+> ✅ Supported &bull; [Developer Dashboard](https://aka.ms/PartnerCenterLogin) &bull; [Publishing Docs](https://learn.microsoft.com/en-us/microsoft-edge/extensions-chromium/publish/publish-extension)
 
 No need to create a specific ZIP for Edge. If you're already publishing to the Chrome Web Store, you can reuse your Chrome ZIP.
 

docs/guide/testing.md

@@ -19,7 +19,7 @@ If you want to try to use a different framework for unit tests, you will need to
 - **Auto-imports**: Add `unimport` to your test environment or disable them by setting `imports: false` in your `wxt.config.ts` file
 - **`browser` mock**: Mock the `webextension-polyfill` module globally with `wxt/dist/virtual/mock-browser.js`
 - **[Remote Code Bundling](/guide/remote-code)**: If you use it, configure your environment to handle the `url:` module prefix
-- **Global Variables**: If you consume them, manually define globals provided by WXT (like `__BROWSER__`) by adding them to the global scope before accessing them (`globalThis.__BROWSER__ = "chrome"`)
+- **Global Variables**: If you consume them, manually define globals provided by WXT (like `import.meta.env.BROWSER`) by adding them to the global scope before accessing them (`import.meta.env.BROWSER = "chrome"`)
 - **Import paths**: If you use the `@/` or `~/` path aliases, add them to your test environment
 
 [Here's how Vitest is configured](https://github.com/wxt-dev/wxt/blob/main/src/testing/wxt-vitest-plugin.ts) for reference.

e2e/tests/output-structure.test.ts

@@ -227,4 +227,169 @@ describe('Output Directory Structure', () => {
       true,
     );
   });
+
+  it('should generate ESM background script when type=module', async () => {
+    const project = new TestProject();
+    project.addFile(
+      'utils/log.ts',
+      `export function logHello(name: string) {
+        console.log(\`Hello \${name}!\`);
+      }`,
+    );
+    project.addFile(
+      'entrypoints/background.ts',
+      `export default defineBackground({
+        type: "module",
+        main() {
+          logHello("background");
+        },
+      })`,
+    );
+    project.addFile(
+      'entrypoints/popup/index.html',
+      `<html>
+        <head>
+          <script type="module" src="./main.ts"></script>
+        </head>
+      </html>`,
+    );
+    project.addFile('entrypoints/popup/main.ts', `logHello('popup')`);
+
+    await project.build({
+      experimental: {
+        // Simplify the build output for comparison
+        includeBrowserPolyfill: false,
+      },
+      vite: () => ({
+        build: {
+          // Make output for snapshot readible
+          minify: false,
+        },
+      }),
+    });
+
+    expect(await project.serializeFile('.output/chrome-mv3/background.js'))
+      .toMatchInlineSnapshot(`
+      ".output/chrome-mv3/background.js
+      ----------------------------------------
+      import { l as logHello } from "./chunks/log-bezs0tt4.js";
+      function defineBackground(arg) {
+        if (typeof arg === "function")
+          return { main: arg };
+        return arg;
+      }
+      const definition = defineBackground({
+        type: "module",
+        main() {
+          logHello("background");
+        }
+      });
+      chrome;
+      function print(method, ...args) {
+        return;
+      }
+      var logger = {
+        debug: (...args) => print(console.debug, ...args),
+        log: (...args) => print(console.log, ...args),
+        warn: (...args) => print(console.warn, ...args),
+        error: (...args) => print(console.error, ...args)
+      };
+      try {
+        const res = definition.main();
+        if (res instanceof Promise) {
+          console.warn(
+            "The background's main() function return a promise, but it must be synchonous"
+          );
+        }
+      } catch (err) {
+        logger.error("The background crashed on startup!");
+        throw err;
+      }
+      "
+    `);
+  });
+
+  it('should generate IIFE background script when type=undefined', async () => {
+    const project = new TestProject();
+    project.addFile(
+      'utils/log.ts',
+      `export function logHello(name: string) {
+          console.log(\`Hello \${name}!\`);
+        }`,
+    );
+    project.addFile(
+      'entrypoints/background.ts',
+      `export default defineBackground({
+          main() {
+            logHello("background");
+          },
+        })`,
+    );
+    project.addFile(
+      'entrypoints/popup/index.html',
+      `<html>
+          <head>
+            <script type="module" src="./main.ts"></script>
+          </head>
+        </html>`,
+    );
+    project.addFile('entrypoints/popup/main.ts', `logHello('popup')`);
+
+    await project.build({
+      experimental: {
+        // Simplify the build output for comparison
+        includeBrowserPolyfill: false,
+      },
+      vite: () => ({
+        build: {
+          // Make output for snapshot readible
+          minify: false,
+        },
+      }),
+    });
+
+    expect(await project.serializeFile('.output/chrome-mv3/background.js'))
+      .toMatchInlineSnapshot(`
+        ".output/chrome-mv3/background.js
+        ----------------------------------------
+        (function() {
+          "use strict";
+          function defineBackground(arg) {
+            if (typeof arg === "function")
+              return { main: arg };
+            return arg;
+          }
+          function logHello(name) {
+            console.log(\`Hello \${name}!\`);
+          }
+          const definition = defineBackground({
+            main() {
+              logHello("background");
+            }
+          });
+          chrome;
+          function print(method, ...args) {
+            return;
+          }
+          var logger = {
+            debug: (...args) => print(console.debug, ...args),
+            log: (...args) => print(console.log, ...args),
+            warn: (...args) => print(console.warn, ...args),
+            error: (...args) => print(console.error, ...args)
+          };
+          try {
+            const res = definition.main();
+            if (res instanceof Promise) {
+              console.warn(
+                "The background's main() function return a promise, but it must be synchonous"
+              );
+            }
+          } catch (err) {
+            logger.error("The background crashed on startup!");
+            throw err;
+          }
+        })();
+        "
+      `);
+  });
 });

e2e/tests/typescript-project.test.ts

@@ -14,16 +14,19 @@ describe('TypeScript Project', () => {
       ----------------------------------------
       // Generated by wxt
       export {}
-      declare global {
-        const __MANIFEST_VERSION__: 2 | 3;
-        const __BROWSER__: string;
-        const __IS_CHROME__: boolean;
-        const __IS_FIREFOX__: boolean;
-        const __IS_SAFARI__: boolean;
-        const __IS_EDGE__: boolean;
-        const __IS_OPERA__: boolean;
-        const __COMMAND__: "build" | "serve";
-        const __ENTRYPOINT__: string;
+      interface ImportMetaEnv {
+        readonly MANIFEST_VERSION: 2 | 3;
+        readonly BROWSER: string;
+        readonly CHROME: boolean;
+        readonly FIREFOX: boolean;
+        readonly SAFARI: boolean;
+        readonly EDGE: boolean;
+        readonly OPERA: boolean;
+        readonly COMMAND: "build" | "serve";
+        readonly ENTRYPOINT: string;
+      }
+      interface ImportMeta {
+        readonly env: ImportMetaEnv
       }
       "
     `);
@@ -133,7 +136,7 @@ describe('TypeScript Project', () => {
             options?: GetMessageOptions,
           ): string;
           /**
-           * 
+           * No message description.
            *
            * "<browser.i18n.getUiLocale()>"
            */

package.json

@@ -1,7 +1,7 @@
 {
   "name": "wxt",
   "type": "module",
-  "version": "0.14.7",
+  "version": "0.16.1",
   "description": "Next gen framework for developing web extensions",
   "engines": {
     "node": ">=18",
@@ -82,7 +82,7 @@
     }
   },
   "scripts": {
-    "wxt": "tsx src/cli.ts",
+    "wxt": "tsx src/cli/index.ts",
     "build": "tsx scripts/build.ts",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
@@ -132,10 +132,11 @@
     "ora": "^7.0.1",
     "picocolors": "^1.0.0",
     "prompts": "^2.4.2",
+    "publish-browser-extension": "^2.1.1",
     "rollup-plugin-visualizer": "^5.9.2",
     "unimport": "^3.4.0",
-    "vite": "^5.0.0",
-    "web-ext-run": "^0.1.2",
+    "vite": "^5.0.12",
+    "web-ext-run": "^0.2.0",
     "webextension-polyfill": "^0.10.0",
     "zip-dir": "^2.0.0"
   },

scripts/build.ts

@@ -94,7 +94,7 @@ const config: tsup.Options[] = [
   {
     ...preset,
     entry: {
-      cli: 'src/cli.ts',
+      cli: 'src/cli/index.ts',
     },
     format: ['esm'],
     banner: {

src/cli/__tests__/index.test.ts

@@ -1,29 +1,29 @@
 import { describe, it, vi, beforeEach, expect } from 'vitest';
-import { build } from '../core/build';
-import { createServer } from '../core/create-server';
-import { zip } from '../core/zip';
-import { prepare } from '../core/prepare';
-import { clean } from '../core/clean';
-import { initialize } from '../core/initialize';
+import { build } from '~/core/build';
+import { createServer } from '~/core/create-server';
+import { zip } from '~/core/zip';
+import { prepare } from '~/core/prepare';
+import { clean } from '~/core/clean';
+import { initialize } from '~/core/initialize';
 import { mock } from 'vitest-mock-extended';
 import consola from 'consola';
 
-vi.mock('../core/build');
+vi.mock('~/core/build');
 const buildMock = vi.mocked(build);
 
-vi.mock('../core/create-server');
+vi.mock('~/core/create-server');
 const createServerMock = vi.mocked(createServer);
 
-vi.mock('../core/zip');
+vi.mock('~/core/zip');
 const zipMock = vi.mocked(zip);
 
-vi.mock('../core/prepare');
+vi.mock('~/core/prepare');
 const prepareMock = vi.mocked(prepare);
 
-vi.mock('../core/clean');
+vi.mock('~/core/clean');
 const cleanMock = vi.mocked(clean);
 
-vi.mock('../core/initialize');
+vi.mock('~/core/initialize');
 const initializeMock = vi.mocked(initialize);
 
 consola.wrapConsole();
@@ -34,6 +34,10 @@ function mockArgv(...args: string[]) {
   process.argv = ['/bin/node', 'bin/wxt.mjs', ...args];
 }
 
+async function importCli() {
+  await import('~/cli');
+}
+
 describe('CLI', () => {
   beforeEach(() => {
     vi.resetModules();
@@ -44,14 +48,14 @@ describe('CLI', () => {
   describe('dev', () => {
     it('should not pass any config when no flags are passed', async () => {
       mockArgv();
-      await import('../cli');
+      await importCli();
 
       expect(createServerMock).toBeCalledWith({});
     });
 
     it('should respect passing a custom root', async () => {
       mockArgv('path/to/root');
-      await import('../cli');
+      await importCli();
 
       expect(createServerMock).toBeCalledWith({
         root: 'path/to/root',
@@ -60,7 +64,7 @@ describe('CLI', () => {
 
     it('should respect a custom config file', async () => {
       mockArgv('-c', './path/to/config.ts');
-      await import('../cli');
+      await importCli();
 
       expect(createServerMock).toBeCalledWith({
         configFile: './path/to/config.ts',
@@ -69,7 +73,7 @@ describe('CLI', () => {
 
     it('should respect passing a custom mode', async () => {
       mockArgv('-m', 'development');
-      await import('../cli');
+      await importCli();
 
       expect(createServerMock).toBeCalledWith({
         mode: 'development',
@@ -78,7 +82,7 @@ describe('CLI', () => {
 
     it('should respect passing a custom browser', async () => {
       mockArgv('-b', 'firefox');
-      await import('../cli');
+      await importCli();
 
       expect(createServerMock).toBeCalledWith({
         browser: 'firefox',
@@ -87,7 +91,7 @@ describe('CLI', () => {
 
     it('should pass correct filtered entrypoints', async () => {
       mockArgv('-e', 'popup', '-e', 'options');
-      await import('../cli');
+      await importCli();
 
       expect(createServerMock).toBeCalledWith({
         filterEntrypoints: ['popup', 'options'],
@@ -96,7 +100,7 @@ describe('CLI', () => {
 
     it('should respect passing --mv2', async () => {
       mockArgv('--mv2');
-      await import('../cli');
+      await importCli();
 
       expect(createServerMock).toBeCalledWith({
         manifestVersion: 2,
@@ -105,7 +109,7 @@ describe('CLI', () => {
 
     it('should respect passing --mv3', async () => {
       mockArgv('--mv3');
-      await import('../cli');
+      await importCli();
 
       expect(createServerMock).toBeCalledWith({
         manifestVersion: 3,
@@ -114,7 +118,7 @@ describe('CLI', () => {
 
     it('should respect passing --debug', async () => {
       mockArgv('--debug');
-      await import('../cli');
+      await importCli();
 
       expect(createServerMock).toBeCalledWith({
         debug: true,
@@ -125,14 +129,14 @@ describe('CLI', () => {
   describe('build', () => {
     it('should not pass any config when no flags are passed', async () => {
       mockArgv('build');
-      await import('../cli');
+      await importCli();
 
       expect(buildMock).toBeCalledWith({});
     });
 
     it('should respect passing a custom root', async () => {
       mockArgv('build', 'path/to/root');
-      await import('../cli');
+      await importCli();
 
       expect(buildMock).toBeCalledWith({
         root: 'path/to/root',
@@ -141,7 +145,7 @@ describe('CLI', () => {
 
     it('should respect a custom config file', async () => {
       mockArgv('build', '-c', './path/to/config.ts');
-      await import('../cli');
+      await importCli();
 
       expect(buildMock).toBeCalledWith({
         configFile: './path/to/config.ts',
@@ -150,7 +154,7 @@ describe('CLI', () => {
 
     it('should respect passing a custom mode', async () => {
       mockArgv('build', '-m', 'development');
-      await import('../cli');
+      await importCli();
 
       expect(buildMock).toBeCalledWith({
         mode: 'development',
@@ -159,7 +163,7 @@ describe('CLI', () => {
 
     it('should respect passing a custom browser', async () => {
       mockArgv('build', '-b', 'firefox');
-      await import('../cli');
+      await importCli();
 
       expect(buildMock).toBeCalledWith({
         browser: 'firefox',
@@ -168,7 +172,7 @@ describe('CLI', () => {
 
     it('should pass correct filtered entrypoints', async () => {
       mockArgv('build', '-e', 'popup', '-e', 'options');
-      await import('../cli');
+      await importCli();
 
       expect(buildMock).toBeCalledWith({
         filterEntrypoints: ['popup', 'options'],
@@ -177,7 +181,7 @@ describe('CLI', () => {
 
     it('should respect passing --mv2', async () => {
       mockArgv('build', '--mv2');
-      await import('../cli');
+      await importCli();
 
       expect(buildMock).toBeCalledWith({
         manifestVersion: 2,
@@ -186,7 +190,7 @@ describe('CLI', () => {
 
     it('should respect passing --mv3', async () => {
       mockArgv('build', '--mv3');
-      await import('../cli');
+      await importCli();
 
       expect(buildMock).toBeCalledWith({
         manifestVersion: 3,
@@ -195,7 +199,7 @@ describe('CLI', () => {
 
     it('should include analysis in the build', async () => {
       mockArgv('build', '--analyze');
-      await import('../cli');
+      await importCli();
 
       expect(buildMock).toBeCalledWith({
         analysis: {
@@ -206,7 +210,7 @@ describe('CLI', () => {
 
     it('should respect passing --debug', async () => {
       mockArgv('build', '--debug');
-      await import('../cli');
+      await importCli();
 
       expect(buildMock).toBeCalledWith({
         debug: true,
@@ -217,14 +221,14 @@ describe('CLI', () => {
   describe('zip', () => {
     it('should not pass any config when no flags are passed', async () => {
       mockArgv('zip');
-      await import('../cli');
+      await importCli();
 
       expect(zipMock).toBeCalledWith({});
     });
 
     it('should respect passing a custom root', async () => {
       mockArgv('zip', 'path/to/root');
-      await import('../cli');
+      await importCli();
 
       expect(zipMock).toBeCalledWith({
         root: 'path/to/root',
@@ -233,7 +237,7 @@ describe('CLI', () => {
 
     it('should respect a custom config file', async () => {
       mockArgv('zip', '-c', './path/to/config.ts');
-      await import('../cli');
+      await importCli();
 
       expect(zipMock).toBeCalledWith({
         configFile: './path/to/config.ts',
@@ -242,7 +246,7 @@ describe('CLI', () => {
 
     it('should respect passing a custom mode', async () => {
       mockArgv('zip', '-m', 'development');
-      await import('../cli');
+      await importCli();
 
       expect(zipMock).toBeCalledWith({
         mode: 'development',
@@ -251,7 +255,7 @@ describe('CLI', () => {
 
     it('should respect passing a custom browser', async () => {
       mockArgv('zip', '-b', 'firefox');
-      await import('../cli');
+      await importCli();
 
       expect(zipMock).toBeCalledWith({
         browser: 'firefox',
@@ -260,7 +264,7 @@ describe('CLI', () => {
 
     it('should respect passing --mv2', async () => {
       mockArgv('zip', '--mv2');
-      await import('../cli');
+      await importCli();
 
       expect(zipMock).toBeCalledWith({
         manifestVersion: 2,
@@ -269,7 +273,7 @@ describe('CLI', () => {
 
     it('should respect passing --mv3', async () => {
       mockArgv('zip', '--mv3');
-      await import('../cli');
+      await importCli();
 
       expect(zipMock).toBeCalledWith({
         manifestVersion: 3,
@@ -278,7 +282,7 @@ describe('CLI', () => {
 
     it('should respect passing --debug', async () => {
       mockArgv('zip', '--debug');
-      await import('../cli');
+      await importCli();
 
       expect(zipMock).toBeCalledWith({
         debug: true,
@@ -289,14 +293,14 @@ describe('CLI', () => {
   describe('prepare', () => {
     it('should not pass any config when no flags are passed', async () => {
       mockArgv('prepare');
-      await import('../cli');
+      await importCli();
 
       expect(prepareMock).toBeCalledWith({});
     });
 
     it('should respect passing a custom root', async () => {
       mockArgv('prepare', 'path/to/root');
-      await import('../cli');
+      await importCli();
 
       expect(prepareMock).toBeCalledWith({
         root: 'path/to/root',
@@ -305,7 +309,7 @@ describe('CLI', () => {
 
     it('should respect a custom config file', async () => {
       mockArgv('prepare', '-c', './path/to/config.ts');
-      await import('../cli');
+      await importCli();
 
       expect(prepareMock).toBeCalledWith({
         configFile: './path/to/config.ts',
@@ -314,7 +318,7 @@ describe('CLI', () => {
 
     it('should respect passing --debug', async () => {
       mockArgv('prepare', '--debug');
-      await import('../cli');
+      await importCli();
 
       expect(prepareMock).toBeCalledWith({
         debug: true,
@@ -325,14 +329,14 @@ describe('CLI', () => {
   describe('clean', () => {
     it('should not pass any config when no flags are passed', async () => {
       mockArgv('clean');
-      await import('../cli');
+      await importCli();
 
       expect(cleanMock).toBeCalledWith(undefined);
     });
 
     it('should respect passing a custom root', async () => {
       mockArgv('clean', 'path/to/root');
-      await import('../cli');
+      await importCli();
 
       expect(cleanMock).toBeCalledWith('path/to/root');
     });
@@ -341,14 +345,14 @@ describe('CLI', () => {
   describe('init', () => {
     it('should not pass any options when no flags are passed', async () => {
       mockArgv('init');
-      await import('../cli');
+      await importCli();
 
       expect(initializeMock).toBeCalledWith({});
     });
 
     it('should respect the provided folder', async () => {
       mockArgv('init', 'path/to/folder');
-      await import('../cli');
+      await importCli();
 
       expect(initializeMock).toBeCalledWith({
         directory: 'path/to/folder',
@@ -357,7 +361,7 @@ describe('CLI', () => {
 
     it('should respect passing --template', async () => {
       mockArgv('init', '-t', 'vue');
-      await import('../cli');
+      await importCli();
 
       expect(initializeMock).toBeCalledWith({
         template: 'vue',
@@ -366,7 +370,7 @@ describe('CLI', () => {
 
     it('should respect passing --pm', async () => {
       mockArgv('init', '--pm', 'pnpm');
-      await import('../cli');
+      await importCli();
 
       expect(initializeMock).toBeCalledWith({
         packageManager: 'pnpm',

src/cli/cli-utils.ts

@@ -0,0 +1,93 @@
+import { CAC, Command } from 'cac';
+import consola, { LogLevels } from 'consola';
+import { getInternalConfig } from '~/core/utils/building';
+import { exec } from '~/core/utils/exec';
+import { printHeader } from '~/core/utils/log';
+import { formatDuration } from '~/core/utils/time';
+import { ValidationError } from '~/core/utils/validation';
+
+/**
+ * Wrap an action handler to add a timer, error handling, and maybe enable debug mode.
+ */
+export function wrapAction(
+  cb: (
+    ...args: any[]
+  ) => void | { isOngoing?: boolean } | Promise<void | { isOngoing?: boolean }>,
+  options?: {
+    disableFinishedLog?: boolean;
+  },
+) {
+  return async (...args: any[]) => {
+    // Enable consola's debug mode globally at the start of all commands when the `--debug` flag is
+    // passed
+    const isDebug = !!args.find((arg) => arg?.debug);
+    if (isDebug) {
+      consola.level = LogLevels.debug;
+    }
+
+    const startTime = Date.now();
+    try {
+      printHeader();
+
+      const status = await cb(...args);
+
+      if (!status?.isOngoing && !options?.disableFinishedLog)
+        consola.success(
+          `Finished in ${formatDuration(Date.now() - startTime)}`,
+        );
+    } catch (err) {
+      consola.fail(
+        `Command failed after ${formatDuration(Date.now() - startTime)}`,
+      );
+      if (err instanceof ValidationError) {
+        // Don't log these errors, they've already been logged
+      } else {
+        consola.error(err);
+      }
+      process.exit(1);
+    }
+  };
+}
+
+/**
+ * Array flags, when not passed, are either `undefined` or `[undefined]`. This function filters out
+ * the
+ */
+export function getArrayFromFlags<T>(
+  flags: any,
+  name: string,
+): T[] | undefined {
+  const array = [flags[name]].flat() as Array<T | undefined>;
+  const result = array.filter((item) => item != null) as T[];
+  return result.length ? result : undefined;
+}
+
+const aliasCommandNames = new Set<string>();
+export function createAliasedCommand(
+  base: CAC,
+  name: string,
+  alias: string,
+  docsUrl: string,
+) {
+  const aliasedCommand = base
+    .command(name, `Alias for ${alias} (${docsUrl})`)
+    .allowUnknownOptions()
+    .action(async () => {
+      try {
+        const config = await getInternalConfig({}, 'build');
+        const args = process.argv.slice(
+          process.argv.indexOf(aliasedCommand.name) + 1,
+        );
+        await exec(config, alias, args, {
+          stdio: 'inherit',
+        });
+      } catch {
+        // Let the other aliased CLI log errors, just exit
+        process.exit(1);
+      }
+    });
+  aliasCommandNames.add(aliasedCommand.name);
+}
+export function isAliasedCommand(command: Command | undefined): boolean {
+  return !!command && aliasCommandNames.has(command.name);
+}

src/cli/commands.ts

@@ -1,17 +1,12 @@
 import cac from 'cac';
-import { version } from '~/version';
 import { build, clean, createServer, initialize, prepare, zip } from '~/core';
-import consola, { LogLevels } from 'consola';
-import { printHeader } from '~/core/utils/log';
-import { formatDuration } from '~/core/utils/time';
-import { ValidationError } from './core/utils/validation';
-
-// TODO: Remove. See https://github.com/wxt-dev/wxt/issues/277
-process.env.VITE_CJS_IGNORE_WARNING = 'true';
+import {
+  createAliasedCommand,
+  getArrayFromFlags,
+  wrapAction,
+} from './cli-utils';
 
 const cli = cac('wxt');
-cli.help();
-cli.version(version);
 
 cli.option('--debug', 'enable debug mode');
 
@@ -140,57 +135,12 @@ cli
     ),
   );
 
-cli.parse(process.argv);
+// SUBMIT
+createAliasedCommand(
+  cli,
+  'submit',
+  'publish-extension',
+  'https://www.npmjs.com/publish-browser-extension',
+);
 
-/**
- * Wrap an action handler to add a timer, error handling, and maybe enable debug mode.
- */
-function wrapAction(
-  cb: (
-    ...args: any[]
-  ) => void | { isOngoing?: boolean } | Promise<void | { isOngoing?: boolean }>,
-  options?: {
-    disableFinishedLog?: boolean;
-  },
-) {
-  return async (...args: any[]) => {
-    // Enable consola's debug mode globally at the start of all commands when the `--debug` flag is
-    // passed
-    const isDebug = !!args.find((arg) => arg?.debug);
-    if (isDebug) {
-      consola.level = LogLevels.debug;
-    }
-
-    const startTime = Date.now();
-    try {
-      printHeader();
-
-      const status = await cb(...args);
-
-      if (!status?.isOngoing && !options?.disableFinishedLog)
-        consola.success(
-          `Finished in ${formatDuration(Date.now() - startTime)}`,
-        );
-    } catch (err) {
-      consola.fail(
-        `Command failed after ${formatDuration(Date.now() - startTime)}`,
-      );
-      if (err instanceof ValidationError) {
-        // Don't log these errors, they've already been logged
-      } else {
-        consola.error(err);
-      }
-      process.exit(1);
-    }
-  };
-}
-
-/**
- * Array flags, when not passed, are either `undefined` or `[undefined]`. This function filters out
- * the
- */
-function getArrayFromFlags<T>(flags: any, name: string): T[] | undefined {
-  const array = [flags[name]].flat() as Array<T | undefined>;
-  const result = array.filter((item) => item != null) as T[];
-  return result.length ? result : undefined;
-}
+export default cli;

src/cli/index.ts

@@ -0,0 +1,19 @@
+import cli from './commands';
+import { version } from '~/version';
+import { isAliasedCommand } from './cli-utils';
+
+// TODO: Remove. See https://github.com/wxt-dev/wxt/issues/277
+process.env.VITE_CJS_IGNORE_WARNING = 'true';
+
+// Grab the command that we're trying to run
+cli.parse(process.argv, { run: false });
+
+// If it's not an alias, add the help and version options, then parse again
+if (!isAliasedCommand(cli.matchedCommand)) {
+  cli.help();
+  cli.version(version);
+  cli.parse(process.argv, { run: false });
+}
+
+// Run the alias or command
+await cli.runMatchedCommand();

src/client/content-scripts/custom-events.ts

@@ -15,10 +15,12 @@ export class WxtLocationChangeEvent extends Event {
  * Returns an event name unique to the extension and content script that's running.
  */
 export function getUniqueEventName(eventName: string): string {
-  // During the build process, __ENTRYPOINT__ is not defined when importing entrypoints to get their
-  // metadata.
+  // During the build process, import.meta.env is not defined when importing
+  // entrypoints to get their metadata.
   const entrypointName =
-    typeof __ENTRYPOINT__ === 'undefined' ? 'build' : __ENTRYPOINT__;
+    typeof import.meta.env === 'undefined'
+      ? 'build'
+      : import.meta.env.ENTRYPOINT;
 
   return `${browser.runtime.id}:${entrypointName}:${eventName}`;
 }

src/client/content-scripts/ui/index.ts

@@ -236,7 +236,9 @@ function mountUi(
  * Load the CSS for the current entrypoint.
  */
 async function loadCss(): Promise<string> {
-  const url = browser.runtime.getURL(`/content-scripts/${__ENTRYPOINT__}.css`);
+  const url = browser.runtime.getURL(
+    `/content-scripts/${import.meta.env.ENTRYPOINT}.css`,
+  );
   try {
     const res = await fetch(url);
     return await res.text();

src/core/builders/vite/index.ts

@@ -44,6 +44,10 @@ export async function createViteBuilder(
     if (config.build.minify == null && wxtConfig.command === 'serve') {
       config.build.minify = false;
     }
+    // Enable inline sourcemaps for the dev command (so content scripts have sourcemaps)
+    if (config.build.sourcemap == null && wxtConfig.command === 'serve') {
+      config.build.sourcemap = 'inline';
+    }
 
     config.plugins ??= [];
     config.plugins.push(
@@ -71,23 +75,7 @@ export async function createViteBuilder(
    * Return the basic config for building an entrypoint in [lib mode](https://vitejs.dev/guide/build.html#library-mode).
    */
   const getLibModeConfig = (entrypoint: Entrypoint): vite.InlineConfig => {
-    let virtualEntrypointType: VirtualEntrypointType | undefined;
-    switch (entrypoint.type) {
-      case 'background':
-      case 'unlisted-script':
-        virtualEntrypointType = entrypoint.type;
-        break;
-      case 'content-script':
-        virtualEntrypointType =
-          entrypoint.options.world === 'MAIN'
-            ? 'content-script-main-world'
-            : 'content-script-isolated-world';
-        break;
-    }
-    const entry = virtualEntrypointType
-      ? `virtual:wxt-${virtualEntrypointType}?${entrypoint.inputPath}`
-      : entrypoint.inputPath;
-
+    const entry = getRollupEntry(entrypoint);
     const plugins: NonNullable<vite.UserConfig['plugins']> = [
       wxtPlugins.entrypointGroupGlobals(entrypoint),
     ];
@@ -153,14 +141,16 @@ export async function createViteBuilder(
       build: {
         rollupOptions: {
           input: entrypoints.reduce<Record<string, string>>((input, entry) => {
-            input[entry.name] = entry.inputPath;
+            input[entry.name] = getRollupEntry(entry);
             return input;
           }, {}),
           output: {
             // Include a hash to prevent conflicts
             chunkFileNames: 'chunks/[name]-[hash].js',
-            // Include a hash to prevent conflicts
-            entryFileNames: 'chunks/[name]-[hash].js',
+            // Place JS entrypoints in main directory without a hash. (popup.html & popup.js are
+            // next to each other). The unique entrypoint name requirement prevents conflicts with
+            // scripts of the same name
+            entryFileNames: '[name].js',
             // We can't control the "name", so we need a hash to prevent conflicts
             assetFileNames: 'assets/[name]-[hash].[ext]',
           },
@@ -259,3 +249,26 @@ function getBuildOutputChunks(
   if (Array.isArray(result)) return result.flatMap(({ output }) => output);
   return result.output;
 }
+
+/**
+ * Returns the input module ID (virtual or real file) for an entrypoint. The returned string should
+ * be passed as an input to rollup.
+ */
+function getRollupEntry(entrypoint: Entrypoint): string {
+  let virtualEntrypointType: VirtualEntrypointType | undefined;
+  switch (entrypoint.type) {
+    case 'background':
+    case 'unlisted-script':
+      virtualEntrypointType = entrypoint.type;
+      break;
+    case 'content-script':
+      virtualEntrypointType =
+        entrypoint.options.world === 'MAIN'
+          ? 'content-script-main-world'
+          : 'content-script-isolated-world';
+      break;
+  }
+  return virtualEntrypointType
+    ? `virtual:wxt-${virtualEntrypointType}?${entrypoint.inputPath}`
+    : entrypoint.inputPath;
+}

src/core/builders/vite/plugins/__tests__/devHtmlPrerender.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'vitest';
+import { Window } from 'happy-dom';
+import { pointToDevServer } from '../devHtmlPrerender';
+import {
+  fakeDevServer,
+  fakeInternalConfig,
+} from '~/core/utils/testing/fake-objects';
+import { normalizePath } from '~/core/utils/paths';
+import { resolve } from 'node:path';
+
+describe('Dev HTML Prerender Plugin', () => {
+  describe('pointToDevServer', () => {
+    it.each([
+      // File paths should be resolved
+      ['style.css', 'http://localhost:5173/entrypoints/popup/style.css'],
+      ['./style.css', 'http://localhost:5173/entrypoints/popup/style.css'],
+      ['../style.css', 'http://localhost:5173/entrypoints/style.css'],
+      ['~/assets/style.css', 'http://localhost:5173/assets/style.css'],
+      ['~~/assets/style.css', 'http://localhost:5173/assets/style.css'],
+      ['~local/style.css', 'http://localhost:5173/style.css'],
+      ['~absolute/style.css', 'http://localhost:5173/assets/style.css'],
+      ['~file', 'http://localhost:5173/example.css'],
+      // Absolute paths are loaded with the `/@fs/` base path
+      [
+        '~outside/test.css',
+        `http://localhost:5173/@fs${
+          process.platform === 'win32'
+            ? '/' + normalizePath(resolve('/some/non-root/test.css')) // "/D:/some/non-root/test.css"
+            : '/some/non-root/test.css'
+        }`,
+      ],
+      // URLs should not be changed
+      ['https://example.com/style.css', 'https://example.com/style.css'],
+    ])('should transform "%s" into "%s"', (input, expected) => {
+      const { document } = new Window({
+        url: 'http://localhost',
+      });
+      const root = '/some/root';
+      const config = fakeInternalConfig({
+        root,
+        alias: {
+          '~local': '.',
+          '~absolute': `${root}/assets`,
+          '~file': `${root}/example.css`,
+          '~outside': `${root}/../non-root`,
+          '~~': root,
+          '~': root,
+        },
+      });
+      const server = fakeDevServer({
+        hostname: 'localhost',
+        port: 5173,
+        origin: 'http://localhost:5173',
+      });
+      const id = root + '/entrypoints/popup/index.html';
+
+      document.head.innerHTML = `<link rel="stylesheet" href="${input}" />`;
+      pointToDevServer(config, server, id, document as any, 'link', 'href');
+
+      const actual = document.querySelector('link')!;
+      expect(actual.getAttribute('href')).toBe(expected);
+    });
+  });
+});

src/core/builders/vite/plugins/devHtmlPrerender.ts

@@ -1,8 +1,9 @@
 import type * as vite from 'vite';
-import { InternalConfig } from '~/types';
+import { InternalConfig, WxtDevServer } from '~/types';
 import { getEntrypointName } from '~/core/utils/entrypoints';
 import { parseHTML } from 'linkedom';
-import { dirname, isAbsolute, relative, resolve } from 'node:path';
+import { dirname, relative, resolve } from 'node:path';
+import { normalizePath } from '~/core/utils/paths';
 
 // Cache the preamble script for all devHtmlPrerender plugins, not just one
 let reactRefreshPreamble = '';
@@ -47,25 +48,10 @@ export function devHtmlPrerender(
 
         const { document } = parseHTML(code);
 
-        const pointToDevServer = (
-          querySelector: string,
-          attr: string,
-        ): void => {
-          document.querySelectorAll(querySelector).forEach((element) => {
-            const src = element.getAttribute(attr);
-            if (!src) return;
-
-            if (isAbsolute(src)) {
-              element.setAttribute(attr, server.origin + src);
-            } else if (src.startsWith('.')) {
-              const abs = resolve(dirname(id), src);
-              const pathname = relative(config.root, abs);
-              element.setAttribute(attr, `${server.origin}/${pathname}`);
-            }
-          });
-        };
-        pointToDevServer('script[type=module]', 'src');
-        pointToDevServer('link[rel=stylesheet]', 'href');
+        const _pointToDevServer = (querySelector: string, attr: string) =>
+          pointToDevServer(config, server, id, document, querySelector, attr);
+        _pointToDevServer('script[type=module]', 'src');
+        _pointToDevServer('link[rel=stylesheet]', 'href');
 
         // Add a script to add page reloading
         const reloader = document.createElement('script');
@@ -146,3 +132,63 @@ export function devHtmlPrerender(
     },
   ];
 }
+
+export function pointToDevServer(
+  config: Omit<InternalConfig, 'builder'>,
+  server: WxtDevServer,
+  id: string,
+  document: Document,
+  querySelector: string,
+  attr: string,
+) {
+  document.querySelectorAll(querySelector).forEach((element) => {
+    const src = element.getAttribute(attr);
+    if (!src || isUrl(src)) return;
+
+    let resolvedAbsolutePath: string | undefined;
+
+    // Check if src uses a project alias
+    const matchingAlias = Object.entries(config.alias).find(([key]) =>
+      src.startsWith(key),
+    );
+    if (matchingAlias) {
+      // Matches a import alias
+      const [alias, replacement] = matchingAlias;
+      resolvedAbsolutePath = resolve(
+        config.root,
+        src.replace(alias, replacement),
+      );
+    } else {
+      // Some file path relative to the HTML file
+      resolvedAbsolutePath = resolve(dirname(id), src);
+    }
+
+    // Apply the final file path
+    if (resolvedAbsolutePath) {
+      const relativePath = normalizePath(
+        relative(config.root, resolvedAbsolutePath),
+      );
+
+      if (relativePath.startsWith('.')) {
+        // Outside the config.root directory, serve the absolute path
+        let path = normalizePath(resolvedAbsolutePath);
+        // Add "/" to start of windows paths ("D:/some/path" -> "/D:/some/path")
+        if (!path.startsWith('/')) path = '/' + path;
+        element.setAttribute(attr, `${server.origin}/@fs${path}`);
+      } else {
+        // Inside the project, use relative path
+        const url = new URL(relativePath, server.origin);
+        element.setAttribute(attr, url.href);
+      }
+    }
+  });
+}
+
+function isUrl(str: string): boolean {
+  try {
+    new URL(str);
+    return true;
+  } catch {
+    return false;
+  }
+}

src/core/builders/vite/plugins/entrypointGroupGlobals.ts

@@ -14,7 +14,7 @@ export function entrypointGroupGlobals(
       const define: vite.InlineConfig['define'] = {};
       let name = Array.isArray(entrypointGroup) ? 'html' : entrypointGroup.name;
       for (const global of getEntrypointGlobals(name)) {
-        define[global.name] = JSON.stringify(global.value);
+        define[`import.meta.env.${global.name}`] = JSON.stringify(global.value);
       }
       return {
         define,

src/core/builders/vite/plugins/globals.ts

@@ -10,7 +10,7 @@ export function globals(
     config() {
       const define: vite.InlineConfig['define'] = {};
       for (const global of getGlobals(config)) {
-        define[global.name] = JSON.stringify(global.value);
+        define[`import.meta.env.${global.name}`] = JSON.stringify(global.value);
       }
       return {
         define,

src/core/builders/vite/plugins/unimport.ts

@@ -36,7 +36,11 @@ export function unimport(
       // Don't transform non-js files
       if (!ENABLED_EXTENSIONS.has(extname(id))) return;
 
-      return unimport.injectImports(code, id);
+      const injected = await unimport.injectImports(code, id);
+      return {
+        code: injected.code,
+        map: injected.s.generateMap({ hires: 'boundary', source: id }),
+      };
     },
   };
 }

src/core/create-server.ts

@@ -8,7 +8,6 @@ import {
 } from '~/types';
 import {
   getEntrypointBundlePath,
-  getEntrypointOutputFile,
   resolvePerBrowserOption,
 } from '~/core/utils/entrypoints';
 import {
@@ -197,15 +196,6 @@ function createFileReloader(options: {
           .join(', ')}`,
       );
 
-      const rebuiltNames = changes.rebuildGroups
-        .flat()
-        .map((entry) => {
-          return pc.cyan(
-            relative(config.outDir, getEntrypointOutputFile(entry, '')),
-          );
-        })
-        .join(pc.dim(', '));
-
       // Rebuild entrypoints on change
       const allEntrypoints = await findEntrypoints(config);
       const { output: newOutput } = await rebuild(
@@ -221,15 +211,24 @@ function createFileReloader(options: {
       switch (changes.type) {
         case 'extension-reload':
           server.reloadExtension();
+          consola.success(`Reloaded extension`);
           break;
         case 'html-reload':
-          reloadHtmlPages(changes.rebuildGroups, server, config);
+          const { reloadedNames } = reloadHtmlPages(
+            changes.rebuildGroups,
+            server,
+            config,
+          );
+          consola.success(`Reloaded: ${getFilenameList(reloadedNames)}`);
           break;
         case 'content-script-reload':
           reloadContentScripts(changes.changedSteps, config, server);
+          const rebuiltNames = changes.rebuildGroups
+            .flat()
+            .map((entry) => entry.name);
+          consola.success(`Reloaded: ${getFilenameList(rebuiltNames)}`);
           break;
       }
-      consola.success(`Reloaded: ${rebuiltNames}`);
     });
   };
 }
@@ -279,9 +278,26 @@ function reloadHtmlPages(
   groups: EntrypointGroup[],
   server: WxtDevServer,
   config: InternalConfig,
-) {
-  groups.flat().forEach((entry) => {
+): { reloadedNames: string[] } {
+  // groups might contain other files like background/content scripts, and we only care about the HTMl pages
+  const htmlEntries = groups
+    .flat()
+    .filter((entry) => entry.inputPath.endsWith('.html'));
+
+  htmlEntries.forEach((entry) => {
     const path = getEntrypointBundlePath(entry, config.outDir, '.html');
     server.reloadPage(path);
   });
+
+  return {
+    reloadedNames: htmlEntries.map((entry) => entry.name),
+  };
+}
+
+function getFilenameList(names: string[]): string {
+  return names
+    .map((name) => {
+      return pc.cyan(name);
+    })
+    .join(pc.dim(', '));
 }

src/core/runners/web-ext.ts

@@ -1,6 +1,7 @@
 import type { WebExtRunInstance } from 'web-ext-run';
 import { ExtensionRunner } from '~/types';
 import { formatDuration } from '../utils/time';
+import defu from 'defu';
 
 /**
  * Create an `ExtensionRunner` backed by `web-ext`.
@@ -40,6 +41,10 @@ export function createWebExtRunner(): ExtensionRunner {
           : {
               chromiumBinary: wxtUserConfig?.binaries?.[config.browser],
               chromiumProfile: wxtUserConfig?.chromiumProfile,
+              chromiumPref: defu(
+                wxtUserConfig?.chromiumPref,
+                DEFAULT_CHROMIUM_PREFS,
+              ),
               args: wxtUserConfig?.chromiumArgs,
             }),
       };
@@ -75,3 +80,14 @@ export function createWebExtRunner(): ExtensionRunner {
 // https://github.com/mozilla/web-ext/blob/e37e60a2738478f512f1255c537133321f301771/src/util/logger.js#L12
 const WARN_LOG_LEVEL = 40;
 const ERROR_LOG_LEVEL = 50;
+
+const DEFAULT_CHROMIUM_PREFS = {
+  devtools: {
+    synced_preferences_sync_disabled: {
+      // Remove content scripts from sourcemap debugger ignore list so stack traces
+      // and log locations show up properly, see:
+      // https://github.com/wxt-dev/wxt/issues/236#issuecomment-1915364520
+      skipContentScripts: false,
+    },
+  },
+};

src/core/utils/building/__tests__/detect-dev-changes.test.ts

@@ -167,9 +167,9 @@ describe('Detect Dev Changes', () => {
   });
 
   describe('HTML Pages', () => {
-    it('should rebuild then reload only the effected pages', async () => {
+    it('should detect changes to entrypoints/<name>.html files', async () => {
       const config = fakeInternalConfig();
-      const changedPath = '/root/page1/index.html';
+      const changedPath = '/root/page1.html';
       const htmlPage1 = fakePopupEntrypoint({
         inputPath: changedPath,
       });
@@ -184,16 +184,66 @@ describe('Detect Dev Changes', () => {
       const step1: BuildStepOutput = {
         entrypoints: [htmlPage1, htmlPage2],
         chunks: [
-          fakeOutputChunk({
-            moduleIds: [fakeFile(), changedPath],
+          fakeOutputAsset({
+            fileName: 'page1.html',
           }),
         ],
       };
       const step2: BuildStepOutput = {
         entrypoints: [htmlPage3],
         chunks: [
-          fakeOutputChunk({
-            moduleIds: [fakeFile(), fakeFile(), fakeFile()],
+          fakeOutputAsset({
+            fileName: 'page2.html',
+          }),
+        ],
+      };
+
+      const currentOutput: BuildOutput = {
+        manifest: fakeManifest(),
+        publicAssets: [],
+        steps: [step1, step2],
+      };
+      const expected: DevModeChange = {
+        type: 'html-reload',
+        cachedOutput: {
+          ...currentOutput,
+          steps: [step2],
+        },
+        rebuildGroups: [[htmlPage1, htmlPage2]],
+      };
+
+      const actual = detectDevChanges(config, [changedPath], currentOutput);
+
+      expect(actual).toEqual(expected);
+    });
+
+    it('should detect changes to entrypoints/<name>/index.html files', async () => {
+      const config = fakeInternalConfig();
+      const changedPath = '/root/page1/index.html';
+      const htmlPage1 = fakePopupEntrypoint({
+        inputPath: changedPath,
+      });
+      const htmlPage2 = fakeOptionsEntrypoint({
+        inputPath: '/root/page2/index.html',
+      });
+      const htmlPage3 = fakeGenericEntrypoint({
+        type: 'sandbox',
+        inputPath: '/root/page3/index.html',
+      });
+
+      const step1: BuildStepOutput = {
+        entrypoints: [htmlPage1, htmlPage2],
+        chunks: [
+          fakeOutputAsset({
+            fileName: 'page1.html',
+          }),
+        ],
+      };
+      const step2: BuildStepOutput = {
+        entrypoints: [htmlPage3],
+        chunks: [
+          fakeOutputAsset({
+            fileName: 'page2.html',
           }),
         ],
       };

src/core/utils/building/__tests__/find-entrypoints.test.ts

@@ -27,6 +27,7 @@ const readFileMock = vi.mocked(
 
 describe('findEntrypoints', () => {
   const config = fakeInternalConfig({
+    manifestVersion: 3,
     root: '/',
     entrypointsDir: resolve('/src/entrypoints'),
     outDir: resolve('.output'),
@@ -254,6 +255,32 @@ describe('findEntrypoints', () => {
     },
   );
 
+  it('should remove type=module from MV2 background scripts', async () => {
+    const config = fakeInternalConfig({ manifestVersion: 2 });
+    const options: BackgroundEntrypoint['options'] = {
+      type: 'module',
+    };
+    globMock.mockResolvedValueOnce(['background.ts']);
+    importEntrypointFileMock.mockResolvedValue(options);
+
+    const entrypoints = await findEntrypoints(config);
+
+    expect(entrypoints[0].options).toEqual({});
+  });
+
+  it('should allow type=module for MV3 background service workers', async () => {
+    const config = fakeInternalConfig({ manifestVersion: 3 });
+    const options: BackgroundEntrypoint['options'] = {
+      type: 'module',
+    };
+    globMock.mockResolvedValueOnce(['background.ts']);
+    importEntrypointFileMock.mockResolvedValue(options);
+
+    const entrypoints = await findEntrypoints(config);
+
+    expect(entrypoints[0].options).toEqual(options);
+  });
+
   it("should include a virtual background script so dev reloading works when there isn't a background entrypoint defined by the user", async () => {
     globMock.mockResolvedValueOnce(['popup.html']);
 

src/core/utils/building/__tests__/group-entrypoints.test.ts

@@ -1,6 +1,11 @@
 import { describe, expect, it } from 'vitest';
 import { Entrypoint } from '~/types';
 import { groupEntrypoints } from '../group-entrypoints';
+import {
+  fakeBackgroundEntrypoint,
+  fakeGenericEntrypoint,
+  fakePopupEntrypoint,
+} from '../../testing/fake-objects';
 
 const background: Entrypoint = {
   type: 'background',
@@ -141,4 +146,29 @@ describe('groupEntrypoints', () => {
 
     expect(actual).toEqual(expected);
   });
+
+  it('should group ESM compatible scripts with extension pages', () => {
+    const background = fakeBackgroundEntrypoint({
+      options: {
+        type: 'module',
+      },
+    });
+    const popup = fakePopupEntrypoint();
+    const sandbox = fakeGenericEntrypoint({
+      inputPath: '/entrypoints/sandbox.html',
+      name: 'sandbox',
+      type: 'sandbox',
+    });
+
+    const actual = groupEntrypoints([background, popup, sandbox]);
+
+    expect(actual).toEqual([[background, popup], [sandbox]]);
+  });
+
+  it.todo(
+    'should group ESM compatible sandbox scripts with sandbox pages',
+    () => {
+      // Main world content scripts
+    },
+  );
 });

src/core/utils/building/detect-dev-changes.ts

@@ -123,11 +123,12 @@ function findEffectedSteps(
   const changedPath = normalizePath(changedFile);
 
   const isChunkEffected = (chunk: OutputFile): boolean =>
-    // 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
-    (chunk.type === 'asset' && changedPath.endsWith(chunk.fileName)) ||
+    // If it's an HTML file with the same path, is is effected because HTML files need to be re-rendered
+    // - fileName is normalized, relative bundle path, "<entrypoint-name>.html"
+    (chunk.type === 'asset' &&
+      changedPath.replace('/index.html', '.html').endsWith(chunk.fileName)) ||
     // If it's a chunk that depends on the changed file, it is effected
-    // moduleIds are absolute, normalized paths
+    // - moduleIds are absolute, normalized paths
     (chunk.type === 'chunk' && chunk.moduleIds.includes(changedPath));
 
   for (const step of currentOutput.steps) {

src/core/utils/building/find-entrypoints.ts

@@ -392,6 +392,11 @@ async function getBackgroundEntrypoint(
     const { main: _, ...moduleOptions } = defaultExport;
     options = moduleOptions;
   }
+
+  if (config.manifestVersion !== 3) {
+    delete options.type;
+  }
+
   return {
     type: 'background',
     name,

src/core/utils/building/generate-wxt-dir.ts

@@ -136,7 +136,7 @@ declare module "wxt/browser" {
 
   const overrides = messages.map((message) => {
     return `    /**
-     * ${message.description ?? 'No message description.'}
+     * ${message.description || 'No message description.'}
      *
      * "${message.message}"
      */
@@ -164,8 +164,11 @@ async function writeGlobalsDeclarationFile(
     [
       '// Generated by wxt',
       'export {}',
-      'declare global {',
-      ...globals.map((global) => `  const ${global.name}: ${global.type};`),
+      'interface ImportMetaEnv {',
+      ...globals.map((global) => `  readonly ${global.name}: ${global.type};`),
+      '}',
+      'interface ImportMeta {',
+      '  readonly env: ImportMetaEnv',
       '}',
     ].join('\n') + '\n',
   );

src/core/utils/building/get-internal-config.ts

@@ -241,8 +241,9 @@ function resolveInternalZipConfig(
     sourcesTemplate: '{{name}}-{{version}}-sources.zip',
     artifactTemplate: '{{name}}-{{version}}-{{browser}}.zip',
     sourcesRoot: root,
+    includeSources: [],
     ...mergedConfig.zip,
-    ignoredSources: [
+    excludeSources: [
       '**/node_modules',
       // WXT files
       '**/web-ext.config.ts',
@@ -252,7 +253,7 @@ function resolveInternalZipConfig(
       '**/__tests__/**',
       '**/*.+(test|spec).?(c|m)+(j|t)s?(x)',
       // From user
-      ...(mergedConfig.zip?.ignoredSources ?? []),
+      ...(mergedConfig.zip?.excludeSources ?? []),
     ],
   };
 }

src/core/utils/building/group-entrypoints.ts

@@ -11,8 +11,11 @@ export function groupEntrypoints(entrypoints: Entrypoint[]): EntrypointGroup[] {
   const groups: EntrypointGroup[] = [];
 
   for (const entry of entrypoints) {
-    const group = ENTRY_TYPE_TO_GROUP_MAP[entry.type];
-    if (group === 'no-group') {
+    let group = ENTRY_TYPE_TO_GROUP_MAP[entry.type];
+    if (entry.type === 'background' && entry.options.type === 'module') {
+      group = 'esm';
+    }
+    if (group === 'individual') {
       groups.push(entry);
     } else {
       let groupIndex = groupIndexMap[group];
@@ -28,22 +31,22 @@ export function groupEntrypoints(entrypoints: Entrypoint[]): EntrypointGroup[] {
 }
 
 const ENTRY_TYPE_TO_GROUP_MAP: Record<Entrypoint['type'], Group> = {
-  sandbox: 'sandbox-page',
+  sandbox: 'sandboxed-esm',
 
-  popup: 'extension-page',
-  newtab: 'extension-page',
-  history: 'extension-page',
-  options: 'extension-page',
-  devtools: 'extension-page',
-  bookmarks: 'extension-page',
-  sidepanel: 'extension-page',
-  'unlisted-page': 'extension-page',
+  popup: 'esm',
+  newtab: 'esm',
+  history: 'esm',
+  options: 'esm',
+  devtools: 'esm',
+  bookmarks: 'esm',
+  sidepanel: 'esm',
+  'unlisted-page': 'esm',
 
-  background: 'no-group',
-  'content-script': 'no-group',
-  'unlisted-script': 'no-group',
-  'unlisted-style': 'no-group',
-  'content-script-style': 'no-group',
+  background: 'individual',
+  'content-script': 'individual',
+  'unlisted-script': 'individual',
+  'unlisted-style': 'individual',
+  'content-script-style': 'individual',
 };
 
-type Group = 'extension-page' | 'sandbox-page' | 'no-group';
+type Group = 'esm' | 'sandboxed-esm' | 'individual';

src/core/utils/building/import-entrypoint.ts

@@ -98,6 +98,7 @@ export async function importEntrypointFile<T>(
         { cause: err },
       );
     } else {
+      config.logger.error(err);
       throw Error(`Failed to load entrypoint: ${filePath}`, { cause: err });
     }
   }

src/core/utils/building/internal-build.ts

@@ -8,8 +8,7 @@ import { printBuildSummary } from '~/core/utils/log';
 import glob from 'fast-glob';
 import { unnormalizePath } from '~/core/utils/paths';
 import { rebuild } from './rebuild';
-import managePath from 'manage-path';
-import { resolve, relative } from 'node:path';
+import { relative } from 'node:path';
 import {
   ValidationError,
   ValidationResult,
@@ -17,6 +16,7 @@ import {
   validateEntrypoints,
 } from '../validation';
 import consola from 'consola';
+import { exec } from '../exec';
 
 /**
  * Builds the extension based on an internal config. No more config discovery is performed, the
@@ -88,21 +88,16 @@ export async function internalBuild(
 }
 
 async function combineAnalysisStats(config: InternalConfig): Promise<void> {
-  const { execaCommand } = await import('execa');
   const unixFiles = await glob(`stats-*.json`, {
     cwd: config.outDir,
     absolute: true,
   });
   const absolutePaths = unixFiles.map(unnormalizePath);
 
-  const alterPath = managePath(process.env);
-  // Add subdependency path for PNPM shamefully-hoist=false
-  alterPath.push(resolve(config.root, 'node_modules/wxt/node_modules/.bin'));
-
-  await execaCommand(
-    `rollup-plugin-visualizer ${absolutePaths.join(' ')} --template ${
-      config.analysis.template
-    }`,
+  await exec(
+    config,
+    'rollup-plugin-visualizer',
+    [...absolutePaths, '--template', config.analysis.template],
     { cwd: config.root, stdio: 'inherit' },
   );
 }

src/core/utils/exec.ts

@@ -0,0 +1,25 @@
+import type { Options } from 'execa';
+import managePath from 'manage-path';
+import { resolve } from 'node:path';
+import { InternalConfig } from '~/types';
+
+const managedPath = managePath(process.env);
+
+/**
+ * Wrapper around `execa` with a modified `PATH` variable containing CLI tools from WXT's dependencies.
+ */
+export const exec = async (
+  config: InternalConfig,
+  file: string,
+  args?: readonly string[],
+  options?: Options,
+) => {
+  // Reset so the same path isn't added multiple times
+  managedPath.restore();
+
+  // Add subdependency path for PNPM shamefully-hoist=false
+  managedPath.push(resolve(config.root, 'node_modules/wxt/node_modules/.bin'));
+
+  const { execa } = await import('execa');
+  return await execa(file, args, options);
+};

src/core/utils/globals.ts

@@ -5,42 +5,42 @@ export function getGlobals(
 ): Array<{ name: string; value: any; type: string }> {
   return [
     {
-      name: surroundInUnderscore('MANIFEST_VERSION'),
+      name: 'MANIFEST_VERSION',
       value: config.manifestVersion,
       type: `2 | 3`,
     },
     {
-      name: surroundInUnderscore('BROWSER'),
+      name: 'BROWSER',
       value: config.browser,
       type: `string`,
     },
     {
-      name: surroundInUnderscore('IS_CHROME'),
+      name: 'CHROME',
       value: config.browser === 'chrome',
       type: `boolean`,
     },
     {
-      name: surroundInUnderscore('IS_FIREFOX'),
+      name: 'FIREFOX',
       value: config.browser === 'firefox',
       type: `boolean`,
     },
     {
-      name: surroundInUnderscore('IS_SAFARI'),
+      name: 'SAFARI',
       value: config.browser === 'safari',
       type: `boolean`,
     },
     {
-      name: surroundInUnderscore('IS_EDGE'),
+      name: 'EDGE',
       value: config.browser === 'edge',
       type: `boolean`,
     },
     {
-      name: surroundInUnderscore('IS_OPERA'),
+      name: 'OPERA',
       value: config.browser === 'opera',
       type: `boolean`,
     },
     {
-      name: surroundInUnderscore('COMMAND'),
+      name: 'COMMAND',
       value: config.command,
       type: `"build" | "serve"`,
     },
@@ -50,17 +50,9 @@ export function getGlobals(
 export function getEntrypointGlobals(entrypointName: string) {
   return [
     {
-      name: surroundInUnderscore('ENTRYPOINT'),
+      name: 'ENTRYPOINT',
       value: entrypointName,
       type: `string`,
     },
   ];
 }
-
-/**
- * Don't hardcode the complete name so that the string litterals in this file aren't replaced during
- * tests (which causes syntax errors), only during builds.
- */
-function surroundInUnderscore(name: string): string {
-  return `__${name}__`;
-}

src/core/utils/testing/fake-objects.ts

@@ -22,6 +22,7 @@ import {
   UserManifest,
 } from '~/types';
 import { mock } from 'vitest-mock-extended';
+import { vi } from 'vitest';
 
 faker.seed(__TEST_SEED__);
 
@@ -232,7 +233,8 @@ export const fakeInternalConfig = fakeObjectCreator<InternalConfig>(() => {
     },
     zip: {
       artifactTemplate: '{{name}}-{{version}}.zip',
-      ignoredSources: [],
+      includeSources: [],
+      excludeSources: [],
       sourcesRoot: fakeDir(),
       sourcesTemplate: '{{name}}-sources.zip',
       name: faker.person.firstName().toLowerCase(),
@@ -268,3 +270,20 @@ export const fakeManifestCommand = fakeObjectCreator<Commands.Command>(() => ({
     max: 9,
   })}`,
 }));
+
+export const fakeDevServer = fakeObjectCreator<WxtDevServer>(() => ({
+  hostname: 'localhost',
+  origin: 'http://localhost',
+  port: 5173,
+  reloadContentScript: vi.fn(),
+  reloadExtension: vi.fn(),
+  reloadPage: vi.fn(),
+  restart: vi.fn(),
+  restartBrowser: vi.fn(),
+  stop: vi.fn(),
+  start: vi.fn(),
+  watcher: mock(),
+  transformHtml: vi.fn(),
+  ws: mock(),
+  currentOutput: undefined,
+}));

src/core/zip.ts

@@ -62,10 +62,15 @@ export async function zip(config?: InlineConfig): Promise<string[]> {
       saveTo: sourcesZipPath,
       filter(path) {
         const relativePath = relative(internalConfig.zip.sourcesRoot, path);
-        const matchedPattern = internalConfig.zip.ignoredSources.find(
-          (pattern) => minimatch(relativePath, pattern),
+
+        return (
+          internalConfig.zip.includeSources.some((pattern) =>
+            minimatch(relativePath, pattern),
+          ) ||
+          !internalConfig.zip.excludeSources.some((pattern) =>
+            minimatch(relativePath, pattern),
+          )
         );
-        return matchedPattern == null;
       },
     });
     zipFiles.push(sourcesZipPath);

src/types/external.ts

@@ -143,9 +143,22 @@ export interface InlineConfig {
      * @default config.root
      */
     sourcesRoot?: string;
+    /**
+     * [Minimatch](https://www.npmjs.com/package/minimatch) patterns of files to include when
+     * creating a ZIP of all your source code for Firefox. Patterns are relative to your
+     * `config.zip.sourcesRoot`.
+     *
+     * This setting overrides `excludeSources`. So if a file matches both lists, it is included in the ZIP.
+     *
+     * @example
+     * [
+     *   "coverage", // Ignore the coverage directory in the `sourcesRoot`
+     * ]
+     */
+    includeSources?: string[];
     /**
      * [Minimatch](https://www.npmjs.com/package/minimatch) patterns of files to exclude when
-     * creating a ZIP of all your source code for Firfox. Patterns are relative to your
+     * creating a ZIP of all your source code for Firefox. Patterns are relative to your
      * `config.zip.sourcesRoot`.
      *
      * Hidden files, node_modules, and tests are ignored by default.
@@ -155,7 +168,7 @@ export interface InlineConfig {
      *   "coverage", // Ignore the coverage directory in the `sourcesRoot`
      * ]
      */
-    ignoredSources?: string[];
+    excludeSources?: string[];
   };
 
   /**
@@ -661,6 +674,33 @@ export interface ExtensionRunnerConfig {
    * @see https://extensionworkshop.com/documentation/develop/web-ext-command-reference/#chromium-profile
    */
   chromiumProfile?: string;
+  /**
+   * An map of chrome preferences from https://chromium.googlesource.com/chromium/src/+/main/chrome/common/pref_names.h
+   *
+   * @example
+   * // change your downloads directory
+   * {
+   *   download: {
+   *     default_directory: "/my/custom/dir",
+   *   },
+   * }
+   *
+   * @default
+   * // Enable dev mode and allow content script sourcemaps
+   * {
+   *   devtools: {
+   *     synced_preferences_sync_disabled: {
+   *       skipContentScripts: false,
+   *     },
+   *   }
+   *   extensions: {
+   *     ui: {
+   *       developer_mode: true,
+   *     },
+   *   }
+   * }
+   */
+  chromiumPref?: string;
   /**
    * @see https://extensionworkshop.com/documentation/develop/web-ext-command-reference/#pref
    */

src/types/globals.d.ts

@@ -1,7 +1,10 @@
-// Globals defined by the vite-plugins/devServerGlobals.ts and utils/globals.ts
-declare const __COMMAND__: 'build' | 'serve';
 declare const __DEV_SERVER_PROTOCOL__: string;
 declare const __DEV_SERVER_HOSTNAME__: string;
 declare const __DEV_SERVER_PORT__: string;
-declare const __MANIFEST_VERSION__: 2 | 3;
-declare const __ENTRYPOINT__: string;
+
+// Globals defined by the vite-plugins/devServerGlobals.ts and utils/globals.ts
+interface ImportMetaEnv {
+  readonly COMMAND: 'build' | 'serve';
+  readonly MANIFEST_VERSION: 2 | 3;
+  readonly ENTRYPOINT: string;
+}

src/types/internal.ts

@@ -40,7 +40,8 @@ export interface InternalConfig {
     name?: string;
     artifactTemplate: string;
     sourcesTemplate: string;
-    ignoredSources: string[];
+    includeSources: string[];
+    excludeSources: string[];
     sourcesRoot: string;
   };
   transformManifest: (manifest: Manifest.WebExtensionManifest) => void;

src/types/modules.d.ts

@@ -51,7 +51,15 @@ declare module 'web-ext-run/util/logger' {
 }
 
 declare module 'manage-path' {
-  export default function managePath(env: object): string[];
+  export interface ManagedPath {
+    push(...paths: string[]);
+    push(paths: string[]);
+    shift(...paths: string[]);
+    shift(paths: string[]);
+    get(): string;
+    restore(): void;
+  }
+  export default function managePath(env: object): ManagedPath;
 }
 
 declare module 'wxt/browser' {

src/virtual/background-entrypoint.ts

@@ -5,7 +5,7 @@ import { browser } from 'wxt/browser';
 import { keepServiceWorkerAlive } from './utils/keep-service-worker-alive';
 import { reloadContentScript } from './utils/reload-content-scripts';
 
-if (__COMMAND__ === 'serve') {
+if (import.meta.env.COMMAND === 'serve') {
   try {
     const ws = setupWebSocket((message) => {
       if (message.event === 'wxt:reload-extension') browser.runtime.reload();
@@ -13,7 +13,7 @@ if (__COMMAND__ === 'serve') {
         reloadContentScript(message.data);
     });
 
-    if (__MANIFEST_VERSION__ === 3) {
+    if (import.meta.env.MANIFEST_VERSION === 3) {
       // Tell the server the background script is loaded and ready to go
       ws.addEventListener('open', () => {
         const msg = { type: 'custom', event: 'wxt:background-initialized' };

src/virtual/content-script-isolated-world-entrypoint.ts

@@ -5,12 +5,12 @@ import { ContentScriptContext } from 'wxt/client';
 (async () => {
   try {
     const { main, ...options } = definition;
-    const ctx = new ContentScriptContext(__ENTRYPOINT__, options);
+    const ctx = new ContentScriptContext(import.meta.env.ENTRYPOINT, options);
 
     await main(ctx);
   } catch (err) {
     logger.error(
-      `The content script "${__ENTRYPOINT__}" crashed on startup!`,
+      `The content script "${import.meta.env.ENTRYPOINT}" crashed on startup!`,
       err,
     );
   }

src/virtual/content-script-main-world-entrypoint.ts

@@ -7,7 +7,7 @@ import { logger } from '../sandbox/utils/logger';
     await main();
   } catch (err) {
     logger.error(
-      `The content script "${__ENTRYPOINT__}" crashed on startup!`,
+      `The content script "${import.meta.env.ENTRYPOINT}" crashed on startup!`,
       err,
     );
   }

src/virtual/reload-html.ts

@@ -1,7 +1,7 @@
 import { logger } from '../sandbox/utils/logger';
 import { setupWebSocket } from './utils/setup-web-socket';
 
-if (__COMMAND__ === 'serve') {
+if (import.meta.env.COMMAND === 'serve') {
   try {
     setupWebSocket((message) => {
       if (message.event === 'wxt:reload-page') {

src/virtual/unlisted-script-entrypoint.ts

@@ -6,7 +6,7 @@ import { logger } from '../sandbox/utils/logger';
     await definition.main();
   } catch (err) {
     logger.error(
-      `The unlisted script "${__ENTRYPOINT__}" crashed on startup!`,
+      `The unlisted script "${import.meta.env.ENTRYPOINT}" crashed on startup!`,
       err,
     );
   }

templates/react/package.json

@@ -23,6 +23,6 @@
     "@types/react-dom": "^18.2.18",
     "@vitejs/plugin-react": "^4.2.1",
     "typescript": "^5.3.3",
-    "wxt": "^0.14.0"
+    "wxt": "^0.16.0"
   }
 }

templates/solid/package.json

@@ -20,6 +20,6 @@
   "devDependencies": {
     "typescript": "^5.3.3",
     "vite-plugin-solid": "^2.8.0",
-    "wxt": "^0.14.0"
+    "wxt": "^0.16.0"
   }
 }

templates/svelte/package.json

@@ -20,6 +20,6 @@
     "svelte-check": "^3.6.2",
     "tslib": "^2.6.2",
     "typescript": "^5.3.3",
-    "wxt": "^0.14.0"
+    "wxt": "^0.16.0"
   }
 }

templates/vanilla/package.json

@@ -16,6 +16,6 @@
   },
   "devDependencies": {
     "typescript": "^5.3.3",
-    "wxt": "^0.14.0"
+    "wxt": "^0.16.0"
   }
 }

templates/vue/package.json

@@ -21,6 +21,6 @@
     "@vitejs/plugin-vue": "^5.0.1",
     "typescript": "^5.3.3",
     "vue-tsc": "^1.8.27",
-    "wxt": "^0.14.0"
+    "wxt": "^0.16.0"
   }
 }