chore(release): v0.16.3

feat: Hooks (#419 )
Deprecated `transformManifest` since a hook now exists for it.
2024-02-04 23:41:38 +00:00 · 2024-02-04 17:37:31 -06:00 · 2024-02-04 16:34:10 -06:00 · 2024-02-04 14:11:41 -06:00 · 2024-02-04 03:14:47 -06:00 · 2024-02-04 03:14:15 -06:00
88 changed files with 3363 additions and 2115 deletions
@@ -9,3 +9,7 @@ updates:
    directory: '/' # Location of package manifests
    schedule:
      interval: 'monthly'
+  - package-ecosystem: 'github-actions'
+    directory: '/'
+    schedule:
+      interval: 'monthly'
@@ -14,7 +14,7 @@ jobs:
  publish:
    runs-on: ubuntu-22.04
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: ./.github/actions/setup
      - uses: docker/login-action@v3
        with:
@@ -11,7 +11,7 @@ jobs:
    needs:
      - validate
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

@@ -11,7 +11,7 @@ jobs:
  sync:
    runs-on: ubuntu-22.04
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: pnpm/action-setup@v2
        with:
          version: 8
@@ -10,25 +10,25 @@ jobs:
  formatting:
    runs-on: ubuntu-22.04
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: ./.github/actions/setup
      - run: pnpm format:check
  lint:
    runs-on: ubuntu-22.04
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: ./.github/actions/setup
      - run: pnpm lint
  type-check:
    runs-on: ubuntu-22.04
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: ./.github/actions/setup
      - run: pnpm compile
  validate-demo:
    runs-on: ubuntu-22.04
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: ./.github/actions/setup
      - run: pnpm tsc --noEmit
        working-directory: demo
@@ -41,17 +41,17 @@ jobs:
  tests:
    runs-on: ubuntu-22.04
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: ./.github/actions/setup
      - name: pnpm test:coverage
        run: pnpm test:coverage --reporter=default --reporter=hanging-process
-      - uses: codecov/codecov-action@v3
+      - uses: codecov/codecov-action@v4
        env:
          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
  windows-tests:
    runs-on: windows-latest
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: ./.github/actions/setup
      - run: pnpm test run
  template:
@@ -65,7 +65,7 @@ jobs:
          - vanilla
          - vue
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: ./.github/actions/setup
      - run: pnpm pack
      - run: npm i
@@ -1,5 +1,137 @@
 # Changelog

+## v0.16.3
+
+[compare changes](https://github.com/wxt-dev/wxt/compare/v0.16.2...v0.16.3)
+
+### 🚀 Enhancements
+
+- Hooks ([#419](https://github.com/wxt-dev/wxt/pull/419))
+
+### 🩹 Fixes
+
+- **init:** Use `ungh` to prevent rate limits when loading templates ([37ad2c7](https://github.com/wxt-dev/wxt/commit/37ad2c7))
+
+### 📖 Documentation
+
+- Fix typo of intuitive ([#415](https://github.com/wxt-dev/wxt/pull/415))
+- Fix typo of opinionated ([#416](https://github.com/wxt-dev/wxt/pull/416))
+
+### 🏡 Chore
+
+- Add dependabot for github actions ([#404](https://github.com/wxt-dev/wxt/pull/404))
+- **deps-dev:** Bump happy-dom from 12.10.3 to 13.3.8 ([#411](https://github.com/wxt-dev/wxt/pull/411))
+- **deps-dev:** Bump typescript from 5.3.2 to 5.3.3 ([#409](https://github.com/wxt-dev/wxt/pull/409))
+- Register global `wxt` instance ([#418](https://github.com/wxt-dev/wxt/pull/418))
+
+### ❤️ Contributors
+
+- Chen Hua <hcljsq@gmail.com>
+- Florian Metz ([@Timeraa](http://github.com/Timeraa))
+
+## v0.16.2
+
+[compare changes](https://github.com/wxt-dev/wxt/compare/v0.16.1...v0.16.2)
+
+### 🩹 Fixes
+
+- Don't crash background service worker when using `import.meta.url` ([#402](https://github.com/wxt-dev/wxt/pull/402))
+
+## 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)
@@ -22,7 +154,7 @@

 ### ❤️ Contributors

- 0x7a7a <298164449@qq.com>
+- 0x7a7a ([@0x7a7a](https://github.com/0x7a7a))

 ## v0.15.0

@@ -1,37 +1,42 @@
 import messages from 'public/_locales/en/messages.json';

-export default defineBackground(() => {
-  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,
-  });
+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({
+      url: import.meta.url,
+      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());
+  },
 });
@@ -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);
@@ -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' },
@@ -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.
@@ -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
@@ -7,7 +7,7 @@ head:

 # Introduction

-WXT is a free and open source framework for building web extensions in an conventional, intuative, and safe way **_for all browsers_**.
+WXT is a free and open source framework for building web extensions in an conventional, intuitive, and safe way **_for all browsers_**.

 WXT is based of [Nuxt](https://nuxt.com), and aims to provide the same great DX with TypeScript, auto-imports, and an opinionated project structure.

@@ -15,7 +15,7 @@ WXT is based of [Nuxt](https://nuxt.com), and aims to provide the same great DX

 ## Conventions

-WXT is an optionated framework. This helps keep projects consistent and easy to pick up.
+WXT is an opinionated framework. This helps keep projects consistent and easy to pick up.

 - **Generated manifest**: Based on your project's file structure
 - **Entrypoint configuration**: Configure entrypoints from the same file they're declare in
@@ -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.

@@ -0,0 +1,99 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { TestProject } from '../utils';
+import { WxtHooks } from '~/types';
+
+const hooks: WxtHooks = {
+  ready: vi.fn(),
+  'build:before': vi.fn(),
+  'build:done': vi.fn(),
+  'build:manifestGenerated': vi.fn(),
+  'entrypoints:resolved': vi.fn(),
+  'entrypoints:grouped': vi.fn(),
+};
+
+function expectHooksToBeCalled(called: Record<keyof WxtHooks, boolean>) {
+  Object.keys(hooks).forEach((key) => {
+    const hookName = key as keyof WxtHooks;
+    const times = called[hookName] ? 1 : 0;
+    expect(
+      hooks[hookName],
+      `Expected "${hookName}" to be called ${times} time(s)`,
+    ).toBeCalledTimes(called[hookName] ? 1 : 0);
+  });
+}
+
+describe('Hooks', () => {
+  beforeEach(() => {
+    Object.values(hooks).forEach((fn) => fn.mockReset());
+  });
+
+  it('prepare should call hooks', async () => {
+    const project = new TestProject();
+    project.addFile('entrypoints/popup.html', '<html></html>');
+
+    await project.prepare({ hooks });
+
+    expectHooksToBeCalled({
+      ready: true,
+      'build:before': false,
+      'build:done': false,
+      'build:manifestGenerated': false,
+      'entrypoints:grouped': false,
+      'entrypoints:resolved': true,
+    });
+  });
+
+  it('build should call hooks', async () => {
+    const project = new TestProject();
+    project.addFile('entrypoints/popup.html', '<html></html>');
+
+    await project.build({ hooks });
+
+    expectHooksToBeCalled({
+      ready: true,
+      'build:before': true,
+      'build:done': true,
+      'build:manifestGenerated': true,
+      'entrypoints:grouped': true,
+      'entrypoints:resolved': true,
+    });
+  });
+
+  it('zip should call hooks', async () => {
+    const project = new TestProject();
+    project.addFile('entrypoints/popup.html', '<html></html>');
+
+    await project.zip({ hooks });
+
+    expectHooksToBeCalled({
+      ready: true,
+      'build:before': true,
+      'build:done': true,
+      'build:manifestGenerated': true,
+      'entrypoints:grouped': true,
+      'entrypoints:resolved': true,
+    });
+  });
+
+  it('server.start should call hooks', async () => {
+    const project = new TestProject();
+    project.addFile('entrypoints/popup.html', '<html></html>');
+
+    const server = await project.startServer({
+      hooks,
+      runner: {
+        disabled: true,
+      },
+    });
+    await server.stop();
+
+    expectHooksToBeCalled({
+      ready: true,
+      'build:before': true,
+      'build:done': true,
+      'build:manifestGenerated': true,
+      'entrypoints:grouped': true,
+      'entrypoints:resolved': true,
+    });
+  });
+});
@@ -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;
+          }
+        })();
+        "
+      `);
+  });
 });
@@ -2,7 +2,14 @@ import { dirname, join, relative, resolve } from 'path';
 import fs from 'fs-extra';
 import glob from 'fast-glob';
 import { execaCommand } from 'execa';
-import { InlineConfig, UserConfig, build } from '../src';
+import {
+  InlineConfig,
+  UserConfig,
+  build,
+  createServer,
+  prepare,
+  zip,
+} from '../src';
 import { normalizePath } from '../src/core/utils/paths';
 import merge from 'lodash.merge';

@@ -63,10 +70,29 @@ export class TestProject {
    if (filename === 'wxt.config.ts') this.config = {};
  }

-  /**
-   * Write the files to the test directory install dependencies, and build the project.
-   */
+  async prepare(config: InlineConfig = {}) {
+    await this.writeProjectToDisk();
+    await prepare({ ...config, root: this.root });
+  }
+
  async build(config: InlineConfig = {}) {
+    await this.writeProjectToDisk();
+    await build({ ...config, root: this.root });
+  }
+
+  async zip(config: InlineConfig = {}) {
+    await this.writeProjectToDisk();
+    await zip({ ...config, root: this.root });
+  }
+
+  async startServer(config: InlineConfig = {}) {
+    await this.writeProjectToDisk();
+    const server = await createServer({ ...config, root: this.root });
+    await server.start();
+    return server;
+  }
+
+  private async writeProjectToDisk() {
    if (this.config == null) this.setConfigFileConfig();

    for (const file of this.files) {
@@ -80,7 +106,6 @@ export class TestProject {
    await execaCommand('pnpm --ignore-workspace i --ignore-scripts', {
      cwd: this.root,
    });
-    await build({ ...config, root: this.root });
  }

  /**
@@ -1,7 +1,7 @@
 {
  "name": "wxt",
  "type": "module",
-  "version": "0.15.1",
+  "version": "0.16.3",
  "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 .",
@@ -120,6 +120,7 @@
    "fs-extra": "^11.1.1",
    "get-port": "^7.0.0",
    "giget": "^1.1.3",
+    "hookable": "^5.5.3",
    "immer": "^10.0.3",
    "is-wsl": "^3.0.0",
    "jiti": "^1.21.0",
@@ -132,6 +133,7 @@
    "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.12",
@@ -149,7 +151,7 @@
    "@types/prompts": "^2.4.9",
    "@vitest/coverage-v8": "^1.0.1",
    "execa": "^8.0.1",
-    "happy-dom": "^12.10.3",
+    "happy-dom": "^13.3.8",
    "lint-staged": "^15.2.0",
    "lodash.merge": "^4.6.2",
    "npm-run-all": "^4.1.5",
@@ -94,7 +94,7 @@ const config: tsup.Options[] = [
  {
    ...preset,
    entry: {
-      cli: 'src/cli.ts',
+      cli: 'src/cli/index.ts',
    },
    format: ['esm'],
    banner: {
@@ -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',
@@ -0,0 +1,94 @@
+import { CAC, Command } from 'cac';
+import consola, { LogLevels } from 'consola';
+import { exec } from '~/core/utils/exec';
+import { printHeader } from '~/core/utils/log';
+import { formatDuration } from '~/core/utils/time';
+import { ValidationError } from '~/core/utils/validation';
+import { registerWxt } from '~/core/wxt';
+
+/**
+ * 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 {
+        await registerWxt('build');
+
+        const args = process.argv.slice(
+          process.argv.indexOf(aliasedCommand.name) + 1,
+        );
+        await exec(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);
+}
@@ -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;
@@ -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();
@@ -1,5 +1,6 @@
 import { BuildOutput, InlineConfig } from '~/types';
-import { getInternalConfig, internalBuild } from './utils/building';
+import { internalBuild } from './utils/building';
+import { registerWxt } from './wxt';

 /**
 * Bundles the extension for production. Returns a promise of the build result. Discovers the `wxt.config.ts` file in
@@ -15,6 +16,7 @@ import { getInternalConfig, internalBuild } from './utils/building';
 * })
 */
 export async function build(config?: InlineConfig): Promise<BuildOutput> {
-  const internalConfig = await getInternalConfig(config ?? {}, 'build');
-  return await internalBuild(internalConfig);
+  await registerWxt('build', config);
+
+  return await internalBuild();
 }
@@ -3,7 +3,7 @@ import {
  BuildStepOutput,
  Entrypoint,
  InlineConfig,
-  InternalConfig,
+  ResolvedConfig,
  UserConfig,
  VirtualEntrypointType,
  WxtBuilder,
@@ -15,7 +15,7 @@ import { getEntrypointBundlePath } from '~/core/utils/entrypoints';
 export async function createViteBuilder(
  inlineConfig: InlineConfig,
  userConfig: UserConfig,
-  wxtConfig: Omit<InternalConfig, 'builder'>,
+  wxtConfig: Omit<ResolvedConfig, 'builder'>,
 ): Promise<WxtBuilder> {
  const vite = await import('vite');

@@ -63,6 +63,7 @@ export async function createViteBuilder(
      wxtPlugins.noopBackground(),
      wxtPlugins.globals(wxtConfig),
      wxtPlugins.excludeBrowserPolyfill(wxtConfig),
+      wxtPlugins.defineImportMeta(),
    );
    if (wxtConfig.analysis.enabled) {
      config.plugins.push(wxtPlugins.bundleAnalysis());
@@ -75,23 +76,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),
    ];
@@ -157,14 +142,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]',
          },
@@ -263,3 +250,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;
+}
@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'vitest';
+import { Window } from 'happy-dom';
+import { pointToDevServer } from '../devHtmlPrerender';
+import {
+  fakeDevServer,
+  fakeResolvedConfig,
+} 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 = fakeResolvedConfig({
+        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);
+    });
+  });
+});
@@ -1,5 +1,5 @@
 import type * as vite from 'vite';
-import { Entrypoint, InternalConfig } from '~/types';
+import { Entrypoint, ResolvedConfig } from '~/types';
 import { getEntrypointBundlePath } from '~/core/utils/entrypoints';

 /**
@@ -14,7 +14,7 @@ import { getEntrypointBundlePath } from '~/core/utils/entrypoints';
 */
 export function cssEntrypoints(
  entrypoint: Entrypoint,
-  config: Omit<InternalConfig, 'builder'>,
+  config: Omit<ResolvedConfig, 'builder'>,
 ): vite.Plugin {
  return {
    name: 'wxt:css-entrypoint',
@@ -0,0 +1,19 @@
+/**
+ * Overrides definitions for `import.meta.*`
+ *
+ * - `import.meta.url`: Without this, background service workers crash trying to access
+ *   `document.location`, see https://github.com/wxt-dev/wxt/issues/392
+ */
+export function defineImportMeta() {
+  return {
+    name: 'wxt:define',
+    config() {
+      return {
+        define: {
+          // This works for all extension contexts, including background service worker
+          'import.meta.url': 'self.location.href',
+        },
+      };
+    },
+  };
+}
@@ -1,8 +1,9 @@
 import type * as vite from 'vite';
-import { InternalConfig } from '~/types';
+import { ResolvedConfig, 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 = '';
@@ -11,7 +12,7 @@ let reactRefreshPreamble = '';
 * Pre-renders the HTML entrypoints when building the extension to connect to the dev server.
 */
 export function devHtmlPrerender(
-  config: Omit<InternalConfig, 'builder'>,
+  config: Omit<ResolvedConfig, 'builder'>,
 ): vite.PluginOption {
  const htmlReloadId = '@wxt/reload-html';
  const resolvedHtmlReloadId = resolve(
@@ -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<ResolvedConfig, '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;
+  }
+}
@@ -1,11 +1,11 @@
 import { Plugin } from 'vite';
-import { InternalConfig } from '~/types';
+import { ResolvedConfig } from '~/types';

 /**
 * Defines global constants about the dev server. Helps scripts connect to the server's web socket.
 */
 export function devServerGlobals(
-  config: Omit<InternalConfig, 'builder'>,
+  config: Omit<ResolvedConfig, 'builder'>,
 ): Plugin {
  return {
    name: 'wxt:dev-server-globals',
@@ -1,5 +1,5 @@
 import { Plugin } from 'vite';
-import { InternalConfig } from '~/types';
+import { ResolvedConfig } from '~/types';
 import { fetchCached } from '~/core/utils/network';

 /**
@@ -9,7 +9,7 @@ import { fetchCached } from '~/core/utils/network';
 * @example
 * import "url:https://google-tagmanager.com/gtag?id=XYZ";
 */
-export function download(config: Omit<InternalConfig, 'builder'>): Plugin {
+export function download(config: Omit<ResolvedConfig, 'builder'>): Plugin {
  return {
    name: 'wxt:download',
    resolveId(id) {
@@ -1,4 +1,4 @@
-import { InternalConfig } from '~/types';
+import { ResolvedConfig } from '~/types';
 import type * as vite from 'vite';

 /**
@@ -7,7 +7,7 @@ import type * as vite from 'vite';
 * virtual module.
 */
 export function excludeBrowserPolyfill(
-  config: Omit<InternalConfig, 'builder'>,
+  config: Omit<ResolvedConfig, 'builder'>,
 ): vite.Plugin {
  const virtualId = 'virtual:wxt-webextension-polyfill-disabled';

@@ -1,9 +1,9 @@
 import type * as vite from 'vite';
-import { InternalConfig } from '~/types';
+import { ResolvedConfig } from '~/types';
 import { getGlobals } from '~/core/utils/globals';

 export function globals(
-  config: Omit<InternalConfig, 'builder'>,
+  config: Omit<ResolvedConfig, 'builder'>,
 ): vite.PluginOption {
  return {
    name: 'wxt:globals',
@@ -12,3 +12,4 @@ export * from './globals';
 export * from './webextensionPolyfillMock';
 export * from './excludeBrowserPolyfill';
 export * from './entrypointGroupGlobals';
+export * from './defineImportMeta';
@@ -1,5 +1,5 @@
 import type * as vite from 'vite';
-import { Entrypoint, InternalConfig } from '~/types';
+import { Entrypoint, ResolvedConfig } from '~/types';
 import { dirname, extname, resolve, join } from 'node:path';
 import { getEntrypointBundlePath } from '~/core/utils/entrypoints';
 import fs, { ensureDir } from 'fs-extra';
@@ -20,7 +20,7 @@ import { normalizePath } from '~/core/utils/paths';
 */
 export function multipageMove(
  entrypoints: Entrypoint[],
-  config: Omit<InternalConfig, 'builder'>,
+  config: Omit<ResolvedConfig, 'builder'>,
 ): vite.Plugin {
  return {
    name: 'wxt:multipage-move',
@@ -1,8 +1,8 @@
-import { InternalConfig } from '~/types';
+import { ResolvedConfig } from '~/types';
 import type * as vite from 'vite';

 export function tsconfigPaths(
-  config: Omit<InternalConfig, 'builder'>,
+  config: Omit<ResolvedConfig, 'builder'>,
 ): vite.Plugin {
  return {
    name: 'wxt:aliases',
@@ -1,5 +1,5 @@
 import { createUnimport } from 'unimport';
-import { InternalConfig } from '~/types';
+import { ResolvedConfig } from '~/types';
 import { getUnimportOptions } from '~/core/utils/unimport';
 import type * as vite from 'vite';
 import { extname } from 'path';
@@ -17,7 +17,7 @@ const ENABLED_EXTENSIONS = new Set([
 * Inject any global imports defined by unimport
 */
 export function unimport(
-  config: Omit<InternalConfig, 'builder'>,
+  config: Omit<ResolvedConfig, 'builder'>,
 ): vite.PluginOption {
  const options = getUnimportOptions(config);
  if (options === false) return [];
@@ -1,5 +1,5 @@
 import { Plugin } from 'vite';
-import { InternalConfig, VirtualEntrypointType } from '~/types';
+import { ResolvedConfig, VirtualEntrypointType } from '~/types';
 import fs from 'fs-extra';
 import { resolve } from 'path';
 import { normalizePath } from '~/core/utils/paths';
@@ -9,7 +9,7 @@ import { normalizePath } from '~/core/utils/paths';
 */
 export function virtualEntrypoint(
  type: VirtualEntrypointType,
-  config: Omit<InternalConfig, 'builder'>,
+  config: Omit<ResolvedConfig, 'builder'>,
 ): Plugin {
  const virtualId = `virtual:wxt-${type}?`;
  const resolvedVirtualId = `\0${virtualId}`;
@@ -1,6 +1,6 @@
 import path from 'node:path';
 import type * as vite from 'vite';
-import { InternalConfig } from '~/types';
+import { ResolvedConfig } from '~/types';

 /**
 * Mock `webextension-polyfill` by inlining all dependencies that import it and adding a custom
@@ -16,7 +16,7 @@ import { InternalConfig } from '~/types';
 * `npm list` and inline them automatically.
 */
 export function webextensionPolyfillMock(
-  config: Omit<InternalConfig, 'builder'>,
+  config: Omit<ResolvedConfig, 'builder'>,
 ): vite.PluginOption {
  return {
    name: 'wxt:testing-inline-deps',
@@ -2,13 +2,11 @@ import {
  BuildStepOutput,
  EntrypointGroup,
  InlineConfig,
-  InternalConfig,
  ServerInfo,
  WxtDevServer,
 } from '~/types';
 import {
  getEntrypointBundlePath,
-  getEntrypointOutputFile,
  resolvePerBrowserOption,
 } from '~/core/utils/entrypoints';
 import {
@@ -17,7 +15,6 @@ import {
 } from '~/core/utils/manifest';
 import {
  internalBuild,
-  getInternalConfig,
  detectDevChanges,
  rebuild,
  findEntrypoints,
@@ -27,6 +24,7 @@ import { consola } from 'consola';
 import { Mutex } from 'async-mutex';
 import pc from 'picocolors';
 import { relative } from 'node:path';
+import { registerWxt, wxt } from './wxt';

 /**
 * Creates a dev server and pre-builds all the files that need to exist before loading the extension.
@@ -51,10 +49,10 @@ export async function createServer(

  const buildAndOpenBrowser = async () => {
    // Build after starting the dev server so it can be used to transform HTML files
-    server.currentOutput = await internalBuild(config);
+    server.currentOutput = await internalBuild();

    // Open browser after everything is ready to go.
-    await runner.openBrowser(config);
+    await runner.openBrowser();
  };

  /**
@@ -62,8 +60,8 @@ export async function createServer(
   */
  const closeAndRecreateRunner = async () => {
    await runner.closeBrowser();
-    config = await getLatestConfig();
-    runner = await createExtensionRunner(config);
+    await wxt.reloadConfig();
+    runner = await createExtensionRunner();
  };

  // Server instance must be created first so its reference can be added to the internal config used
@@ -79,7 +77,7 @@ export async function createServer(
    currentOutput: undefined,
    async start() {
      await builderServer.listen();
-      config.logger.success(`Started dev server @ ${serverInfo.origin}`);
+      wxt.logger.success(`Started dev server @ ${serverInfo.origin}`);
      await buildAndOpenBrowser();
    },
    async stop() {
@@ -104,34 +102,26 @@ export async function createServer(
    },
    async restartBrowser() {
      await closeAndRecreateRunner();
-      await runner.openBrowser(config);
+      await runner.openBrowser();
    },
  };

-  const getLatestConfig = () =>
-    getInternalConfig(inlineConfig ?? {}, 'serve', server);
-  let config = await getLatestConfig();
+  await registerWxt('serve', inlineConfig, server);

  let [runner, builderServer] = await Promise.all([
-    createExtensionRunner(config),
-    config.builder.createServer(server),
+    createExtensionRunner(),
+    wxt.config.builder.createServer(server),
  ]);

  // Register content scripts for the first time after the background starts up since they're not
  // listed in the manifest
  server.ws.on('wxt:background-initialized', () => {
    if (server.currentOutput == null) return;
-    reloadContentScripts(server.currentOutput.steps, config, server);
+    reloadContentScripts(server.currentOutput.steps, server);
  });

  // Listen for file changes and reload different parts of the extension accordingly
-  const reloadOnChange = createFileReloader({
-    server,
-    getLatestConfig,
-    updateConfig(newConfig) {
-      config = newConfig;
-    },
-  });
+  const reloadOnChange = createFileReloader(server);
  server.watcher.on('all', reloadOnChange);

  return server;
@@ -146,21 +136,15 @@ async function getPort(): Promise<number> {
 * Returns a function responsible for reloading different parts of the extension when a file
 * changes.
 */
-function createFileReloader(options: {
-  server: WxtDevServer;
-  getLatestConfig: () => Promise<InternalConfig>;
-  updateConfig: (config: InternalConfig) => void;
-}) {
-  const { server, getLatestConfig, updateConfig } = options;
+function createFileReloader(server: WxtDevServer) {
  const fileChangedMutex = new Mutex();
  const changeQueue: Array<[string, string]> = [];

  return async (event: string, path: string) => {
-    const config = await getLatestConfig();
-    updateConfig(config);
+    await wxt.reloadConfig();

    // Here, "path" is a non-normalized path (ie: C:\\users\\... instead of C:/users/...)
-    if (path.startsWith(config.outBaseDir)) return;
+    if (path.startsWith(wxt.config.outBaseDir)) return;
    changeQueue.push([event, path]);

    await fileChangedMutex.runExclusive(async () => {
@@ -171,45 +155,31 @@ function createFileReloader(options: {
        .map(([_, file]) => file);
      if (fileChanges.length === 0) return;

-      const changes = detectDevChanges(
-        config,
-        fileChanges,
-        server.currentOutput,
-      );
+      const changes = detectDevChanges(fileChanges, server.currentOutput);
      if (changes.type === 'no-change') return;

      if (changes.type === 'full-restart') {
-        config.logger.info('Config changed, restarting server...');
+        wxt.logger.info('Config changed, restarting server...');
        server.restart();
        return;
      }

      if (changes.type === 'browser-restart') {
-        config.logger.info('Runner config changed, restarting browser...');
+        wxt.logger.info('Runner config changed, restarting browser...');
        server.restartBrowser();
        return;
      }

      // Log the entrypoints that were effected
-      config.logger.info(
+      wxt.logger.info(
        `Changed: ${Array.from(new Set(fileChanges))
-          .map((file) => pc.dim(relative(config.root, file)))
+          .map((file) => pc.dim(relative(wxt.config.root, file)))
          .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 allEntrypoints = await findEntrypoints();
      const { output: newOutput } = await rebuild(
-        config,
        allEntrypoints,
        // TODO: this excludes new entrypoints, so they're not built until the dev command is restarted
        changes.rebuildGroups,
@@ -221,15 +191,23 @@ 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,
+          );
+          consola.success(`Reloaded: ${getFilenameList(reloadedNames)}`);
          break;
        case 'content-script-reload':
-          reloadContentScripts(changes.changedSteps, config, server);
+          reloadContentScripts(changes.changedSteps, server);
+          const rebuiltNames = changes.rebuildGroups
+            .flat()
+            .map((entry) => entry.name);
+          consola.success(`Reloaded: ${getFilenameList(rebuiltNames)}`);
          break;
      }
-      consola.success(`Reloaded: ${rebuiltNames}`);
    });
  };
 }
@@ -237,35 +215,34 @@ function createFileReloader(options: {
 /**
 * From the server, tell the client to reload content scripts from the provided build step outputs.
 */
-function reloadContentScripts(
-  steps: BuildStepOutput[],
-  config: InternalConfig,
-  server: WxtDevServer,
-) {
-  if (config.manifestVersion === 3) {
+function reloadContentScripts(steps: BuildStepOutput[], server: WxtDevServer) {
+  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 = [getEntrypointBundlePath(entry, config.outDir, '.js')];
+      const js = [getEntrypointBundlePath(entry, wxt.config.outDir, '.js')];
      const cssMap = getContentScriptsCssMap(server.currentOutput, [entry]);
      const css = getContentScriptCssFiles([entry], cssMap);

      server.reloadContentScript({
        allFrames: resolvePerBrowserOption(
          entry.options.allFrames,
-          config.browser,
+          wxt.config.browser,
        ),
        excludeMatches: resolvePerBrowserOption(
          entry.options.excludeMatches,
-          config.browser,
+          wxt.config.browser,
        ),
-        matches: resolvePerBrowserOption(entry.options.matches, config.browser),
-        runAt: resolvePerBrowserOption(entry.options.runAt, config.browser),
+        matches: resolvePerBrowserOption(
+          entry.options.matches,
+          wxt.config.browser,
+        ),
+        runAt: resolvePerBrowserOption(entry.options.runAt, wxt.config.browser),
        // @ts-expect-error: Chrome accepts this, not typed in webextension-polyfill (https://developer.chrome.com/docs/extensions/reference/scripting/#type-RegisteredContentScript)
-        world: resolvePerBrowserOption(entry.options.world, config.browser),
+        world: resolvePerBrowserOption(entry.options.world, wxt.config.browser),
        js,
        css,
      });
@@ -278,10 +255,26 @@ function reloadContentScripts(
 function reloadHtmlPages(
  groups: EntrypointGroup[],
  server: WxtDevServer,
-  config: InternalConfig,
-) {
-  groups.flat().forEach((entry) => {
-    const path = getEntrypointBundlePath(entry, config.outDir, '.html');
+): { 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, wxt.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(', '));
 }
@@ -90,26 +90,25 @@ interface Template {

 async function listTemplates(): Promise<Template[]> {
  try {
-    const res = await fetch(
-      'https://api.github.com/repos/wxt-dev/wxt/contents/templates',
-      {
-        headers: {
-          Accept: 'application/vnd.github+json',
-          'X-GitHub-Api-Version': '2022-11-28',
-        },
-      },
-    );
+    const res = await fetch('https://ungh.cc/repos/wxt-dev/wxt/files/main');
    if (res.status >= 300)
      throw Error(`Request failed with status ${res.status} ${res.statusText}`);

-    const data = (await res.json()) as Array<{
-      type: 'file' | 'dir';
-      name: string;
-      path: string;
-    }>;
-    return data
-      .filter((item: any) => item.type === 'dir')
-      .map((item) => ({ name: item.name, path: item.path }))
+    const data = (await res.json()) as {
+      meta: {
+        sha: string;
+      };
+      files: Array<{
+        path: string;
+        mode: string;
+        sha: string;
+        size: number;
+      }>;
+    };
+    return data.files
+      .map((item) => item.path.match(/templates\/(.+)\/package\.json/)?.[1])
+      .filter((name) => name != null)
+      .map((name) => ({ name: name!, path: `templates/${name}` }))
      .sort((l, r) => {
        const lWeight = TEMPLATE_SORT_WEIGHT[l.name] ?? Number.MAX_SAFE_INTEGER;
        const rWeight = TEMPLATE_SORT_WEIGHT[r.name] ?? Number.MAX_SAFE_INTEGER;
@@ -1,15 +1,11 @@
 import { InlineConfig } from '~/types';
-import {
-  findEntrypoints,
-  generateTypesDir,
-  getInternalConfig,
-} from '~/core/utils/building';
+import { findEntrypoints, generateTypesDir } from '~/core/utils/building';
+import { registerWxt, wxt } from './wxt';

 export async function prepare(config: InlineConfig) {
-  const internalConfig = await getInternalConfig(config, 'build');
+  await registerWxt('build', config);
+  wxt.logger.info('Generating types...');

-  internalConfig.logger.info('Generating types...');
-
-  const entrypoints = await findEntrypoints(internalConfig);
-  await generateTypesDir(entrypoints, internalConfig);
+  const entrypoints = await findEntrypoints();
+  await generateTypesDir(entrypoints);
 }
@@ -1,6 +1,6 @@
 import { describe, expect, it, vi } from 'vitest';
 import { createExtensionRunner } from '..';
-import { fakeInternalConfig } from '~/core/utils/testing/fake-objects';
+import { setFakeWxt } from '~/core/utils/testing/fake-objects';
 import { mock } from 'vitest-mock-extended';
 import { createSafariRunner } from '../safari';
 import { createWslRunner } from '../wsl';
@@ -26,54 +26,62 @@ const createWebExtRunnerMock = vi.mocked(createWebExtRunner);

 describe('createExtensionRunner', () => {
  it('should return a Safari runner when browser is "safari"', async () => {
-    const config = fakeInternalConfig({
-      browser: 'safari',
+    setFakeWxt({
+      config: {
+        browser: 'safari',
+      },
    });
    const safariRunner = mock<ExtensionRunner>();
    createSafariRunnerMock.mockReturnValue(safariRunner);

-    await expect(createExtensionRunner(config)).resolves.toBe(safariRunner);
+    await expect(createExtensionRunner()).resolves.toBe(safariRunner);
  });

  it('should return a WSL runner when `is-wsl` is true', async () => {
    isWslMock.mockResolvedValueOnce(true);
-    const config = fakeInternalConfig({
-      browser: 'chrome',
+    setFakeWxt({
+      config: {
+        browser: 'chrome',
+      },
    });
    const wslRunner = mock<ExtensionRunner>();
    createWslRunnerMock.mockReturnValue(wslRunner);

-    await expect(createExtensionRunner(config)).resolves.toBe(wslRunner);
+    await expect(createExtensionRunner()).resolves.toBe(wslRunner);
  });

  it('should return a manual runner when `runner.disabled` is true', async () => {
    isWslMock.mockResolvedValueOnce(false);
-    const config = fakeInternalConfig({
-      browser: 'chrome',
-      runnerConfig: {
-        config: {
-          disabled: true,
+    setFakeWxt({
+      config: {
+        browser: 'chrome',
+        runnerConfig: {
+          config: {
+            disabled: true,
+          },
        },
      },
    });
    const manualRunner = mock<ExtensionRunner>();
    createManualRunnerMock.mockReturnValue(manualRunner);

-    await expect(createExtensionRunner(config)).resolves.toBe(manualRunner);
+    await expect(createExtensionRunner()).resolves.toBe(manualRunner);
  });

  it('should return a web-ext runner otherwise', async () => {
-    const config = fakeInternalConfig({
-      browser: 'chrome',
-      runnerConfig: {
-        config: {
-          disabled: undefined,
+    setFakeWxt({
+      config: {
+        browser: 'chrome',
+        runnerConfig: {
+          config: {
+            disabled: undefined,
+          },
        },
      },
    });
    const manualRunner = mock<ExtensionRunner>();
    createWebExtRunnerMock.mockReturnValue(manualRunner);

-    await expect(createExtensionRunner(config)).resolves.toBe(manualRunner);
+    await expect(createExtensionRunner()).resolves.toBe(manualRunner);
  });
 });
@@ -1,17 +1,16 @@
-import { InternalConfig, ExtensionRunner } from '~/types';
+import { ExtensionRunner } from '~/types';
 import { createWslRunner } from './wsl';
 import { createWebExtRunner } from './web-ext';
 import { createSafariRunner } from './safari';
 import { createManualRunner } from './manual';
 import { isWsl } from '~/core/utils/wsl';
+import { wxt } from '../wxt';

-export async function createExtensionRunner(
-  config: InternalConfig,
-): Promise<ExtensionRunner> {
-  if (config.browser === 'safari') return createSafariRunner();
+export async function createExtensionRunner(): Promise<ExtensionRunner> {
+  if (wxt.config.browser === 'safari') return createSafariRunner();

  if (await isWsl()) return createWslRunner();
-  if (config.runnerConfig.config?.disabled) return createManualRunner();
+  if (wxt.config.runnerConfig.config?.disabled) return createManualRunner();

  return createWebExtRunner();
 }
@@ -1,16 +1,17 @@
 import { ExtensionRunner } from '~/types';
 import { relative } from 'node:path';
+import { wxt } from '../wxt';

 /**
 * The manual runner tells the user to load the unpacked extension manually.
 */
 export function createManualRunner(): ExtensionRunner {
  return {
-    async openBrowser(config) {
-      config.logger.info(
+    async openBrowser() {
+      wxt.logger.info(
        `Load "${relative(
          process.cwd(),
-          config.outDir,
+          wxt.config.outDir,
        )}" as an unpacked extension manually`,
      );
    },
@@ -1,16 +1,17 @@
 import { ExtensionRunner } from '~/types';
 import { relative } from 'node:path';
+import { wxt } from '../wxt';

 /**
 * The Safari runner just logs a warning message because `web-ext` doesn't work with Safari.
 */
 export function createSafariRunner(): ExtensionRunner {
  return {
-    async openBrowser(config) {
-      config.logger.warn(
+    async openBrowser() {
+      wxt.logger.warn(
        `Cannot Safari using web-ext. Load "${relative(
          process.cwd(),
-          config.outDir,
+          wxt.config.outDir,
        )}" as an unpacked extension manually`,
      );
    },
@@ -2,6 +2,7 @@ import type { WebExtRunInstance } from 'web-ext-run';
 import { ExtensionRunner } from '~/types';
 import { formatDuration } from '../utils/time';
 import defu from 'defu';
+import { wxt } from '../wxt';

 /**
 * Create an `ExtensionRunner` backed by `web-ext`.
@@ -10,10 +11,13 @@ export function createWebExtRunner(): ExtensionRunner {
  let runner: WebExtRunInstance | undefined;

  return {
-    async openBrowser(config) {
+    async openBrowser() {
      const startTime = Date.now();

-      if (config.browser === 'firefox' && config.manifestVersion === 3) {
+      if (
+        wxt.config.browser === 'firefox' &&
+        wxt.config.manifestVersion === 3
+      ) {
        throw Error(
          'Dev mode does not support Firefox MV3. For alternatives, see https://github.com/wxt-dev/wxt/issues/230#issuecomment-1806881653',
        );
@@ -22,16 +26,16 @@ export function createWebExtRunner(): ExtensionRunner {
      // Use WXT's logger instead of web-ext's built-in one.
      const webExtLogger = await import('web-ext-run/util/logger');
      webExtLogger.consoleStream.write = ({ level, msg, name }) => {
-        if (level >= ERROR_LOG_LEVEL) config.logger.error(name, msg);
-        if (level >= WARN_LOG_LEVEL) config.logger.warn(msg);
+        if (level >= ERROR_LOG_LEVEL) wxt.logger.error(name, msg);
+        if (level >= WARN_LOG_LEVEL) wxt.logger.warn(msg);
      };

-      const wxtUserConfig = config.runnerConfig.config;
+      const wxtUserConfig = wxt.config.runnerConfig.config;
      const userConfig = {
        console: wxtUserConfig?.openConsole,
        devtools: wxtUserConfig?.openDevtools,
        startUrl: wxtUserConfig?.startUrls,
-        ...(config.browser === 'firefox'
+        ...(wxt.config.browser === 'firefox'
          ? {
              firefox: wxtUserConfig?.binaries?.firefox,
              firefoxProfile: wxtUserConfig?.firefoxProfile,
@@ -39,7 +43,7 @@ export function createWebExtRunner(): ExtensionRunner {
              args: wxtUserConfig?.firefoxArgs,
            }
          : {
-              chromiumBinary: wxtUserConfig?.binaries?.[config.browser],
+              chromiumBinary: wxtUserConfig?.binaries?.[wxt.config.browser],
              chromiumProfile: wxtUserConfig?.chromiumProfile,
              chromiumPref: defu(
                wxtUserConfig?.chromiumPref,
@@ -51,8 +55,9 @@ export function createWebExtRunner(): ExtensionRunner {

      const finalConfig = {
        ...userConfig,
-        target: config.browser === 'firefox' ? 'firefox-desktop' : 'chromium',
-        sourceDir: config.outDir,
+        target:
+          wxt.config.browser === 'firefox' ? 'firefox-desktop' : 'chromium',
+        sourceDir: wxt.config.outDir,
        // WXT handles reloads, so disable auto-reload behaviors in web-ext
        noReload: true,
        noInput: true,
@@ -61,14 +66,14 @@ export function createWebExtRunner(): ExtensionRunner {
        // Don't call `process.exit(0)` after starting web-ext
        shouldExitProgram: false,
      };
-      config.logger.debug('web-ext config:', finalConfig);
-      config.logger.debug('web-ext options:', options);
+      wxt.logger.debug('web-ext config:', finalConfig);
+      wxt.logger.debug('web-ext options:', options);

      const webExt = await import('web-ext-run');
      runner = await webExt.default.cmd.run(finalConfig, options);

      const duration = Date.now() - startTime;
-      config.logger.success(`Opened browser in ${formatDuration(duration)}`);
+      wxt.logger.success(`Opened browser in ${formatDuration(duration)}`);
    },

    async closeBrowser() {
@@ -1,16 +1,17 @@
 import { ExtensionRunner } from '~/types';
 import { relative } from 'node:path';
+import { wxt } from '../wxt';

 /**
 * The WSL runner just logs a warning message because `web-ext` doesn't work in WSL.
 */
 export function createWslRunner(): ExtensionRunner {
  return {
-    async openBrowser(config) {
-      config.logger.warn(
+    async openBrowser() {
+      wxt.logger.warn(
        `Cannot open browser when using WSL. Load "${relative(
          process.cwd(),
-          config.outDir,
+          wxt.config.outDir,
        )}" as an unpacked extension manually`,
      );
    },
@@ -1,14 +1,15 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, beforeEach } from 'vitest';
 import { hashContentScriptOptions } from '~/core/utils/content-scripts';
-import { fakeInternalConfig } from '~/core/utils/testing/fake-objects';
+import { setFakeWxt } from '~/core/utils/testing/fake-objects';

 describe('Content Script Utils', () => {
+  beforeEach(() => {
+    setFakeWxt();
+  });
+
  describe('hashContentScriptOptions', () => {
    it('should return a string containing all the options with defaults applied', () => {
-      const hash = hashContentScriptOptions(
-        { matches: [] },
-        fakeInternalConfig(),
-      );
+      const hash = hashContentScriptOptions({ matches: [] });

      expect(hash).toMatchInlineSnapshot(
        `"[["all_frames",false],["exclude_globs",[]],["exclude_matches",[]],["include_globs",[]],["match_about_blank",false],["match_origin_as_fallback",false],["matches",[]],["run_at","document_idle"],["world","ISOLATED"]]"`,
@@ -16,21 +17,15 @@ describe('Content Script Utils', () => {
    });

    it('should be consistent regardless of the object ordering and default values', () => {
-      const hash1 = hashContentScriptOptions(
-        {
-          allFrames: true,
-          matches: ['*://google.com/*', '*://duckduckgo.com/*'],
-          matchAboutBlank: false,
-        },
-        fakeInternalConfig(),
-      );
-      const hash2 = hashContentScriptOptions(
-        {
-          matches: ['*://duckduckgo.com/*', '*://google.com/*'],
-          allFrames: true,
-        },
-        fakeInternalConfig(),
-      );
+      const hash1 = hashContentScriptOptions({
+        allFrames: true,
+        matches: ['*://google.com/*', '*://duckduckgo.com/*'],
+        matchAboutBlank: false,
+      });
+      const hash2 = hashContentScriptOptions({
+        matches: ['*://duckduckgo.com/*', '*://google.com/*'],
+        allFrames: true,
+      });

      expect(hash1).toBe(hash2);
    });
@@ -1,14 +1,14 @@
-import { describe, expect, it } from 'vitest';
+import { beforeEach, describe, expect, it } from 'vitest';
 import { generateManifest, stripPathFromMatchPattern } from '../manifest';
 import {
  fakeArray,
  fakeBackgroundEntrypoint,
  fakeBuildOutput,
  fakeEntrypoint,
-  fakeInternalConfig,
  fakeManifestCommand,
  fakeOptionsEntrypoint,
  fakePopupEntrypoint,
+  setFakeWxt,
 } from '../testing/fake-objects';
 import { Manifest } from 'webextension-polyfill';
 import {
@@ -17,11 +17,16 @@ import {
  Entrypoint,
  OutputAsset,
 } from '~/types';
+import { wxt } from '../../wxt';

 const outDir = '/output';
 const contentScriptOutDir = '/output/content-scripts';

 describe('Manifest Utils', () => {
+  beforeEach(() => {
+    setFakeWxt();
+  });
+
  describe('generateManifest', () => {
    describe('popup', () => {
      type ActionType = 'browser_action' | 'page_action';
@@ -41,9 +46,12 @@ describe('Manifest Utils', () => {
      it('should include an action for mv3', async () => {
        const popup = popupEntrypoint();
        const buildOutput = fakeBuildOutput();
-        const config = fakeInternalConfig({
-          manifestVersion: 3,
-          outDir,
+
+        setFakeWxt({
+          config: {
+            manifestVersion: 3,
+            outDir,
+          },
        });
        const expected: Partial<Manifest.WebExtensionManifest> = {
          action: {
@@ -56,7 +64,6 @@ describe('Manifest Utils', () => {
        const { manifest: actual } = await generateManifest(
          [popup],
          buildOutput,
-          config,
        );

        expect(actual).toMatchObject(expected);
@@ -74,9 +81,11 @@ describe('Manifest Utils', () => {
        async ({ inputType, expectedType }) => {
          const popup = popupEntrypoint(inputType);
          const buildOutput = fakeBuildOutput();
-          const config = fakeInternalConfig({
-            manifestVersion: 2,
-            outDir,
+          setFakeWxt({
+            config: {
+              manifestVersion: 2,
+              outDir,
+            },
          });
          const expected = {
            default_icon: popup.options.defaultIcon,
@@ -87,7 +96,6 @@ describe('Manifest Utils', () => {
          const { manifest: actual } = await generateManifest(
            [popup],
            buildOutput,
-            config,
          );

          expect(actual[expectedType]).toEqual(expected);
@@ -98,24 +106,22 @@ describe('Manifest Utils', () => {
    describe('action without popup', () => {
      it('should respect the action field in the manifest without a popup', async () => {
        const buildOutput = fakeBuildOutput();
-        const config = fakeInternalConfig({
-          outDir,
-          manifest: {
-            action: {
-              default_icon: 'icon-16.png',
-              default_title: 'Example title',
+        setFakeWxt({
+          config: {
+            outDir,
+            manifest: {
+              action: {
+                default_icon: 'icon-16.png',
+                default_title: 'Example title',
+              },
            },
          },
        });
        const expected: Partial<Manifest.WebExtensionManifest> = {
-          action: config.manifest.action,
+          action: wxt.config.manifest.action,
        };

-        const { manifest: actual } = await generateManifest(
-          [],
-          buildOutput,
-          config,
-        );
+        const { manifest: actual } = await generateManifest([], buildOutput);

        expect(actual).toMatchObject(expected);
      });
@@ -132,10 +138,12 @@ describe('Manifest Utils', () => {
      });

      it('should include a options_ui and chrome_style for chrome', async () => {
-        const config = fakeInternalConfig({
-          manifestVersion: 3,
-          outDir,
-          browser: 'chrome',
+        setFakeWxt({
+          config: {
+            manifestVersion: 3,
+            outDir,
+            browser: 'chrome',
+          },
        });
        const buildOutput = fakeBuildOutput();
        const expected = {
@@ -147,17 +155,18 @@ describe('Manifest Utils', () => {
        const { manifest: actual } = await generateManifest(
          [options],
          buildOutput,
-          config,
        );

        expect(actual.options_ui).toEqual(expected);
      });

      it('should include a options_ui and browser_style for firefox', async () => {
-        const config = fakeInternalConfig({
-          manifestVersion: 3,
-          browser: 'firefox',
-          outDir,
+        setFakeWxt({
+          config: {
+            manifestVersion: 3,
+            browser: 'firefox',
+            outDir,
+          },
        });
        const buildOutput = fakeBuildOutput();
        const expected = {
@@ -169,7 +178,6 @@ describe('Manifest Utils', () => {
        const { manifest: actual } = await generateManifest(
          [options],
          buildOutput,
-          config,
        );

        expect(actual.options_ui).toEqual(expected);
@@ -189,10 +197,12 @@ describe('Manifest Utils', () => {
        it.each(['chrome', 'safari'])(
          'should include a service worker and type for %s',
          async (browser) => {
-            const config = fakeInternalConfig({
-              outDir,
-              manifestVersion: 3,
-              browser,
+            setFakeWxt({
+              config: {
+                outDir,
+                manifestVersion: 3,
+                browser,
+              },
            });
            const buildOutput = fakeBuildOutput();
            const expected = {
@@ -203,7 +213,6 @@ describe('Manifest Utils', () => {
            const { manifest: actual } = await generateManifest(
              [background],
              buildOutput,
-              config,
            );

            expect(actual.background).toEqual(expected);
@@ -211,10 +220,12 @@ describe('Manifest Utils', () => {
        );

        it('should include a background script and type for firefox', async () => {
-          const config = fakeInternalConfig({
-            outDir,
-            manifestVersion: 3,
-            browser: 'firefox',
+          setFakeWxt({
+            config: {
+              outDir,
+              manifestVersion: 3,
+              browser: 'firefox',
+            },
          });
          const buildOutput = fakeBuildOutput();
          const expected = {
@@ -225,7 +236,6 @@ describe('Manifest Utils', () => {
          const { manifest: actual } = await generateManifest(
            [background],
            buildOutput,
-            config,
          );

          expect(actual.background).toEqual(expected);
@@ -236,10 +246,12 @@ describe('Manifest Utils', () => {
        it.each(['chrome', 'safari'])(
          'should include scripts and persistent for %s',
          async (browser) => {
-            const config = fakeInternalConfig({
-              outDir,
-              manifestVersion: 2,
-              browser,
+            setFakeWxt({
+              config: {
+                outDir,
+                manifestVersion: 2,
+                browser,
+              },
            });
            const buildOutput = fakeBuildOutput();
            const expected = {
@@ -250,7 +262,6 @@ describe('Manifest Utils', () => {
            const { manifest: actual } = await generateManifest(
              [background],
              buildOutput,
-              config,
            );

            expect(actual.background).toEqual(expected);
@@ -258,10 +269,12 @@ describe('Manifest Utils', () => {
        );

        it('should include a background script and persistent for firefox mv2', async () => {
-          const config = fakeInternalConfig({
-            outDir,
-            manifestVersion: 2,
-            browser: 'firefox',
+          setFakeWxt({
+            config: {
+              outDir,
+              manifestVersion: 2,
+              browser: 'firefox',
+            },
          });
          const buildOutput = fakeBuildOutput();
          const expected = {
@@ -272,7 +285,6 @@ describe('Manifest Utils', () => {
          const { manifest: actual } = await generateManifest(
            [background],
            buildOutput,
-            config,
          );

          expect(actual.background).toEqual(expected);
@@ -293,12 +305,10 @@ describe('Manifest Utils', () => {
            { type: 'asset', fileName: 'icons/128x128.png' },
          ],
        });
-        const config = fakeInternalConfig();

        const { manifest: actual } = await generateManifest(
          entrypoints,
          buildOutput,
-          config,
        );

        expect(actual.icons).toEqual({
@@ -319,12 +329,10 @@ describe('Manifest Utils', () => {
            { type: 'asset', fileName: 'icon-16.jpeg' },
          ],
        });
-        const config = fakeInternalConfig();

        const { manifest: actual } = await generateManifest(
          entrypoints,
          buildOutput,
-          config,
        );

        expect(actual.icons).toBeUndefined();
@@ -346,16 +354,17 @@ describe('Manifest Utils', () => {
          32: 'logo-32.png',
          48: 'logo-48.png',
        };
-        const config = fakeInternalConfig({
-          manifest: {
-            icons: expected,
+        setFakeWxt({
+          config: {
+            manifest: {
+              icons: expected,
+            },
          },
        });

        const { manifest: actual } = await generateManifest(
          entrypoints,
          buildOutput,
-          config,
        );

        expect(actual.icons).toEqual(expected);
@@ -440,10 +449,12 @@ describe('Manifest Utils', () => {
        };

        const entrypoints = [cs1, cs2, cs3, cs4, cs5];
-        const config = fakeInternalConfig({
-          command: 'build',
-          outDir,
-          manifestVersion: 3,
+        setFakeWxt({
+          config: {
+            command: 'build',
+            outDir,
+            manifestVersion: 3,
+          },
        });
        const buildOutput: Omit<BuildOutput, 'manifest'> = {
          publicAssets: [],
@@ -459,7 +470,6 @@ describe('Manifest Utils', () => {
        const { manifest: actual } = await generateManifest(
          entrypoints,
          buildOutput,
-          config,
        );

        expect(actual.content_scripts).toContainEqual({
@@ -509,18 +519,19 @@ describe('Manifest Utils', () => {

        const entrypoints = [cs];
        const buildOutput = fakeBuildOutput();
-        const config = fakeInternalConfig({
-          outDir,
-          command: 'build',
-          manifest: {
-            content_scripts: [userContentScript],
+        setFakeWxt({
+          config: {
+            outDir,
+            command: 'build',
+            manifest: {
+              content_scripts: [userContentScript],
+            },
          },
        });

        const { manifest: actual } = await generateManifest(
          entrypoints,
          buildOutput,
-          config,
        );

        expect(actual.content_scripts).toContainEqual(userContentScript);
@@ -552,15 +563,16 @@ describe('Manifest Utils', () => {
              publicAssets: [],
              steps: [{ entrypoints: cs, chunks: [styles] }],
            };
-            const config = fakeInternalConfig({
-              outDir,
-              command: 'build',
+            setFakeWxt({
+              config: {
+                outDir,
+                command: 'build',
+              },
            });

            const { manifest: actual } = await generateManifest(
              entrypoints,
              buildOutput,
-              config,
            );

            expect(actual.content_scripts).toEqual([
@@ -597,15 +609,16 @@ describe('Manifest Utils', () => {
              publicAssets: [],
              steps: [{ entrypoints: cs, chunks: [styles] }],
            };
-            const config = fakeInternalConfig({
-              outDir,
-              command: 'build',
+            setFakeWxt({
+              config: {
+                outDir,
+                command: 'build',
+              },
            });

            const { manifest: actual } = await generateManifest(
              entrypoints,
              buildOutput,
-              config,
            );

            expect(actual.content_scripts).toEqual([
@@ -639,16 +652,17 @@ describe('Manifest Utils', () => {
            publicAssets: [],
            steps: [{ entrypoints: cs, chunks: [styles] }],
          };
-          const config = fakeInternalConfig({
-            outDir,
-            command: 'build',
-            manifestVersion: 3,
+          setFakeWxt({
+            config: {
+              outDir,
+              command: 'build',
+              manifestVersion: 3,
+            },
          });

          const { manifest: actual } = await generateManifest(
            entrypoints,
            buildOutput,
-            config,
          );

          expect(actual.web_accessible_resources).toEqual([
@@ -681,16 +695,17 @@ describe('Manifest Utils', () => {
            publicAssets: [],
            steps: [{ entrypoints: cs, chunks: [styles] }],
          };
-          const config = fakeInternalConfig({
-            outDir,
-            command: 'build',
-            manifestVersion: 2,
+          setFakeWxt({
+            config: {
+              outDir,
+              command: 'build',
+              manifestVersion: 2,
+            },
          });

          const { manifest: actual } = await generateManifest(
            entrypoints,
            buildOutput,
-            config,
          );

          expect(actual.web_accessible_resources).toEqual([
@@ -720,16 +735,17 @@ describe('Manifest Utils', () => {
            publicAssets: [],
            steps: [{ entrypoints: cs, chunks: [styles] }],
          };
-          const config = fakeInternalConfig({
-            outDir,
-            command: 'build',
-            manifestVersion: 3,
+          setFakeWxt({
+            config: {
+              outDir,
+              command: 'build',
+              manifestVersion: 3,
+            },
          });

          const { manifest: actual } = await generateManifest(
            entrypoints,
            buildOutput,
-            config,
          );

          expect(actual.web_accessible_resources).toEqual([
@@ -765,21 +781,22 @@ describe('Manifest Utils', () => {
          publicAssets: [],
          steps: [{ entrypoints: cs, chunks: [styles] }],
        };
-        const config = fakeInternalConfig({
-          outDir,
-          command: 'build',
-          manifestVersion: 3,
-          manifest: {
-            web_accessible_resources: [
-              { resources: ['one.png'], matches: ['*://one.com/*'] },
-            ],
+        setFakeWxt({
+          config: {
+            outDir,
+            command: 'build',
+            manifestVersion: 3,
+            manifest: {
+              web_accessible_resources: [
+                { resources: ['one.png'], matches: ['*://one.com/*'] },
+              ],
+            },
          },
        });

        const { manifest: actual } = await generateManifest(
          entrypoints,
          buildOutput,
-          config,
        );

        expect(actual.web_accessible_resources).toEqual([
@@ -813,19 +830,20 @@ describe('Manifest Utils', () => {
          publicAssets: [],
          steps: [{ entrypoints: cs, chunks: [styles] }],
        };
-        const config = fakeInternalConfig({
-          outDir,
-          command: 'build',
-          manifestVersion: 2,
-          manifest: {
-            web_accessible_resources: ['one.png'],
+        setFakeWxt({
+          config: {
+            outDir,
+            command: 'build',
+            manifestVersion: 2,
+            manifest: {
+              web_accessible_resources: ['one.png'],
+            },
          },
        });

        const { manifest: actual } = await generateManifest(
          entrypoints,
          buildOutput,
-          config,
        );

        expect(actual.web_accessible_resources).toEqual([
@@ -840,9 +858,11 @@ describe('Manifest Utils', () => {
        const entrypoints: Entrypoint[] = [];
        const buildOutput = fakeBuildOutput();
        const newAuthor = 'Custom Author';
-        const config = fakeInternalConfig({
-          transformManifest(manifest: any) {
-            manifest.author = newAuthor;
+        setFakeWxt({
+          config: {
+            transformManifest(manifest: any) {
+              manifest.author = newAuthor;
+            },
          },
        });
        const expected = {
@@ -852,7 +872,6 @@ describe('Manifest Utils', () => {
        const { manifest: actual } = await generateManifest(
          entrypoints,
          buildOutput,
-          config,
        );

        expect(actual).toMatchObject(expected);
@@ -867,18 +886,19 @@ describe('Manifest Utils', () => {
          const versionName = '1.0.0-alpha1';
          const entrypoints: Entrypoint[] = [];
          const buildOutput = fakeBuildOutput();
-          const config = fakeInternalConfig({
-            browser,
-            manifest: {
-              version,
-              version_name: versionName,
+          setFakeWxt({
+            config: {
+              browser,
+              manifest: {
+                version,
+                version_name: versionName,
+              },
            },
          });

          const { manifest: actual } = await generateManifest(
            entrypoints,
            buildOutput,
-            config,
          );

          expect(actual.version).toBe(version);
@@ -893,18 +913,19 @@ describe('Manifest Utils', () => {
          const versionName = '1.0.0-alpha1';
          const entrypoints: Entrypoint[] = [];
          const buildOutput = fakeBuildOutput();
-          const config = fakeInternalConfig({
-            browser,
-            manifest: {
-              version,
-              version_name: versionName,
+          setFakeWxt({
+            config: {
+              browser,
+              manifest: {
+                version,
+                version_name: versionName,
+              },
            },
          });

          const { manifest: actual } = await generateManifest(
            entrypoints,
            buildOutput,
-            config,
          );

          expect(actual.version).toBe(version);
@@ -918,18 +939,19 @@ describe('Manifest Utils', () => {
          const version = '1.0.0';
          const entrypoints: Entrypoint[] = [];
          const buildOutput = fakeBuildOutput();
-          const config = fakeInternalConfig({
-            browser,
-            manifest: {
-              version,
-              version_name: version,
+          setFakeWxt({
+            config: {
+              browser,
+              manifest: {
+                version,
+                version_name: version,
+              },
            },
          });

          const { manifest: actual } = await generateManifest(
            entrypoints,
            buildOutput,
-            config,
          );

          expect(actual.version).toBe(version);
@@ -940,23 +962,24 @@ describe('Manifest Utils', () => {
      it('should log a warning if the version could not be detected', async () => {
        const entrypoints: Entrypoint[] = [];
        const buildOutput = fakeBuildOutput();
-        const config = fakeInternalConfig({
-          manifest: {
-            // @ts-ignore: Purposefully removing version from fake object
-            version: null,
+        setFakeWxt({
+          config: {
+            manifest: {
+              // @ts-ignore: Purposefully removing version from fake object
+              version: null,
+            },
          },
        });

        const { manifest: actual } = await generateManifest(
          entrypoints,
          buildOutput,
-          config,
        );

        expect(actual.version).toBe('0.0.0');
        expect(actual.version_name).toBeUndefined();
-        expect(config.logger.warn).toBeCalledTimes(1);
-        expect(config.logger.warn).toBeCalledWith(
+        expect(wxt.logger.warn).toBeCalledTimes(1);
+        expect(wxt.logger.warn).toBeCalledWith(
          expect.stringContaining('Extension version not found'),
        );
      });
@@ -972,14 +995,15 @@ describe('Manifest Utils', () => {
      };

      it('should include a command for reloading the extension during development', async () => {
-        const config = fakeInternalConfig({ command: 'serve' });
+        setFakeWxt({
+          config: { command: 'serve' },
+        });
        const output = fakeBuildOutput();
        const entrypoints = fakeArray(fakeEntrypoint);

        const { manifest: actual } = await generateManifest(
          entrypoints,
          output,
-          config,
        );

        expect(actual.commands).toEqual({
@@ -988,10 +1012,12 @@ describe('Manifest Utils', () => {
      });

      it('should customize the reload commands key binding if passing a custom command', async () => {
-        const config = fakeInternalConfig({
-          command: 'serve',
-          dev: {
-            reloadCommand: 'Ctrl+E',
+        setFakeWxt({
+          config: {
+            command: 'serve',
+            dev: {
+              reloadCommand: 'Ctrl+E',
+            },
          },
        });
        const output = fakeBuildOutput();
@@ -1000,7 +1026,6 @@ describe('Manifest Utils', () => {
        const { manifest: actual } = await generateManifest(
          entrypoints,
          output,
-          config,
        );

        expect(actual.commands).toEqual({
@@ -1014,10 +1039,12 @@ describe('Manifest Utils', () => {
      });

      it("should not include the reload command when it's been disabled", async () => {
-        const config = fakeInternalConfig({
-          command: 'serve',
-          dev: {
-            reloadCommand: false,
+        setFakeWxt({
+          config: {
+            command: 'serve',
+            dev: {
+              reloadCommand: false,
+            },
          },
        });
        const output = fakeBuildOutput();
@@ -1026,7 +1053,6 @@ describe('Manifest Utils', () => {
        const { manifest: actual } = await generateManifest(
          entrypoints,
          output,
-          config,
        );

        expect(actual.commands).toBeUndefined();
@@ -1035,11 +1061,13 @@ describe('Manifest Utils', () => {
      it('should not override any existing commands when adding the one to reload the extension', async () => {
        const customCommandName = 'custom-command';
        const customCommand = fakeManifestCommand();
-        const config = fakeInternalConfig({
-          command: 'serve',
-          manifest: {
-            commands: {
-              [customCommandName]: customCommand,
+        setFakeWxt({
+          config: {
+            command: 'serve',
+            manifest: {
+              commands: {
+                [customCommandName]: customCommand,
+              },
            },
          },
        });
@@ -1049,7 +1077,6 @@ describe('Manifest Utils', () => {
        const { manifest: actual } = await generateManifest(
          entrypoints,
          output,
-          config,
        );

        expect(actual.commands).toEqual({
@@ -1065,9 +1092,11 @@ describe('Manifest Utils', () => {
          command3: fakeManifestCommand(),
          command4: fakeManifestCommand(),
        };
-        const config = fakeInternalConfig({
-          command: 'serve',
-          manifest: { commands },
+        setFakeWxt({
+          config: {
+            command: 'serve',
+            manifest: { commands },
+          },
        });
        const output = fakeBuildOutput();
        const entrypoints = fakeArray(fakeEntrypoint);
@@ -1075,7 +1104,6 @@ describe('Manifest Utils', () => {
        const { manifest: actual, warnings } = await generateManifest(
          entrypoints,
          output,
-          config,
        );

        expect(actual.commands).toEqual(commands);
@@ -1083,14 +1111,15 @@ describe('Manifest Utils', () => {
      });

      it('should not include the command when building an extension', async () => {
-        const config = fakeInternalConfig({ command: 'build' });
+        setFakeWxt({
+          config: { command: 'build' },
+        });
        const output = fakeBuildOutput();
        const entrypoints = fakeArray(fakeEntrypoint);

        const { manifest: actual } = await generateManifest(
          entrypoints,
          output,
-          config,
        );

        expect(actual.commands).toBeUndefined();
@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { getPackageJson } from '../package';
-import { fakeInternalConfig } from '../testing/fake-objects';
+import { setFakeWxt } from '../testing/fake-objects';
 import { mock } from 'vitest-mock-extended';
 import { Logger } from '~/types';

@@ -8,7 +8,11 @@ describe('Package JSON Utils', () => {
  describe('getPackageJson', () => {
    it('should return the package.json inside <root>/package.json', async () => {
      const root = process.cwd(); // WXT project directory
-      const actual = await getPackageJson(fakeInternalConfig({ root }));
+      setFakeWxt({
+        config: { root },
+      });
+
+      const actual = await getPackageJson();

      expect(actual).toMatchObject({
        name: 'wxt',
@@ -18,7 +22,12 @@ describe('Package JSON Utils', () => {
    it("should return an empty object when <root>/package.json doesn't exist", async () => {
      const root = '/some/path/that/does/not/exist';
      const logger = mock<Logger>();
-      const actual = await getPackageJson(fakeInternalConfig({ root, logger }));
+      setFakeWxt({
+        config: { root, logger },
+        logger,
+      });
+
+      const actual = await getPackageJson();

      expect(actual).toEqual({});
    });
@@ -1,4 +1,4 @@
-import { describe, expect, it } from 'vitest';
+import { beforeEach, describe, expect, it } from 'vitest';
 import { DevModeChange, detectDevChanges } from '~/core/utils/building';
 import {
  fakeBackgroundEntrypoint,
@@ -10,14 +10,19 @@ import {
  fakePopupEntrypoint,
  fakeOutputAsset,
  fakeOutputChunk,
-  fakeInternalConfig,
+  fakeWxt,
+  setFakeWxt,
 } from '~/core/utils/testing/fake-objects';
 import { BuildOutput, BuildStepOutput } from '~/types';
+import { setWxtForTesting } from '../../../wxt';

 describe('Detect Dev Changes', () => {
+  beforeEach(() => {
+    setWxtForTesting(fakeWxt());
+  });
+
  describe('No changes', () => {
    it("should return 'no-change' when the changed file isn't used by any of the entrypoints", () => {
-      const config = fakeInternalConfig();
      const changes = ['/some/path.ts'];
      const currentOutput: BuildOutput = {
        manifest: fakeManifest(),
@@ -34,7 +39,7 @@ describe('Detect Dev Changes', () => {
        ],
      };

-      const actual = detectDevChanges(config, changes, currentOutput);
+      const actual = detectDevChanges(changes, currentOutput);

      expect(actual).toEqual({ type: 'no-change' });
    });
@@ -43,9 +48,11 @@ describe('Detect Dev Changes', () => {
  describe('wxt.config.ts', () => {
    it("should return 'full-restart' when one of the changed files is the config file", () => {
      const configFile = '/root/wxt.config.ts';
-      const config = fakeInternalConfig({
-        userConfigMetadata: {
-          configFile,
+      setFakeWxt({
+        config: {
+          userConfigMetadata: {
+            configFile,
+          },
        },
      });
      const changes = ['/root/src/public/image.svg', configFile];
@@ -58,7 +65,7 @@ describe('Detect Dev Changes', () => {
        type: 'full-restart',
      };

-      const actual = detectDevChanges(config, changes, currentOutput);
+      const actual = detectDevChanges(changes, currentOutput);

      expect(actual).toEqual(expected);
    });
@@ -67,9 +74,11 @@ describe('Detect Dev Changes', () => {
  describe('web-ext.config.ts', () => {
    it("should return 'browser-restart' when one of the changed files is the config file", () => {
      const runnerFile = '/root/web-ext.config.ts';
-      const config = fakeInternalConfig({
-        runnerConfig: {
-          configFile: runnerFile,
+      setFakeWxt({
+        config: {
+          runnerConfig: {
+            configFile: runnerFile,
+          },
        },
      });
      const changes = ['/root/src/public/image.svg', runnerFile];
@@ -82,7 +91,7 @@ describe('Detect Dev Changes', () => {
        type: 'browser-restart',
      };

-      const actual = detectDevChanges(config, changes, currentOutput);
+      const actual = detectDevChanges(changes, currentOutput);

      expect(actual).toEqual(expected);
    });
@@ -90,7 +99,6 @@ describe('Detect Dev Changes', () => {

  describe('Public Assets', () => {
    it("should return 'extension-reload' without any groups to rebuild when the changed file is a public asset", () => {
-      const config = fakeInternalConfig();
      const changes = ['/root/src/public/image.svg'];
      const asset1 = fakeOutputAsset({
        fileName: 'image.svg',
@@ -112,7 +120,7 @@ describe('Detect Dev Changes', () => {
        },
      };

-      const actual = detectDevChanges(config, changes, currentOutput);
+      const actual = detectDevChanges(changes, currentOutput);

      expect(actual).toEqual(expected);
    });
@@ -120,7 +128,6 @@ describe('Detect Dev Changes', () => {

  describe('Background', () => {
    it("should rebuild the background and reload the extension when the changed file in it's chunks' `moduleIds` field", () => {
-      const config = fakeInternalConfig();
      const changedPath = '/root/utils/shared.ts';
      const contentScript = fakeContentScriptEntrypoint({
        inputPath: '/root/overlay.content.ts',
@@ -160,16 +167,15 @@ describe('Detect Dev Changes', () => {
        rebuildGroups: [background],
      };

-      const actual = detectDevChanges(config, [changedPath], currentOutput);
+      const actual = detectDevChanges([changedPath], currentOutput);

      expect(actual).toEqual(expected);
    });
  });

  describe('HTML Pages', () => {
-    it('should rebuild then reload only the effected pages', async () => {
-      const config = fakeInternalConfig();
-      const changedPath = '/root/page1/index.html';
+    it('should detect changes to entrypoints/<name>.html files', async () => {
+      const changedPath = '/root/page1.html';
      const htmlPage1 = fakePopupEntrypoint({
        inputPath: changedPath,
      });
@@ -184,16 +190,16 @@ 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',
          }),
        ],
      };
@@ -212,7 +218,56 @@ describe('Detect Dev Changes', () => {
        rebuildGroups: [[htmlPage1, htmlPage2]],
      };

-      const actual = detectDevChanges(config, [changedPath], currentOutput);
+      const actual = detectDevChanges([changedPath], currentOutput);
+
+      expect(actual).toEqual(expected);
+    });
+
+    it('should detect changes to entrypoints/<name>/index.html files', async () => {
+      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',
+          }),
+        ],
+      };
+
+      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([changedPath], currentOutput);

      expect(actual).toEqual(expected);
    });
@@ -220,7 +275,6 @@ describe('Detect Dev Changes', () => {

  describe('Content Scripts', () => {
    it('should rebuild then reload only the effected content scripts', async () => {
-      const config = fakeInternalConfig();
      const changedPath = '/root/utils/shared.ts';
      const script1 = fakeContentScriptEntrypoint({
        inputPath: '/root/overlay1.content/index.ts',
@@ -272,7 +326,7 @@ describe('Detect Dev Changes', () => {
        rebuildGroups: [script1, script3],
      };

-      const actual = detectDevChanges(config, [changedPath], currentOutput);
+      const actual = detectDevChanges([changedPath], currentOutput);

      expect(actual).toEqual(expected);
    });
@@ -1,4 +1,4 @@
-import { describe, it, expect, vi } from 'vitest';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
 import {
  BackgroundEntrypoint,
  ContentScriptEntrypoint,
@@ -11,7 +11,10 @@ import { findEntrypoints } from '../find-entrypoints';
 import fs from 'fs-extra';
 import { importEntrypointFile } from '../import-entrypoint';
 import glob from 'fast-glob';
-import { fakeInternalConfig } from '~/core/utils/testing/fake-objects';
+import {
+  fakeResolvedConfig,
+  setFakeWxt,
+} from '~/core/utils/testing/fake-objects';
 import { unnormalizePath } from '~/core/utils/paths';

 vi.mock('../import-entrypoint');
@@ -26,13 +29,18 @@ const readFileMock = vi.mocked(
 );

 describe('findEntrypoints', () => {
-  const config = fakeInternalConfig({
+  const config = fakeResolvedConfig({
+    manifestVersion: 3,
    root: '/',
    entrypointsDir: resolve('/src/entrypoints'),
    outDir: resolve('.output'),
    command: 'build',
  });

+  beforeEach(() => {
+    setFakeWxt({ config });
+  });
+
  it.each<[string, string, PopupEntrypoint]>([
    [
      'popup.html',
@@ -82,7 +90,7 @@ describe('findEntrypoints', () => {
      globMock.mockResolvedValueOnce([path]);
      readFileMock.mockResolvedValueOnce(content);

-      const entrypoints = await findEntrypoints(config);
+      const entrypoints = await findEntrypoints();

      expect(entrypoints).toHaveLength(1);
      expect(entrypoints[0]).toEqual(expected);
@@ -135,7 +143,7 @@ describe('findEntrypoints', () => {
      globMock.mockResolvedValueOnce([path]);
      readFileMock.mockResolvedValueOnce(content);

-      const entrypoints = await findEntrypoints(config);
+      const entrypoints = await findEntrypoints();

      expect(entrypoints).toHaveLength(1);
      expect(entrypoints[0]).toEqual(expected);
@@ -202,14 +210,11 @@ describe('findEntrypoints', () => {
      globMock.mockResolvedValueOnce([path]);
      importEntrypointFileMock.mockResolvedValue(options);

-      const entrypoints = await findEntrypoints(config);
+      const entrypoints = await findEntrypoints();

      expect(entrypoints).toHaveLength(1);
      expect(entrypoints[0]).toEqual({ ...expected, options });
-      expect(importEntrypointFileMock).toBeCalledWith(
-        expected.inputPath,
-        config,
-      );
+      expect(importEntrypointFileMock).toBeCalledWith(expected.inputPath);
    },
  );

@@ -243,24 +248,58 @@ describe('findEntrypoints', () => {
      globMock.mockResolvedValueOnce([path]);
      importEntrypointFileMock.mockResolvedValue(options);

-      const entrypoints = await findEntrypoints(config);
+      const entrypoints = await findEntrypoints();

      expect(entrypoints).toHaveLength(1);
      expect(entrypoints[0]).toEqual({ ...expected, options });
-      expect(importEntrypointFileMock).toBeCalledWith(
-        expected.inputPath,
-        config,
-      );
+      expect(importEntrypointFileMock).toBeCalledWith(expected.inputPath);
    },
  );

+  it('should remove type=module from MV2 background scripts', async () => {
+    setFakeWxt({
+      config: {
+        manifestVersion: 2,
+      },
+    });
+    const options: BackgroundEntrypoint['options'] = {
+      type: 'module',
+    };
+    globMock.mockResolvedValueOnce(['background.ts']);
+    importEntrypointFileMock.mockResolvedValue(options);
+
+    const entrypoints = await findEntrypoints();
+
+    expect(entrypoints[0].options).toEqual({});
+  });
+
+  it('should allow type=module for MV3 background service workers', async () => {
+    setFakeWxt({
+      config: {
+        manifestVersion: 3,
+      },
+    });
+    const options: BackgroundEntrypoint['options'] = {
+      type: 'module',
+    };
+    globMock.mockResolvedValueOnce(['background.ts']);
+    importEntrypointFileMock.mockResolvedValue(options);
+
+    const entrypoints = await findEntrypoints();
+
+    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 () => {
+    setFakeWxt({
+      config: {
+        ...config,
+        command: 'serve',
+      },
+    });
    globMock.mockResolvedValueOnce(['popup.html']);

-    const entrypoints = await findEntrypoints({
-      ...config,
-      command: 'serve',
-    });
+    const entrypoints = await findEntrypoints();

    expect(entrypoints).toHaveLength(2);
    expect(entrypoints).toContainEqual({
@@ -296,14 +335,11 @@ describe('findEntrypoints', () => {
      globMock.mockResolvedValueOnce([path]);
      importEntrypointFileMock.mockResolvedValue(options);

-      const entrypoints = await findEntrypoints(config);
+      const entrypoints = await findEntrypoints();

      expect(entrypoints).toHaveLength(1);
      expect(entrypoints[0]).toEqual({ ...expected, options });
-      expect(importEntrypointFileMock).toBeCalledWith(
-        expected.inputPath,
-        config,
-      );
+      expect(importEntrypointFileMock).toBeCalledWith(expected.inputPath);
    },
  );

@@ -592,7 +628,7 @@ describe('findEntrypoints', () => {
  ])('should find entrypoint for %s', async (path, expected) => {
    globMock.mockResolvedValueOnce([path]);

-    const entrypoints = await findEntrypoints(config);
+    const entrypoints = await findEntrypoints();

    expect(entrypoints).toHaveLength(1);
    expect(entrypoints[0]).toEqual(expected);
@@ -608,7 +644,7 @@ describe('findEntrypoints', () => {
      'ui.html',
    ]);

-    await expect(() => findEntrypoints(config)).rejects.toThrowError(
+    await expect(() => findEntrypoints()).rejects.toThrowError(
      [
        'Multiple entrypoints with the same name detected, only one entrypoint for each name is allowed.',
        '',
@@ -626,7 +662,7 @@ describe('findEntrypoints', () => {
  it('throw an error if there are no entrypoints', async () => {
    globMock.mockResolvedValueOnce([]);

-    await expect(() => findEntrypoints(config)).rejects.toThrowError(
+    await expect(() => findEntrypoints()).rejects.toThrowError(
      `No entrypoints found in ${unnormalizePath(config.entrypointsDir)}`,
    );
  });
@@ -638,7 +674,7 @@ describe('findEntrypoints', () => {
        include: ['not' + config.browser],
      });

-      const entrypoints = await findEntrypoints(config);
+      const entrypoints = await findEntrypoints();

      expect(entrypoints).toEqual([]);
    });
@@ -649,7 +685,7 @@ describe('findEntrypoints', () => {
        include: ['not' + config.browser],
      });

-      const entrypoints = await findEntrypoints(config);
+      const entrypoints = await findEntrypoints();

      expect(entrypoints).toEqual([]);
    });
@@ -666,7 +702,7 @@ describe('findEntrypoints', () => {
        </html>`,
      );

-      const entrypoints = await findEntrypoints(config);
+      const entrypoints = await findEntrypoints();

      expect(entrypoints).toEqual([]);
    });
@@ -683,7 +719,7 @@ describe('findEntrypoints', () => {
        </html>`,
      );

-      const entrypoints = await findEntrypoints(config);
+      const entrypoints = await findEntrypoints();

      expect(entrypoints).toEqual([]);
    });
@@ -700,7 +736,7 @@ describe('findEntrypoints', () => {
        </html>`,
      );

-      const entrypoints = await findEntrypoints(config);
+      const entrypoints = await findEntrypoints();

      expect(entrypoints).toEqual([]);
    });
@@ -713,7 +749,7 @@ describe('findEntrypoints', () => {
        exclude: [config.browser],
      });

-      const entrypoints = await findEntrypoints(config);
+      const entrypoints = await findEntrypoints();

      expect(entrypoints).toEqual([]);
    });
@@ -724,7 +760,7 @@ describe('findEntrypoints', () => {
        exclude: [config.browser],
      });

-      const entrypoints = await findEntrypoints(config);
+      const entrypoints = await findEntrypoints();

      expect(entrypoints).toEqual([]);
    });
@@ -739,7 +775,7 @@ describe('findEntrypoints', () => {
        </html>`,
      );

-      const entrypoints = await findEntrypoints(config);
+      const entrypoints = await findEntrypoints();

      expect(entrypoints).toEqual([]);
    });
@@ -754,7 +790,7 @@ describe('findEntrypoints', () => {
        </html>`,
      );

-      const entrypoints = await findEntrypoints(config);
+      const entrypoints = await findEntrypoints();

      expect(entrypoints).toEqual([]);
    });
@@ -769,7 +805,7 @@ describe('findEntrypoints', () => {
        </html>`,
      );

-      const entrypoints = await findEntrypoints(config);
+      const entrypoints = await findEntrypoints();

      expect(entrypoints).toEqual([]);
    });
@@ -785,15 +821,17 @@ describe('findEntrypoints', () => {
      ]);
      importEntrypointFileMock.mockResolvedValue({});
      const filterEntrypoints = ['popup', 'ui'];
-      const config = fakeInternalConfig({
-        root: '/',
-        entrypointsDir: resolve('/src/entrypoints'),
-        outDir: resolve('.output'),
-        command: 'build',
-        filterEntrypoints: new Set(filterEntrypoints),
+      setFakeWxt({
+        config: {
+          root: '/',
+          entrypointsDir: resolve('/src/entrypoints'),
+          outDir: resolve('.output'),
+          command: 'build',
+          filterEntrypoints: new Set(filterEntrypoints),
+        },
      });

-      const entrypoints = await findEntrypoints(config);
+      const entrypoints = await findEntrypoints();
      const names = entrypoints.map((item) => item.name);
      expect(names).toHaveLength(2);
      expect(names).toEqual(filterEntrypoints);
@@ -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
+    },
+  );
 });
@@ -1,21 +1,25 @@
-import { describe, expect, it } from 'vitest';
+import { beforeEach, describe, expect, it } from 'vitest';
 import { importEntrypointFile } from '~/core/utils/building';
-import { fakeInternalConfig } from '~/core/utils/testing/fake-objects';
 import { resolve } from 'node:path';
 import { unnormalizePath } from '../../paths';
+import { setFakeWxt } from '../../testing/fake-objects';

 const entrypointPath = (filename: string) =>
  resolve('src/core/utils/__tests__/test-entrypoints', filename);

-const config = fakeInternalConfig({
-  imports: false,
-  debug: false,
-  // Run inside the demo folder so that wxt is in the node_modules
-  // WXT must also be built for these tests to pass
-  root: 'demo',
-});
-
 describe('importEntrypointFile', () => {
+  beforeEach(() => {
+    setFakeWxt({
+      config: {
+        imports: false,
+        debug: false,
+        // Run inside the demo folder so that wxt is in the node_modules
+        // WXT must also be built for these tests to pass
+        root: 'demo',
+      },
+    });
+  });
+
  it.each([
    ['background.ts', { main: expect.any(Function) }],
    ['content.ts', { main: expect.any(Function), matches: ['<all_urls>'] }],
@@ -25,7 +29,7 @@ describe('importEntrypointFile', () => {
  ])(
    'should return the default export of test-entrypoints/%s',
    async (file, expected) => {
-      const actual = await importEntrypointFile(entrypointPath(file), config);
+      const actual = await importEntrypointFile(entrypointPath(file));

      expect(actual).toEqual(expected);
    },
@@ -34,7 +38,6 @@ describe('importEntrypointFile', () => {
  it('should return undefined when there is no default export', async () => {
    const actual = await importEntrypointFile(
      entrypointPath('no-default-export.ts'),
-      config,
    );

    expect(actual).toBeUndefined();
@@ -45,7 +48,7 @@ describe('importEntrypointFile', () => {
      '../src/core/utils/__tests__/test-entrypoints/imported-option.ts',
    );
    await expect(() =>
-      importEntrypointFile(entrypointPath('imported-option.ts'), config),
+      importEntrypointFile(entrypointPath('imported-option.ts')),
    ).rejects.toThrowErrorMatchingInlineSnapshot(
      `[Error: ${filePath}: Cannot use imported variable "faker" outside the main function. See https://wxt.dev/guide/entrypoints.html#side-effects]`,
    );
@@ -1,18 +1,13 @@
-import {
-  BuildOutput,
-  BuildStepOutput,
-  EntrypointGroup,
-  InternalConfig,
-} from '~/types';
+import { BuildOutput, BuildStepOutput, EntrypointGroup } from '~/types';
 import { getPublicFiles } from '~/core/utils/fs';
 import fs from 'fs-extra';
 import { dirname, resolve } from 'path';
 import type { Ora } from 'ora';
 import pc from 'picocolors';
+import { wxt } from '../../wxt';

 export async function buildEntrypoints(
  groups: EntrypointGroup[],
-  config: InternalConfig,
  spinner: Ora,
 ): Promise<Omit<BuildOutput, 'manifest'>> {
  const steps: BuildStepOutput[] = [];
@@ -23,26 +18,24 @@ export async function buildEntrypoints(
    spinner.text =
      pc.dim(`[${i + 1}/${groups.length}]`) + ` ${groupNameColored}`;
    try {
-      steps.push(await config.builder.build(group));
+      steps.push(await wxt.config.builder.build(group));
    } catch (err) {
      throw Error(`Failed to build ${groupNames.join(', ')}`, { cause: err });
    }
  }
-  const publicAssets = await copyPublicDirectory(config);
+  const publicAssets = await copyPublicDirectory();

  return { publicAssets, steps };
 }

-async function copyPublicDirectory(
-  config: InternalConfig,
-): Promise<BuildOutput['publicAssets']> {
-  const files = await getPublicFiles(config);
+async function copyPublicDirectory(): Promise<BuildOutput['publicAssets']> {
+  const files = await getPublicFiles();
  if (files.length === 0) return [];

  const publicAssets: BuildOutput['publicAssets'] = [];
  for (const file of files) {
-    const srcPath = resolve(config.publicDir, file);
-    const outPath = resolve(config.outDir, file);
+    const srcPath = resolve(wxt.config.publicDir, file);
+    const outPath = resolve(wxt.config.outDir, file);

    await fs.ensureDir(dirname(outPath));
    await fs.copyFile(srcPath, outPath);
@@ -2,12 +2,12 @@ import {
  BuildOutput,
  BuildStepOutput,
  EntrypointGroup,
-  InternalConfig,
  OutputAsset,
  OutputFile,
 } from '~/types';
 import { every, some } from '~/core/utils/arrays';
 import { normalizePath } from '~/core/utils/paths';
+import { wxt } from '../../wxt';

 /**
 * Compare the changed files vs the build output and determine what kind of reload needs to happen:
@@ -30,19 +30,18 @@ import { normalizePath } from '~/core/utils/paths';
 *   - Config file changed (wxt.config.ts, .env, web-ext.config.ts, etc)
 */
 export function detectDevChanges(
-  config: InternalConfig,
  changedFiles: string[],
  currentOutput: BuildOutput,
 ): DevModeChange {
  const isConfigChange = some(
    changedFiles,
-    (file) => file === config.userConfigMetadata.configFile,
+    (file) => file === wxt.config.userConfigMetadata.configFile,
  );
  if (isConfigChange) return { type: 'full-restart' };

  const isRunnerChange = some(
    changedFiles,
-    (file) => file === config.runnerConfig.configFile,
+    (file) => file === wxt.config.runnerConfig.configFile,
  );
  if (isRunnerChange) return { type: 'browser-restart' };

@@ -123,11 +122,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) {
@@ -7,7 +7,6 @@ import {
  ContentScriptEntrypoint,
  Entrypoint,
  GenericEntrypoint,
-  InternalConfig,
  OptionsEntrypoint,
  PopupEntrypoint,
  UnlistedScriptDefinition,
@@ -25,15 +24,14 @@ import {
 import { VIRTUAL_NOOP_BACKGROUND_MODULE_ID } from '~/core/utils/constants';
 import { CSS_EXTENSIONS_PATTERN } from '~/core/utils/paths';
 import pc from 'picocolors';
+import { wxt } from '../../wxt';

 /**
 * Return entrypoints and their configuration by looking through the project's files.
 */
-export async function findEntrypoints(
-  config: InternalConfig,
-): Promise<Entrypoint[]> {
+export async function findEntrypoints(): Promise<Entrypoint[]> {
  const relativePaths = await glob(Object.keys(PATH_GLOB_TO_TYPE_MAP), {
-    cwd: config.entrypointsDir,
+    cwd: wxt.config.entrypointsDir,
  });
  // Ensure consistent output
  relativePaths.sort();
@@ -42,8 +40,8 @@ export async function findEntrypoints(
  const entrypointInfos: EntrypointInfo[] = relativePaths.reduce<
    EntrypointInfo[]
  >((results, relativePath) => {
-    const inputPath = resolve(config.entrypointsDir, relativePath);
-    const name = getEntrypointName(config.entrypointsDir, inputPath);
+    const inputPath = resolve(wxt.config.entrypointsDir, relativePath);
+    const name = getEntrypointName(wxt.config.entrypointsDir, inputPath);
    const matchingGlob = pathGlobs.find((glob) =>
      minimatch(relativePath, glob),
    );
@@ -54,16 +52,16 @@ export async function findEntrypoints(
        inputPath,
        type,
        skipped:
-          config.filterEntrypoints != null &&
-          !config.filterEntrypoints.has(name),
+          wxt.config.filterEntrypoints != null &&
+          !wxt.config.filterEntrypoints.has(name),
      });
    }
    return results;
  }, []);

  // Validation
-  preventNoEntrypoints(config, entrypointInfos);
-  preventDuplicateEntrypointNames(config, entrypointInfos);
+  preventNoEntrypoints(entrypointInfos);
+  preventDuplicateEntrypointNames(entrypointInfos);

  // Import entrypoints to get their config
  let hasBackground = false;
@@ -72,23 +70,23 @@ export async function findEntrypoints(
      const { type } = info;
      switch (type) {
        case 'popup':
-          return await getPopupEntrypoint(config, info);
+          return await getPopupEntrypoint(info);
        case 'options':
-          return await getOptionsEntrypoint(config, info);
+          return await getOptionsEntrypoint(info);
        case 'background':
          hasBackground = true;
-          return await getBackgroundEntrypoint(config, info);
+          return await getBackgroundEntrypoint(info);
        case 'content-script':
-          return await getContentScriptEntrypoint(config, info);
+          return await getContentScriptEntrypoint(info);
        case 'unlisted-page':
-          return await getUnlistedPageEntrypoint(config, info);
+          return await getUnlistedPageEntrypoint(info);
        case 'unlisted-script':
-          return await getUnlistedScriptEntrypoint(config, info);
+          return await getUnlistedScriptEntrypoint(info);
        case 'content-script-style':
          return {
            ...info,
            type,
-            outputDir: resolve(config.outDir, CONTENT_SCRIPT_OUT_DIR),
+            outputDir: resolve(wxt.config.outDir, CONTENT_SCRIPT_OUT_DIR),
            options: {
              include: undefined,
              exclude: undefined,
@@ -98,7 +96,7 @@ export async function findEntrypoints(
          return {
            ...info,
            type,
-            outputDir: config.outDir,
+            outputDir: wxt.config.outDir,
            options: {
              include: undefined,
              exclude: undefined,
@@ -108,9 +106,9 @@ export async function findEntrypoints(
    }),
  );

-  if (config.command === 'serve' && !hasBackground) {
+  if (wxt.config.command === 'serve' && !hasBackground) {
    entrypoints.push(
-      await getBackgroundEntrypoint(config, {
+      await getBackgroundEntrypoint({
        inputPath: VIRTUAL_NOOP_BACKGROUND_MODULE_ID,
        name: 'background',
        type: 'background',
@@ -119,12 +117,12 @@ export async function findEntrypoints(
    );
  }

-  config.logger.debug('All entrypoints:', entrypoints);
+  wxt.logger.debug('All entrypoints:', entrypoints);
  const skippedEntrypointNames = entrypointInfos
    .filter((item) => item.skipped)
    .map((item) => item.name);
  if (skippedEntrypointNames.length) {
-    config.logger.warn(
+    wxt.logger.warn(
      `Filter excluded the following entrypoints:\n${skippedEntrypointNames
        .map((item) => `${pc.dim('-')} ${pc.cyan(item)}`)
        .join('\n')}`,
@@ -133,16 +131,16 @@ export async function findEntrypoints(
  const targetEntrypoints = entrypoints.filter((entry) => {
    const { include, exclude } = entry.options;
    if (include?.length && exclude?.length) {
-      config.logger.warn(
+      wxt.logger.warn(
        `The ${entry.name} entrypoint lists both include and exclude, but only one can be used per entrypoint. Entrypoint ignored.`,
      );
      return false;
    }
    if (exclude?.length && !include?.length) {
-      return !exclude.includes(config.browser);
+      return !exclude.includes(wxt.config.browser);
    }
    if (include?.length && !exclude?.length) {
-      return include.includes(config.browser);
+      return include.includes(wxt.config.browser);
    }
    if (skippedEntrypointNames.includes(entry.name)) {
      return false;
@@ -150,7 +148,9 @@ export async function findEntrypoints(

    return true;
  });
-  config.logger.debug(`${config.browser} entrypoints:`, targetEntrypoints);
+  wxt.logger.debug(`${wxt.config.browser} entrypoints:`, targetEntrypoints);
+  await wxt.hooks.callHook('entrypoints:resolved', wxt, targetEntrypoints);
+
  return targetEntrypoints;
 }

@@ -164,10 +164,7 @@ interface EntrypointInfo {
  skipped: boolean;
 }

-function preventDuplicateEntrypointNames(
-  config: InternalConfig,
-  files: EntrypointInfo[],
-) {
+function preventDuplicateEntrypointNames(files: EntrypointInfo[]) {
  const namesToPaths = files.reduce<Record<string, string[]>>(
    (map, { name, inputPath }) => {
      map[name] ??= [];
@@ -181,7 +178,7 @@ function preventDuplicateEntrypointNames(
      if (absolutePaths.length > 1) {
        lines.push(`- ${name}`);
        absolutePaths.forEach((absolutePath) => {
-          lines.push(`  - ${relative(config.root, absolutePath)}`);
+          lines.push(`  - ${relative(wxt.config.root, absolutePath)}`);
        });
      }
      return lines;
@@ -196,9 +193,9 @@ function preventDuplicateEntrypointNames(
  }
 }

-function preventNoEntrypoints(config: InternalConfig, files: EntrypointInfo[]) {
+function preventNoEntrypoints(files: EntrypointInfo[]) {
  if (files.length === 0) {
-    throw Error(`No entrypoints found in ${config.entrypointsDir}`);
+    throw Error(`No entrypoints found in ${wxt.config.entrypointsDir}`);
  }
 }

@@ -226,10 +223,11 @@ function getHtmlBaseOptions(document: Document): BaseEntrypointOptions {
 * @param path Absolute path to the popup HTML file.
 * @param content String contents of the file at the path.
 */
-async function getPopupEntrypoint(
-  config: InternalConfig,
-  { inputPath, name, skipped }: EntrypointInfo,
-): Promise<PopupEntrypoint> {
+async function getPopupEntrypoint({
+  inputPath,
+  name,
+  skipped,
+}: EntrypointInfo): Promise<PopupEntrypoint> {
  const content = await fs.readFile(inputPath, 'utf-8');
  const { document } = parseHTML(content);

@@ -245,7 +243,7 @@ async function getPopupEntrypoint(
    try {
      options.defaultIcon = JSON5.parse(defaultIconContent);
    } catch (err) {
-      config.logger.fatal(
+      wxt.logger.fatal(
        `Failed to parse default_icon meta tag content as JSON5. content=${defaultIconContent}`,
        err,
      );
@@ -272,7 +270,7 @@ async function getPopupEntrypoint(
    name: 'popup',
    options,
    inputPath,
-    outputDir: config.outDir,
+    outputDir: wxt.config.outDir,
    skipped,
  };
 }
@@ -281,10 +279,11 @@ async function getPopupEntrypoint(
 * @param path Absolute path to the options HTML file.
 * @param content String contents of the file at the path.
 */
-async function getOptionsEntrypoint(
-  config: InternalConfig,
-  { inputPath, name, skipped }: EntrypointInfo,
-): Promise<OptionsEntrypoint> {
+async function getOptionsEntrypoint({
+  inputPath,
+  name,
+  skipped,
+}: EntrypointInfo): Promise<OptionsEntrypoint> {
  const content = await fs.readFile(inputPath, 'utf-8');
  const { document } = parseHTML(content);

@@ -316,7 +315,7 @@ async function getOptionsEntrypoint(
    name: 'options',
    options,
    inputPath,
-    outputDir: config.outDir,
+    outputDir: wxt.config.outDir,
    skipped,
  };
 }
@@ -325,18 +324,19 @@ async function getOptionsEntrypoint(
 * @param path Absolute path to the HTML file.
 * @param content String contents of the file at the path.
 */
-async function getUnlistedPageEntrypoint(
-  config: InternalConfig,
-  { inputPath, name, skipped }: EntrypointInfo,
-): Promise<GenericEntrypoint> {
+async function getUnlistedPageEntrypoint({
+  inputPath,
+  name,
+  skipped,
+}: EntrypointInfo): Promise<GenericEntrypoint> {
  const content = await fs.readFile(inputPath, 'utf-8');
  const { document } = parseHTML(content);

  return {
    type: 'unlisted-page',
-    name: getEntrypointName(config.entrypointsDir, inputPath),
+    name: getEntrypointName(wxt.config.entrypointsDir, inputPath),
    inputPath,
-    outputDir: config.outDir,
+    outputDir: wxt.config.outDir,
    options: getHtmlBaseOptions(document),
    skipped,
  };
@@ -346,14 +346,13 @@ async function getUnlistedPageEntrypoint(
 * @param path Absolute path to the script's file.
 * @param content String contents of the file at the path.
 */
-async function getUnlistedScriptEntrypoint(
-  config: InternalConfig,
-  { inputPath, name, skipped }: EntrypointInfo,
-): Promise<GenericEntrypoint> {
-  const defaultExport = await importEntrypointFile<UnlistedScriptDefinition>(
-    inputPath,
-    config,
-  );
+async function getUnlistedScriptEntrypoint({
+  inputPath,
+  name,
+  skipped,
+}: EntrypointInfo): Promise<GenericEntrypoint> {
+  const defaultExport =
+    await importEntrypointFile<UnlistedScriptDefinition>(inputPath);
  if (defaultExport == null) {
    throw Error(
      `${name}: Default export not found, did you forget to call "export default defineUnlistedScript(...)"?`,
@@ -365,7 +364,7 @@ async function getUnlistedScriptEntrypoint(
    type: 'unlisted-script',
    name,
    inputPath,
-    outputDir: config.outDir,
+    outputDir: wxt.config.outDir,
    options,
    skipped,
  };
@@ -374,16 +373,15 @@ async function getUnlistedScriptEntrypoint(
 /**
 * @param path Absolute path to the background's TS file.
 */
-async function getBackgroundEntrypoint(
-  config: InternalConfig,
-  { inputPath, name, skipped }: EntrypointInfo,
-): Promise<BackgroundEntrypoint> {
+async function getBackgroundEntrypoint({
+  inputPath,
+  name,
+  skipped,
+}: EntrypointInfo): Promise<BackgroundEntrypoint> {
  let options: Omit<BackgroundDefinition, 'main'> = {};
  if (inputPath !== VIRTUAL_NOOP_BACKGROUND_MODULE_ID) {
-    const defaultExport = await importEntrypointFile<BackgroundDefinition>(
-      inputPath,
-      config,
-    );
+    const defaultExport =
+      await importEntrypointFile<BackgroundDefinition>(inputPath);
    if (defaultExport == null) {
      throw Error(
        `${name}: Default export not found, did you forget to call "export default defineBackground(...)"?`,
@@ -392,15 +390,23 @@ async function getBackgroundEntrypoint(
    const { main: _, ...moduleOptions } = defaultExport;
    options = moduleOptions;
  }
+
+  if (wxt.config.manifestVersion !== 3) {
+    delete options.type;
+  }
+
  return {
    type: 'background',
    name,
    inputPath,
-    outputDir: config.outDir,
+    outputDir: wxt.config.outDir,
    options: {
      ...options,
-      type: resolvePerBrowserOption(options.type, config.browser),
-      persistent: resolvePerBrowserOption(options.persistent, config.browser),
+      type: resolvePerBrowserOption(options.type, wxt.config.browser),
+      persistent: resolvePerBrowserOption(
+        options.persistent,
+        wxt.config.browser,
+      ),
    },
    skipped,
  };
@@ -409,12 +415,13 @@ async function getBackgroundEntrypoint(
 /**
 * @param path Absolute path to the content script's TS file.
 */
-async function getContentScriptEntrypoint(
-  config: InternalConfig,
-  { inputPath, name, skipped }: EntrypointInfo,
-): Promise<ContentScriptEntrypoint> {
+async function getContentScriptEntrypoint({
+  inputPath,
+  name,
+  skipped,
+}: EntrypointInfo): Promise<ContentScriptEntrypoint> {
  const { main: _, ...options } =
-    await importEntrypointFile<ContentScriptDefinition>(inputPath, config);
+    await importEntrypointFile<ContentScriptDefinition>(inputPath);
  if (options == null) {
    throw Error(
      `${name}: Default export not found, did you forget to call "export default defineContentScript(...)"?`,
@@ -424,7 +431,7 @@ async function getContentScriptEntrypoint(
    type: 'content-script',
    name,
    inputPath,
-    outputDir: resolve(config.outDir, CONTENT_SCRIPT_OUT_DIR),
+    outputDir: resolve(wxt.config.outDir, CONTENT_SCRIPT_OUT_DIR),
    options,
    skipped,
  };
@@ -1,5 +1,5 @@
 import { UnimportOptions, createUnimport } from 'unimport';
-import { Entrypoint, InternalConfig } from '~/types';
+import { Entrypoint } from '~/types';
 import fs from 'fs-extra';
 import { relative, resolve } from 'path';
 import { getEntrypointBundlePath } from '~/core/utils/entrypoints';
@@ -9,40 +9,39 @@ import { normalizePath } from '~/core/utils/paths';
 import path from 'node:path';
 import { Message, parseI18nMessages } from '~/core/utils/i18n';
 import { writeFileIfDifferent, getPublicFiles } from '~/core/utils/fs';
+import { wxt } from '../../wxt';

 /**
 * Generate and write all the files inside the `InternalConfig.typesDir` directory.
 */
 export async function generateTypesDir(
  entrypoints: Entrypoint[],
-  config: InternalConfig,
 ): Promise<void> {
-  await fs.ensureDir(config.typesDir);
+  await fs.ensureDir(wxt.config.typesDir);

  const references: string[] = [];

-  const imports = getUnimportOptions(config);
+  const imports = getUnimportOptions(wxt.config);
  if (imports !== false) {
-    references.push(await writeImportsDeclarationFile(config, imports));
+    references.push(await writeImportsDeclarationFile(imports));
  }

-  references.push(await writePathsDeclarationFile(entrypoints, config));
-  references.push(await writeI18nDeclarationFile(config));
-  references.push(await writeGlobalsDeclarationFile(config));
+  references.push(await writePathsDeclarationFile(entrypoints));
+  references.push(await writeI18nDeclarationFile());
+  references.push(await writeGlobalsDeclarationFile());

-  const mainReference = await writeMainDeclarationFile(references, config);
-  await writeTsConfigFile(mainReference, config);
+  const mainReference = await writeMainDeclarationFile(references);
+  await writeTsConfigFile(mainReference);
 }

 async function writeImportsDeclarationFile(
-  config: InternalConfig,
  unimportOptions: Partial<UnimportOptions>,
 ): Promise<string> {
-  const filePath = resolve(config.typesDir, 'imports.d.ts');
+  const filePath = resolve(wxt.config.typesDir, 'imports.d.ts');
  const unimport = createUnimport(unimportOptions);

  // Load project imports into unimport memory so they are output via generateTypeDeclarations
-  await unimport.scanImportsFromDir(undefined, { cwd: config.srcDir });
+  await unimport.scanImportsFromDir(undefined, { cwd: wxt.config.srcDir });

  await writeFileIfDifferent(
    filePath,
@@ -56,18 +55,17 @@ async function writeImportsDeclarationFile(

 async function writePathsDeclarationFile(
  entrypoints: Entrypoint[],
-  config: InternalConfig,
 ): Promise<string> {
-  const filePath = resolve(config.typesDir, 'paths.d.ts');
+  const filePath = resolve(wxt.config.typesDir, 'paths.d.ts');
  const unions = entrypoints
    .map((entry) =>
      getEntrypointBundlePath(
        entry,
-        config.outDir,
+        wxt.config.outDir,
        entry.inputPath.endsWith('.html') ? '.html' : '.js',
      ),
    )
-    .concat(await getPublicFiles(config))
+    .concat(await getPublicFiles())
    .map(normalizePath)
    .map((path) => `    | "/${path}"`)
    .sort()
@@ -95,11 +93,9 @@ declare module "wxt/browser" {
  return filePath;
 }

-async function writeI18nDeclarationFile(
-  config: InternalConfig,
-): Promise<string> {
-  const filePath = resolve(config.typesDir, 'i18n.d.ts');
-  const defaultLocale = config.manifest.default_locale;
+async function writeI18nDeclarationFile(): Promise<string> {
+  const filePath = resolve(wxt.config.typesDir, 'i18n.d.ts');
+  const defaultLocale = wxt.config.manifest.default_locale;
  const template = `// Generated by wxt
 import "wxt/browser";

@@ -123,7 +119,7 @@ declare module "wxt/browser" {
  let messages: Message[];
  if (defaultLocale) {
    const defaultLocalePath = path.resolve(
-      config.publicDir,
+      wxt.config.publicDir,
      '_locales',
      defaultLocale,
      'messages.json',
@@ -154,11 +150,9 @@ declare module "wxt/browser" {
  return filePath;
 }

-async function writeGlobalsDeclarationFile(
-  config: InternalConfig,
-): Promise<string> {
-  const filePath = resolve(config.typesDir, 'globals.d.ts');
-  const globals = [...getGlobals(config), ...getEntrypointGlobals('')];
+async function writeGlobalsDeclarationFile(): Promise<string> {
+  const filePath = resolve(wxt.config.typesDir, 'globals.d.ts');
+  const globals = [...getGlobals(wxt.config), ...getEntrypointGlobals('')];
  await writeFileIfDifferent(
    filePath,
    [
@@ -175,11 +169,8 @@ async function writeGlobalsDeclarationFile(
  return filePath;
 }

-async function writeMainDeclarationFile(
-  references: string[],
-  config: InternalConfig,
-): Promise<string> {
-  const dir = config.wxtDir;
+async function writeMainDeclarationFile(references: string[]): Promise<string> {
+  const dir = wxt.config.wxtDir;
  const filePath = resolve(dir, 'wxt.d.ts');
  await writeFileIfDifferent(
    filePath,
@@ -195,13 +186,10 @@ async function writeMainDeclarationFile(
  return filePath;
 }

-async function writeTsConfigFile(
-  mainReference: string,
-  config: InternalConfig,
-) {
-  const dir = config.wxtDir;
+async function writeTsConfigFile(mainReference: string) {
+  const dir = wxt.config.wxtDir;
  const getTsconfigPath = (path: string) => normalizePath(relative(dir, path));
-  const paths = Object.entries(config.alias)
+  const paths = Object.entries(wxt.config.alias)
    .flatMap(([alias, absolutePath]) => {
      const aliasPath = getTsconfigPath(absolutePath);
      return [
@@ -229,10 +217,10 @@ ${paths}
    }
  },
  "include": [
-    "${getTsconfigPath(config.root)}/**/*",
+    "${getTsconfigPath(wxt.config.root)}/**/*",
    "./${getTsconfigPath(mainReference)}"
  ],
-  "exclude": ["${getTsconfigPath(config.outBaseDir)}"]
+  "exclude": ["${getTsconfigPath(wxt.config.outBaseDir)}"]
 }`,
  );
 }
@@ -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';
@@ -1,5 +1,4 @@
 import createJITI, { TransformOptions as JitiTransformOptions } from 'jiti';
-import { InternalConfig } from '~/types';
 import { createUnimport } from 'unimport';
 import fs from 'fs-extra';
 import { relative, resolve } from 'node:path';
@@ -8,6 +7,7 @@ import { removeProjectImportStatements } from '~/core/utils/strings';
 import { normalizePath } from '~/core/utils/paths';
 import { TransformOptions, transformSync } from 'esbuild';
 import { fileURLToPath } from 'node:url';
+import { wxt } from '../../wxt';

 /**
 * Get the value from the default export of a `path`.
@@ -24,16 +24,13 @@ import { fileURLToPath } from 'node:url';
 * Downside is that code cannot be executed outside of the main fucntion for the entrypoint,
 * otherwise you will see "xxx is not defined" errors for any imports used outside of main function.
 */
-export async function importEntrypointFile<T>(
-  path: string,
-  config: InternalConfig,
-): Promise<T> {
-  config.logger.debug('Loading file metadata:', path);
+export async function importEntrypointFile<T>(path: string): Promise<T> {
+  wxt.logger.debug('Loading file metadata:', path);
  // JITI & Babel uses normalized paths.
  const normalPath = normalizePath(path);

  const unimport = createUnimport({
-    ...getUnimportOptions(config),
+    ...getUnimportOptions(wxt.config),
    // Only allow specific imports, not all from the project
    dirs: [],
  });
@@ -42,7 +39,7 @@ export async function importEntrypointFile<T>(
  const text = await fs.readFile(path, 'utf-8');
  const textNoImports = removeProjectImportStatements(text);
  const { code } = await unimport.injectImports(textNoImports);
-  config.logger.debug(
+  wxt.logger.debug(
    ['Text:', text, 'No imports:', textNoImports, 'Code:', code].join('\n'),
  );

@@ -52,11 +49,11 @@ export async function importEntrypointFile<T>(
      : fileURLToPath(import.meta.url),
    {
      cache: false,
-      debug: config.debug,
+      debug: wxt.config.debug,
      esmResolve: true,
      alias: {
        'webextension-polyfill': resolve(
-          config.root,
+          wxt.config.root,
          'node_modules/wxt/dist/virtual/mock-browser.js',
        ),
      },
@@ -89,7 +86,7 @@ export async function importEntrypointFile<T>(
    const res = await jiti(path);
    return res.default;
  } catch (err) {
-    const filePath = relative(config.root, path);
+    const filePath = relative(wxt.config.root, path);
    if (err instanceof ReferenceError) {
      // "XXX is not defined" - usually due to WXT removing imports
      const variableName = err.message.replace(' is not defined', '');
@@ -98,7 +95,7 @@ export async function importEntrypointFile<T>(
        { cause: err },
      );
    } else {
-      config.logger.error(err);
+      wxt.logger.error(err);
      throw Error(`Failed to load entrypoint: ${filePath}`, { cause: err });
    }
  }
@@ -2,7 +2,7 @@ export * from './build-entrypoints';
 export * from './detect-dev-changes';
 export * from './find-entrypoints';
 export * from './generate-wxt-dir';
-export * from './get-internal-config';
+export * from './resolve-config';
 export * from './group-entrypoints';
 export * from './import-entrypoint';
 export * from './internal-build';
@@ -1,5 +1,5 @@
 import { findEntrypoints } from './find-entrypoints';
-import { InternalConfig, BuildOutput, Entrypoint } from '~/types';
+import { BuildOutput, Entrypoint } from '~/types';
 import pc from 'picocolors';
 import fs from 'fs-extra';
 import { groupEntrypoints } from './group-entrypoints';
@@ -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,8 @@ import {
  validateEntrypoints,
 } from '../validation';
 import consola from 'consola';
+import { exec } from '../exec';
+import { wxt } from '../../wxt';

 /**
 * Builds the extension based on an internal config. No more config discovery is performed, the
@@ -28,28 +29,28 @@ import consola from 'consola';
 *    `rebuild` for more details)
 * 3. Prints the summary
 */
-export async function internalBuild(
-  config: InternalConfig,
-): Promise<BuildOutput> {
-  const verb = config.command === 'serve' ? 'Pre-rendering' : 'Building';
-  const target = `${config.browser}-mv${config.manifestVersion}`;
-  config.logger.info(
-    `${verb} ${pc.cyan(target)} for ${pc.cyan(config.mode)} with ${pc.green(
-      `${config.builder.name} ${config.builder.version}`,
+export async function internalBuild(): Promise<BuildOutput> {
+  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.config.builder.name} ${wxt.config.builder.version}`,
    )}`,
  );
  const startTime = Date.now();

  // Cleanup
-  await fs.rm(config.outDir, { recursive: true, force: true });
-  await fs.ensureDir(config.outDir);
+  await fs.rm(wxt.config.outDir, { recursive: true, force: true });
+  await fs.ensureDir(wxt.config.outDir);

-  const entrypoints = await findEntrypoints(config);
-  config.logger.debug('Detected entrypoints:', entrypoints);
+  const entrypoints = await findEntrypoints();
+  wxt.logger.debug('Detected entrypoints:', entrypoints);

  const validationResults = validateEntrypoints(entrypoints);
  if (validationResults.errorCount + validationResults.warningCount > 0) {
-    printValidationResults(config, validationResults);
+    printValidationResults(validationResults);
  }
  if (validationResults.errorCount > 0) {
    throw new ValidationError(`Entrypoint validation failed`, {
@@ -58,28 +59,25 @@ export async function internalBuild(
  }

  const groups = groupEntrypoints(entrypoints);
-  const { output, warnings } = await rebuild(
-    config,
-    entrypoints,
-    groups,
-    undefined,
-  );
+  await wxt.hooks.callHook('entrypoints:grouped', wxt, groups);
+
+  const { output, warnings } = await rebuild(entrypoints, groups, undefined);
+  await wxt.hooks.callHook('build:done', wxt, output);

  // Post-build
  await printBuildSummary(
-    config.logger.success,
+    wxt.logger.success,
    `Built extension in ${formatDuration(Date.now() - startTime)}`,
    output,
-    config,
  );

  for (const warning of warnings) {
-    config.logger.warn(...warning);
+    wxt.logger.warn(...warning);
  }

-  if (config.analysis.enabled) {
-    await combineAnalysisStats(config);
-    config.logger.info(
+  if (wxt.config.analysis.enabled) {
+    await combineAnalysisStats();
+    wxt.logger.info(
      `Analysis complete:\n  ${pc.gray('└─')} ${pc.yellow('stats.html')}`,
    );
  }
@@ -87,31 +85,26 @@ export async function internalBuild(
  return output;
 }

-async function combineAnalysisStats(config: InternalConfig): Promise<void> {
-  const { execaCommand } = await import('execa');
+async function combineAnalysisStats(): Promise<void> {
  const unixFiles = await glob(`stats-*.json`, {
-    cwd: config.outDir,
+    cwd: wxt.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
-    }`,
-    { cwd: config.root, stdio: 'inherit' },
+  await exec(
+    'rollup-plugin-visualizer',
+    [...absolutePaths, '--template', wxt.config.analysis.template],
+    { cwd: wxt.config.root, stdio: 'inherit' },
  );
 }

-function printValidationResults(
-  config: InternalConfig,
-  { errorCount, errors, warningCount }: ValidationResults,
-) {
-  (errorCount > 0 ? config.logger.error : config.logger.warn)(
+function printValidationResults({
+  errorCount,
+  errors,
+  warningCount,
+}: ValidationResults) {
+  (errorCount > 0 ? wxt.logger.error : wxt.logger.warn)(
    `Entrypoint validation failed: ${errorCount} error${
      errorCount === 1 ? '' : 's'
    }, ${warningCount} warning${warningCount === 1 ? '' : 's'}`,
@@ -1,13 +1,9 @@
 import type { Manifest } from '~/browser';
-import {
-  BuildOutput,
-  Entrypoint,
-  EntrypointGroup,
-  InternalConfig,
-} from '~/types';
+import { BuildOutput, Entrypoint, EntrypointGroup } from '~/types';
 import { generateTypesDir } from './generate-wxt-dir';
 import { buildEntrypoints } from './build-entrypoints';
 import { generateManifest, writeManifest } from '~/core/utils/manifest';
+import { wxt } from '../../wxt';

 /**
 * Given a configuration, list of entrypoints, and an existing, partial output, build the
@@ -26,7 +22,6 @@ import { generateManifest, writeManifest } from '~/core/utils/manifest';
 *                       this is the first build.
 */
 export async function rebuild(
-  config: InternalConfig,
  allEntrypoints: Entrypoint[],
  entrypointGroups: EntrypointGroup[],
  existingOutput: Omit<BuildOutput, 'manifest'> = {
@@ -42,28 +37,28 @@ export async function rebuild(
  const spinner = ora(`Preparing...`).start();

  // Update types directory with new files and types
-  await generateTypesDir(allEntrypoints, config).catch((err) => {
-    config.logger.warn('Failed to update .wxt directory:', err);
+  await generateTypesDir(allEntrypoints).catch((err) => {
+    wxt.logger.warn('Failed to update .wxt directory:', err);
    // Throw the error if doing a regular build, don't for dev mode.
-    if (config.command === 'build') throw err;
+    if (wxt.config.command === 'build') throw err;
  });

  // Build and merge the outputs
-  const newOutput = await buildEntrypoints(entrypointGroups, config, spinner);
+  const newOutput = await buildEntrypoints(entrypointGroups, spinner);
  const mergedOutput: Omit<BuildOutput, 'manifest'> = {
    steps: [...existingOutput.steps, ...newOutput.steps],
    publicAssets: [...existingOutput.publicAssets, ...newOutput.publicAssets],
  };

  const { manifest: newManifest, warnings: manifestWarnings } =
-    await generateManifest(allEntrypoints, mergedOutput, config);
+    await generateManifest(allEntrypoints, mergedOutput);
  const finalOutput: BuildOutput = {
    manifest: newManifest,
    ...newOutput,
  };

  // Write manifest
-  await writeManifest(newManifest, finalOutput, config);
+  await writeManifest(newManifest, finalOutput);

  // Stop the spinner and remove it from the CLI output
  spinner.clear().stop();
@@ -1,7 +1,7 @@
 import { loadConfig } from 'c12';
 import {
  InlineConfig,
-  InternalConfig,
+  ResolvedConfig,
  UserConfig,
  ConfigEnv,
  UserManifestFn,
@@ -23,15 +23,15 @@ import { NullablyRequired } from '../types';
 * Inline config always has priority over user config. Cli flags are passed as inline config if set.
 * If unset, undefined is passed in, letting this function decide default values.
 */
-export async function getInternalConfig(
+export async function resolveConfig(
  inlineConfig: InlineConfig,
  command: 'build' | 'serve',
  server?: WxtDevServer,
-): Promise<InternalConfig> {
+): Promise<ResolvedConfig> {
  // Load user config

  let userConfig: UserConfig = {};
-  let userConfigMetadata: InternalConfig['userConfigMetadata'] | undefined;
+  let userConfigMetadata: ResolvedConfig['userConfigMetadata'] | undefined;
  if (inlineConfig.configFile !== false) {
    const { config: loadedConfig, ...metadata } = await loadConfig<UserConfig>({
      name: 'wxt',
@@ -100,7 +100,7 @@ export async function getInternalConfig(
    }).map(([key, value]) => [key, path.resolve(root, value)]),
  );

-  const finalConfig: Omit<InternalConfig, 'builder'> = {
+  const finalConfig: Omit<ResolvedConfig, 'builder'> = {
    browser,
    command,
    debug,
@@ -140,6 +140,7 @@ export async function getInternalConfig(
    dev: {
      reloadCommand,
    },
+    hooks: mergedConfig.hooks ?? {},
  };

  const builder = await createViteBuilder(
@@ -191,6 +192,10 @@ function mergeInlineConfig(
    inlineConfig.zip ?? {},
    userConfig.zip ?? {},
  );
+  const hooks: InlineConfig['hooks'] = defu(
+    inlineConfig.hooks ?? {},
+    userConfig.hooks ?? {},
+  );

  return {
    root: inlineConfig.root ?? userConfig.root,
@@ -229,13 +234,14 @@ function mergeInlineConfig(
      ...userConfig.dev,
      ...inlineConfig.dev,
    },
+    hooks,
  };
 }

 function resolveInternalZipConfig(
  root: string,
  mergedConfig: InlineConfig,
-): NullablyRequired<InternalConfig['zip']> {
+): NullablyRequired<ResolvedConfig['zip']> {
  return {
    name: undefined,
    sourcesTemplate: '{{name}}-{{version}}-sources.zip',
@@ -1,6 +1,7 @@
 import type { Manifest } from '~/browser';
-import { ContentScriptEntrypoint, InternalConfig } from '~/types';
+import { ContentScriptEntrypoint } from '~/types';
 import { resolvePerBrowserOption } from './entrypoints';
+import { wxt } from '../wxt';

 /**
 * Returns a unique and consistent string hash based on a content scripts options.
@@ -9,9 +10,8 @@ import { resolvePerBrowserOption } from './entrypoints';
 */
 export function hashContentScriptOptions(
  options: ContentScriptEntrypoint['options'],
-  config: InternalConfig,
 ): string {
-  const simplifiedOptions = mapWxtOptionsToContentScript(options, config);
+  const simplifiedOptions = mapWxtOptionsToContentScript(options);

  // Remove undefined fields and use defaults to generate hash
  Object.keys(simplifiedOptions).forEach((key) => {
@@ -45,33 +45,32 @@ export function hashContentScriptOptions(

 export function mapWxtOptionsToContentScript(
  options: ContentScriptEntrypoint['options'],
-  config: InternalConfig,
 ): Omit<Manifest.ContentScript, 'js' | 'css'> {
  return {
-    matches: resolvePerBrowserOption(options.matches, config.browser),
-    all_frames: resolvePerBrowserOption(options.allFrames, config.browser),
+    matches: resolvePerBrowserOption(options.matches, wxt.config.browser),
+    all_frames: resolvePerBrowserOption(options.allFrames, wxt.config.browser),
    match_about_blank: resolvePerBrowserOption(
      options.matchAboutBlank,
-      config.browser,
+      wxt.config.browser,
    ),
    exclude_globs: resolvePerBrowserOption(
      options.excludeGlobs,
-      config.browser,
+      wxt.config.browser,
    ),
    exclude_matches: resolvePerBrowserOption(
      options.excludeMatches,
-      config.browser,
+      wxt.config.browser,
    ),
    include_globs: resolvePerBrowserOption(
      options.includeGlobs,
-      config.browser,
+      wxt.config.browser,
    ),
-    run_at: resolvePerBrowserOption(options.runAt, config.browser),
+    run_at: resolvePerBrowserOption(options.runAt, wxt.config.browser),

    // @ts-expect-error: untyped chrome options
    match_origin_as_fallback: resolvePerBrowserOption(
      options.matchOriginAsFallback,
-      config.browser,
+      wxt.config.browser,
    ),
    world: options.world,
  };
@@ -0,0 +1,26 @@
+import type { Options } from 'execa';
+import managePath from 'manage-path';
+import { resolve } from 'node:path';
+import { wxt } from '../wxt';
+
+const managedPath = managePath(process.env);
+
+/**
+ * Wrapper around `execa` with a modified `PATH` variable containing CLI tools from WXT's dependencies.
+ */
+export const exec = async (
+  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(wxt.config.root, 'node_modules/wxt/node_modules/.bin'),
+  );
+
+  const { execa } = await import('execa');
+  return await execa(file, args, options);
+};
@@ -1,7 +1,7 @@
-import { InternalConfig } from '~/types';
 import fs from 'fs-extra';
 import glob from 'fast-glob';
 import { unnormalizePath } from './paths';
+import { wxt } from '../wxt';

 /**
 * Only write the contents to a file if it results in a change. This prevents unnecessary file
@@ -27,11 +27,9 @@ export async function writeFileIfDifferent(
 * Get all the files in the project's public directory. Returned paths are relative to the
 * `config.publicDir`.
 */
-export async function getPublicFiles(
-  config: InternalConfig,
-): Promise<string[]> {
-  if (!(await fs.exists(config.publicDir))) return [];
+export async function getPublicFiles(): Promise<string[]> {
+  if (!(await fs.exists(wxt.config.publicDir))) return [];

-  const files = await glob('**/*', { cwd: config.publicDir });
+  const files = await glob('**/*', { cwd: wxt.config.publicDir });
  return files.map(unnormalizePath);
 }
@@ -1,7 +1,7 @@
-import { InternalConfig } from '~/types';
+import { ResolvedConfig } from '~/types';

 export function getGlobals(
-  config: Omit<InternalConfig, 'builder'>,
+  config: Omit<ResolvedConfig, 'builder'>,
 ): Array<{ name: string; value: any; type: string }> {
  return [
    {
@@ -1,12 +1,12 @@
 import { resolve } from 'path';
-import { BuildOutput, InternalConfig } from '~/types';
+import { BuildOutput } from '~/types';
 import { printFileList } from './printFileList';
+import { wxt } from '../../wxt';

 export async function printBuildSummary(
  log: (...args: any[]) => void,
  header: string,
  output: BuildOutput,
-  config: InternalConfig,
 ) {
  const chunks = [
    ...output.steps.flatMap((step) => step.chunks),
@@ -19,8 +19,10 @@ export async function printBuildSummary(
    return l.fileName.localeCompare(r.fileName);
  });

-  const files = chunks.map((chunk) => resolve(config.outDir, chunk.fileName));
-  await printFileList(log, header, config.outDir, files);
+  const files = chunks.map((chunk) =>
+    resolve(wxt.config.outDir, chunk.fileName),
+  );
+  await printFileList(log, header, wxt.config.outDir, files);
 }

 const DEFAULT_SORT_WEIGHT = 100;
@@ -4,7 +4,6 @@ import {
  BackgroundEntrypoint,
  BuildOutput,
  ContentScriptEntrypoint,
-  InternalConfig,
  OptionsEntrypoint,
  PopupEntrypoint,
 } from '~/types';
@@ -24,6 +23,7 @@ import { normalizePath } from './paths';
 import { writeFileIfDifferent } from './fs';
 import { produce } from 'immer';
 import defu from 'defu';
+import { wxt } from '../wxt';

 /**
 * Writes the manifest to the output directory and the build output.
@@ -31,15 +31,14 @@ import defu from 'defu';
 export async function writeManifest(
  manifest: Manifest.WebExtensionManifest,
  output: BuildOutput,
-  config: InternalConfig,
 ): Promise<void> {
  const str =
-    config.mode === 'production'
+    wxt.config.mode === 'production'
      ? JSON.stringify(manifest)
      : JSON.stringify(manifest, null, 2);

-  await fs.ensureDir(config.outDir);
-  await writeFileIfDifferent(resolve(config.outDir, 'manifest.json'), str);
+  await fs.ensureDir(wxt.config.outDir);
+  await writeFileIfDifferent(resolve(wxt.config.outDir, 'manifest.json'), str);

  output.publicAssets.unshift({
    type: 'asset',
@@ -53,30 +52,31 @@ export async function writeManifest(
 export async function generateManifest(
  entrypoints: Entrypoint[],
  buildOutput: Omit<BuildOutput, 'manifest'>,
-  config: InternalConfig,
 ): Promise<{ manifest: Manifest.WebExtensionManifest; warnings: any[][] }> {
  const warnings: any[][] = [];
-  const pkg = await getPackageJson(config);
+  const pkg = await getPackageJson();

  let versionName =
-    config.manifest.version_name ?? config.manifest.version ?? pkg?.version;
+    wxt.config.manifest.version_name ??
+    wxt.config.manifest.version ??
+    pkg?.version;
  if (versionName == null) {
    versionName = '0.0.0';
-    config.logger.warn(
+    wxt.logger.warn(
      'Extension version not found, defaulting to "0.0.0". Add a version to your `package.json` or `wxt.config.ts` file. For more details, see: https://wxt.dev/guide/manifest.html#version-and-version-name',
    );
  }
-  const version = config.manifest.version ?? simplifyVersion(versionName);
+  const version = wxt.config.manifest.version ?? simplifyVersion(versionName);

  const baseManifest: Manifest.WebExtensionManifest = {
-    manifest_version: config.manifestVersion,
+    manifest_version: wxt.config.manifestVersion,
    name: pkg?.name,
    description: pkg?.description,
    version,
    short_name: pkg?.shortName,
    icons: discoverIcons(buildOutput),
  };
-  const userManifest = config.manifest;
+  const userManifest = wxt.config.manifest;

  const manifest = defu(
    userManifest,
@@ -84,7 +84,7 @@ export async function generateManifest(
  ) as Manifest.WebExtensionManifest;

  // Add reload command in dev mode
-  if (config.command === 'serve' && config.dev.reloadCommand) {
+  if (wxt.config.command === 'serve' && wxt.config.dev.reloadCommand) {
    if (manifest.commands && Object.keys(manifest.commands).length >= 4) {
      warnings.push([
        "Extension already has 4 registered commands, WXT's reload command is disabled",
@@ -94,7 +94,7 @@ export async function generateManifest(
      manifest.commands['wxt:reload-extension'] = {
        description: 'Reload the extension during development',
        suggested_key: {
-          default: config.dev.reloadCommand,
+          default: wxt.config.dev.reloadCommand,
        },
      };
    }
@@ -104,16 +104,17 @@ export async function generateManifest(
  manifest.version = version;
  manifest.version_name =
    // Firefox doesn't support version_name
-    config.browser === 'firefox' || versionName === version
+    wxt.config.browser === 'firefox' || versionName === version
      ? undefined
      : versionName;

-  addEntrypoints(manifest, entrypoints, buildOutput, config);
+  addEntrypoints(manifest, entrypoints, buildOutput);

-  if (config.command === 'serve') addDevModeCsp(manifest, config);
-  if (config.command === 'serve') addDevModePermissions(manifest, config);
+  if (wxt.config.command === 'serve') addDevModeCsp(manifest);
+  if (wxt.config.command === 'serve') addDevModePermissions(manifest);

-  const finalManifest = produce(manifest, config.transformManifest);
+  const finalManifest = produce(manifest, wxt.config.transformManifest);
+  await wxt.hooks.callHook('build:manifestGenerated', wxt, finalManifest);

  if (finalManifest.name == null)
    throw Error(
@@ -153,7 +154,6 @@ function addEntrypoints(
  manifest: Manifest.WebExtensionManifest,
  entrypoints: Entrypoint[],
  buildOutput: Omit<BuildOutput, 'manifest'>,
-  config: InternalConfig,
 ): void {
  const entriesByType = entrypoints.reduce<
    Partial<Record<Entrypoint['type'], Entrypoint[]>>
@@ -181,13 +181,17 @@ function addEntrypoints(
  const sidepanels = entriesByType['sidepanel'];

  if (background) {
-    const script = getEntrypointBundlePath(background, config.outDir, '.js');
-    if (config.browser === 'firefox' && config.manifestVersion === 3) {
+    const script = getEntrypointBundlePath(
+      background,
+      wxt.config.outDir,
+      '.js',
+    );
+    if (wxt.config.browser === 'firefox' && wxt.config.manifestVersion === 3) {
      manifest.background = {
        type: background.options.type,
        scripts: [script],
      };
-    } else if (config.manifestVersion === 3) {
+    } else if (wxt.config.manifestVersion === 3) {
      manifest.background = {
        type: background.options.type,
        service_worker: script,
@@ -201,8 +205,8 @@ function addEntrypoints(
  }

  if (bookmarks) {
-    if (config.browser === 'firefox') {
-      config.logger.warn(
+    if (wxt.config.browser === 'firefox') {
+      wxt.logger.warn(
        'Bookmarks are not supported by Firefox. chrome_url_overrides.bookmarks was not added to the manifest',
      );
    } else {
@@ -210,15 +214,15 @@ function addEntrypoints(
      // @ts-expect-error: bookmarks is untyped in webextension-polyfill, but supported by chrome
      manifest.chrome_url_overrides.bookmarks = getEntrypointBundlePath(
        bookmarks,
-        config.outDir,
+        wxt.config.outDir,
        '.html',
      );
    }
  }

  if (history) {
-    if (config.browser === 'firefox') {
-      config.logger.warn(
+    if (wxt.config.browser === 'firefox') {
+      wxt.logger.warn(
        'Bookmarks are not supported by Firefox. chrome_url_overrides.history was not added to the manifest',
      );
    } else {
@@ -226,7 +230,7 @@ function addEntrypoints(
      // @ts-expect-error: history is untyped in webextension-polyfill, but supported by chrome
      manifest.chrome_url_overrides.history = getEntrypointBundlePath(
        history,
-        config.outDir,
+        wxt.config.outDir,
        '.html',
      );
    }
@@ -236,7 +240,7 @@ function addEntrypoints(
    manifest.chrome_url_overrides ??= {};
    manifest.chrome_url_overrides.newtab = getEntrypointBundlePath(
      newtab,
-      config.outDir,
+      wxt.config.outDir,
      '.html',
    );
  }
@@ -244,7 +248,7 @@ function addEntrypoints(
  if (popup) {
    const default_popup = getEntrypointBundlePath(
      popup,
-      config.outDir,
+      wxt.config.outDir,
      '.html',
    );
    const options: Manifest.ActionManifest = {};
@@ -273,33 +277,37 @@ function addEntrypoints(
  if (devtools) {
    manifest.devtools_page = getEntrypointBundlePath(
      devtools,
-      config.outDir,
+      wxt.config.outDir,
      '.html',
    );
  }

  if (options) {
-    const page = getEntrypointBundlePath(options, config.outDir, '.html');
+    const page = getEntrypointBundlePath(options, wxt.config.outDir, '.html');
    manifest.options_ui = {
      open_in_tab: options.options.openInTab,
      browser_style:
-        config.browser === 'firefox' ? options.options.browserStyle : undefined,
+        wxt.config.browser === 'firefox'
+          ? options.options.browserStyle
+          : undefined,
      chrome_style:
-        config.browser !== 'firefox' ? options.options.chromeStyle : undefined,
+        wxt.config.browser !== 'firefox'
+          ? options.options.chromeStyle
+          : undefined,
      page,
    };
  }

  if (sandboxes?.length) {
-    if (config.browser === 'firefox') {
-      config.logger.warn(
+    if (wxt.config.browser === 'firefox') {
+      wxt.logger.warn(
        'Sandboxed pages not supported by Firefox. sandbox.pages was not added to the manifest',
      );
    } else {
      // @ts-expect-error: sandbox not typed
      manifest.sandbox = {
        pages: sandboxes.map((entry) =>
-          getEntrypointBundlePath(entry, config.outDir, '.html'),
+          getEntrypointBundlePath(entry, wxt.config.outDir, '.html'),
        ),
      };
    }
@@ -310,23 +318,23 @@ function addEntrypoints(
      sidepanels.find((entry) => entry.name === 'sidepanel') ?? sidepanels[0];
    const page = getEntrypointBundlePath(
      defaultSidepanel,
-      config.outDir,
+      wxt.config.outDir,
      '.html',
    );

-    if (config.browser === 'firefox') {
+    if (wxt.config.browser === 'firefox') {
      manifest.sidebar_action = {
        // TODO: Add options to side panel
        // ...defaultSidepanel.options,
        default_panel: page,
      };
-    } else if (config.manifestVersion === 3) {
+    } else if (wxt.config.manifestVersion === 3) {
      // @ts-expect-error: Untyped
      manifest.side_panel = {
        default_path: page,
      };
    } else {
-      config.logger.warn(
+      wxt.logger.warn(
        'Side panel not supported by Chromium using MV2. side_panel.default_path was not added to the manifest',
      );
    }
@@ -337,12 +345,12 @@ function addEntrypoints(

    // Don't add content scripts to the manifest in dev mode for MV3 - they're managed and reloaded
    // at runtime
-    if (config.command === 'serve' && config.manifestVersion === 3) {
+    if (wxt.config.command === 'serve' && wxt.config.manifestVersion === 3) {
      const hostPermissions = new Set<string>(manifest.host_permissions ?? []);
      contentScripts.forEach((script) => {
        const matches = resolvePerBrowserOption(
          script.options.matches,
-          config.browser,
+          wxt.config.browser,
        );
        matches.forEach((matchPattern) => {
          hostPermissions.add(matchPattern);
@@ -353,7 +361,7 @@ function addEntrypoints(
      );
    } else {
      const hashToEntrypointsMap = contentScripts.reduce((map, script) => {
-        const hash = hashContentScriptOptions(script.options, config);
+        const hash = hashContentScriptOptions(script.options);
        if (map.has(hash)) map.get(hash)?.push(script);
        else map.set(hash, [script]);
        return map;
@@ -361,10 +369,10 @@ function addEntrypoints(

      const newContentScripts = Array.from(hashToEntrypointsMap.entries()).map(
        ([, scripts]) => ({
-          ...mapWxtOptionsToContentScript(scripts[0].options, config),
+          ...mapWxtOptionsToContentScript(scripts[0].options),
          css: getContentScriptCssFiles(scripts, cssMap),
          js: scripts.map((entry) =>
-            getEntrypointBundlePath(entry, config.outDir, '.js'),
+            getEntrypointBundlePath(entry, wxt.config.outDir, '.js'),
          ),
        }),
      );
@@ -375,7 +383,6 @@ function addEntrypoints(
    }

    const contentScriptCssResources = getContentScriptCssWebAccessibleResources(
-      config,
      contentScripts,
      cssMap,
    );
@@ -420,12 +427,9 @@ function discoverIcons(
  return icons.length > 0 ? Object.fromEntries(icons) : undefined;
 }

-function addDevModeCsp(
-  manifest: Manifest.WebExtensionManifest,
-  config: InternalConfig,
-): void {
-  const permission = `http://${config.server?.hostname ?? ''}/*`;
-  const allowedCsp = config.server?.origin ?? 'http://localhost:*';
+function addDevModeCsp(manifest: Manifest.WebExtensionManifest): void {
+  const permission = `http://${wxt.config.server?.hostname ?? ''}/*`;
+  const allowedCsp = wxt.config.server?.origin ?? 'http://localhost:*';

  if (manifest.manifest_version === 3) {
    addHostPermission(manifest, permission);
@@ -442,7 +446,7 @@ function addDevModeCsp(
        "script-src 'self'; object-src 'self';", // default CSP for MV2
  );

-  if (config.server) csp.add('script-src', allowedCsp);
+  if (wxt.config.server) csp.add('script-src', allowedCsp);

  if (manifest.manifest_version === 3) {
    manifest.content_security_policy ??= {};
@@ -453,15 +457,12 @@ function addDevModeCsp(
  }
 }

-function addDevModePermissions(
-  manifest: Manifest.WebExtensionManifest,
-  config: InternalConfig,
-) {
+function addDevModePermissions(manifest: Manifest.WebExtensionManifest) {
  // For reloading the page
  addPermission(manifest, 'tabs');

  // For registering content scripts
-  if (config.manifestVersion === 3) addPermission(manifest, 'scripting');
+  if (wxt.config.manifestVersion === 3) addPermission(manifest, 'scripting');
 }

 /**
@@ -497,7 +498,6 @@ export function getContentScriptCssFiles(
 * added to.
 */
 export function getContentScriptCssWebAccessibleResources(
-  config: InternalConfig,
  contentScripts: ContentScriptEntrypoint[],
  contentScriptCssMap: Record<string, string | undefined>,
 ): any[] {
@@ -509,14 +509,14 @@ export function getContentScriptCssWebAccessibleResources(
    const cssFile = contentScriptCssMap[script.name];
    if (cssFile == null) return;

-    if (config.manifestVersion === 2) {
+    if (wxt.config.manifestVersion === 2) {
      resources.push(cssFile);
    } else {
      resources.push({
        resources: [cssFile],
        matches: resolvePerBrowserOption(
          script.options.matches,
-          config.browser,
+          wxt.config.browser,
        ).map((matchPattern) => stripPathFromMatchPattern(matchPattern)),
      });
    }
@@ -1,5 +1,5 @@
 import dns from 'node:dns';
-import { InternalConfig } from '~/types';
+import { ResolvedConfig } from '~/types';
 import { withTimeout } from './time';

 function isOffline(): Promise<boolean> {
@@ -26,7 +26,7 @@ export async function isOnline(): Promise<boolean> {
 */
 export async function fetchCached(
  url: string,
-  config: Omit<InternalConfig, 'builder'>,
+  config: Omit<ResolvedConfig, 'builder'>,
 ): Promise<string> {
  let content: string = '';

@@ -1,20 +1,20 @@
 import { resolve } from 'node:path';
-import { InternalConfig } from '~/types';
 import fs from 'fs-extra';
+import { wxt } from '../wxt';

 /**
 * Read the project's package.json.
 *
 * TODO: look in root and up directories until it's found
 */
-export async function getPackageJson(
-  config: InternalConfig,
-): Promise<Partial<Record<string, any>> | undefined> {
-  const file = resolve(config.root, 'package.json');
+export async function getPackageJson(): Promise<
+  Partial<Record<string, any>> | undefined
+> {
+  const file = resolve(wxt.config.root, 'package.json');
  try {
    return await fs.readJson(file);
  } catch (err) {
-    config.logger.debug(
+    wxt.logger.debug(
      `Failed to read package.json at: ${file}. Returning undefined.`,
    );
    return {};
@@ -7,7 +7,7 @@ import merge from 'lodash.merge';
 import { Commands, type Manifest } from '~/browser';
 import {
  FsCache,
-  InternalConfig,
+  ResolvedConfig,
  WxtDevServer,
  BackgroundEntrypoint,
  ContentScriptEntrypoint,
@@ -20,12 +20,19 @@ import {
  BuildOutput,
  BuildStepOutput,
  UserManifest,
+  Wxt,
 } from '~/types';
 import { mock } from 'vitest-mock-extended';
+import { vi } from 'vitest';
+import { setWxtForTesting } from '~/core/wxt';

 faker.seed(__TEST_SEED__);

-type DeepPartial<T> = { [key in keyof T]+?: Partial<T[key]> };
+type DeepPartial<T> = T extends object
+  ? {
+      [P in keyof T]?: DeepPartial<T[P]>;
+    }
+  : T;
 function fakeObjectCreator<T>(base: () => T) {
  return (overrides?: DeepPartial<T>): T => merge(base(), overrides);
 }
@@ -197,7 +204,7 @@ export function fakeArray<T>(createItem: () => T, count = 3): T[] {
  return array;
 }

-export const fakeInternalConfig = fakeObjectCreator<InternalConfig>(() => {
+export const fakeResolvedConfig = fakeObjectCreator<ResolvedConfig>(() => {
  const browser = faker.helpers.arrayElement(['chrome', 'firefox']);
  const command = faker.helpers.arrayElement(['build', 'serve'] as const);
  const manifestVersion = faker.helpers.arrayElement([2, 3] as const);
@@ -248,9 +255,22 @@ export const fakeInternalConfig = fakeObjectCreator<InternalConfig>(() => {
    dev: {
      reloadCommand: 'Alt+R',
    },
+    hooks: {},
  };
 });

+export const fakeWxt = fakeObjectCreator<Wxt>(() => ({
+  config: fakeResolvedConfig(),
+  hooks: mock(),
+  logger: mock(),
+  reloadConfig: vi.fn(),
+}));
+
+export function setFakeWxt(overrides?: DeepPartial<Wxt>) {
+  const wxt = fakeWxt(overrides);
+  setWxtForTesting(wxt);
+}
+
 export const fakeBuildOutput = fakeObjectCreator<BuildOutput>(() => ({
  manifest: fakeManifest(),
  publicAssets: fakeArray(fakeOutputAsset),
@@ -269,3 +289,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,
+}));
@@ -1,9 +1,9 @@
 import { UnimportOptions } from 'unimport';
-import { InternalConfig } from '~/types';
+import { ResolvedConfig } from '~/types';
 import { defu } from 'defu';

 export function getUnimportOptions(
-  config: Omit<InternalConfig, 'builder'>,
+  config: Omit<ResolvedConfig, 'builder'>,
 ): Partial<UnimportOptions | false> {
  if (config.imports === false) return false;

@@ -0,0 +1,48 @@
+import { InlineConfig, Wxt, WxtDevServer, WxtHooks } from '~/types';
+import { resolveConfig } from './utils/building';
+import { createHooks } from 'hookable';
+
+/**
+ * Global variable set once `createWxt` is called once. Since this variable is used everywhere, this
+ * global can be used instead of passing the variable as a function parameter everywhere.
+ */
+export let wxt: Wxt;
+
+/**
+ * Create and register a global instance of the Wxt interface for use throughout the project.
+ */
+export async function registerWxt(
+  command: 'build' | 'serve',
+  inlineConfig: InlineConfig = {},
+  server?: WxtDevServer,
+): Promise<void> {
+  const config = await resolveConfig(inlineConfig, command, server);
+  const hooks = createHooks<WxtHooks>();
+
+  wxt = {
+    config,
+    hooks,
+    get logger() {
+      return config.logger;
+    },
+    async reloadConfig() {
+      wxt.config = await resolveConfig(inlineConfig, command, server);
+    },
+  };
+
+  // Initialize hooks
+  wxt.hooks.addHooks(config.hooks);
+  await wxt.hooks.callHook('ready', wxt);
+}
+
+/**
+ * @internal ONLY USE FOR TESTING.
+ *
+ * @example
+ * setWxtForTesting(fakeWxt({ ... }));
+ * // Or use the shorthand
+ * setFakeWxt({ ... })
+ */
+export function setWxtForTesting(testInstance: Wxt) {
+  wxt = testInstance;
+}
@@ -7,7 +7,8 @@ import { getPackageJson } from '~/core/utils/package';
 import { minimatch } from 'minimatch';
 import { formatDuration } from '~/core/utils/time';
 import { printFileList } from '~/core/utils/log/printFileList';
-import { getInternalConfig, internalBuild } from '~/core/utils/building';
+import { internalBuild } from '~/core/utils/building';
+import { registerWxt, wxt } from './wxt';

 /**
 * Build and zip the extension for distribution.
@@ -15,59 +16,54 @@ import { getInternalConfig, internalBuild } from '~/core/utils/building';
 * @returns A list of all files included in the ZIP.
 */
 export async function zip(config?: InlineConfig): Promise<string[]> {
-  const internalConfig = await getInternalConfig(config ?? {}, 'build');
-  const output = await internalBuild(internalConfig);
+  await registerWxt('build', config);
+  const output = await internalBuild();

  const start = Date.now();
-  internalConfig.logger.info('Zipping extension...');
+  wxt.logger.info('Zipping extension...');
  const zipFiles: string[] = [];

  const projectName =
-    internalConfig.zip.name ??
+    wxt.config.zip.name ??
    kebabCaseAlphanumeric(
-      (await getPackageJson(internalConfig))?.name || dirname(process.cwd()),
+      (await getPackageJson())?.name || dirname(process.cwd()),
    );
  const applyTemplate = (template: string): string =>
    template
      .replaceAll('{{name}}', projectName)
-      .replaceAll('{{browser}}', internalConfig.browser)
+      .replaceAll('{{browser}}', wxt.config.browser)
      .replaceAll(
        '{{version}}',
        output.manifest.version_name ?? output.manifest.version,
      )
-      .replaceAll('{{manifestVersion}}', `mv${internalConfig.manifestVersion}`);
+      .replaceAll('{{manifestVersion}}', `mv${wxt.config.manifestVersion}`);

-  await fs.ensureDir(internalConfig.outBaseDir);
+  await fs.ensureDir(wxt.config.outBaseDir);

  // ZIP output directory

-  const outZipFilename = applyTemplate(internalConfig.zip.artifactTemplate);
-  const outZipPath = resolve(internalConfig.outBaseDir, outZipFilename);
-  await zipdir(internalConfig.outDir, {
+  const outZipFilename = applyTemplate(wxt.config.zip.artifactTemplate);
+  const outZipPath = resolve(wxt.config.outBaseDir, outZipFilename);
+  await zipdir(wxt.config.outDir, {
    saveTo: outZipPath,
  });
  zipFiles.push(outZipPath);

  // ZIP sources for Firefox

-  if (internalConfig.browser === 'firefox') {
-    const sourcesZipFilename = applyTemplate(
-      internalConfig.zip.sourcesTemplate,
-    );
-    const sourcesZipPath = resolve(
-      internalConfig.outBaseDir,
-      sourcesZipFilename,
-    );
-    await zipdir(internalConfig.zip.sourcesRoot, {
+  if (wxt.config.browser === 'firefox') {
+    const sourcesZipFilename = applyTemplate(wxt.config.zip.sourcesTemplate);
+    const sourcesZipPath = resolve(wxt.config.outBaseDir, sourcesZipFilename);
+    await zipdir(wxt.config.zip.sourcesRoot, {
      saveTo: sourcesZipPath,
      filter(path) {
-        const relativePath = relative(internalConfig.zip.sourcesRoot, path);
+        const relativePath = relative(wxt.config.zip.sourcesRoot, path);

        return (
-          internalConfig.zip.includeSources.some((pattern) =>
+          wxt.config.zip.includeSources.some((pattern) =>
            minimatch(relativePath, pattern),
          ) ||
-          !internalConfig.zip.excludeSources.some((pattern) =>
+          !wxt.config.zip.excludeSources.some((pattern) =>
            minimatch(relativePath, pattern),
          )
        );
@@ -77,9 +73,9 @@ export async function zip(config?: InlineConfig): Promise<string[]> {
  }

  await printFileList(
-    internalConfig.logger.success,
+    wxt.logger.success,
    `Zipped extension in ${formatDuration(Date.now() - start)}`,
-    internalConfig.outBaseDir,
+    wxt.config.outBaseDir,
    zipFiles,
  );

@@ -2,5 +2,5 @@
 * @module wxt
 */
 export * from '~/core';
-export * from '~/types/external';
+export * from '~/types';
 export * from '~/version';
@@ -6,7 +6,7 @@ import {
  globals,
  webextensionPolyfillMock,
 } from '../core/builders/vite/plugins';
-import { getInternalConfig } from '~/core/utils/building';
+import { resolveConfig } from '~/core/utils/building';
 import { InlineConfig } from '../types';

 /**
@@ -25,7 +25,7 @@ import { InlineConfig } from '../types';
 * @param inlineConfig Customize WXT's config for testing. Any config specified here overrides the config from your `wxt.config.ts` file.
 */
 export function WxtVitest(inlineConfig?: InlineConfig): vite.PluginOption {
-  return getInternalConfig(inlineConfig ?? {}, 'serve').then((config) => [
+  return resolveConfig(inlineConfig ?? {}, 'serve').then((config) => [
    webextensionPolyfillMock(config),
    unimport(config),
    globals(config),
@@ -1,795 +0,0 @@
-import type * as vite from 'vite';
-import type { Manifest, Scripting } from '~/browser';
-import { UnimportOptions } from 'unimport';
-import { LogLevel } from 'consola';
-import { ContentScriptContext } from '../client/content-scripts/content-script-context';
-import type { PluginVisualizerOptions } from 'rollup-plugin-visualizer';
-import type { FSWatcher } from 'chokidar';
-
-export interface InlineConfig {
-  /**
-   * Your project's root directory containing the `package.json` used to fill out the
-   * `manifest.json`.
-   *
-   * @default process.cwd()
-   */
-  root?: string;
-  /**
-   * Directory containing all source code. Set to `"src"` to move all source code to a `src/`
-   * directory.
-   *
-   * @default config.root
-   */
-  srcDir?: string;
-  /**
-   * Directory containing files that will be copied to the output directory as-is.
-   *
-   * @default "${config.root}/public"
-   */
-  publicDir?: string;
-  /**
-   * @default "${config.srcDir}/entrypoints"
-   */
-  entrypointsDir?: string;
-  /**
-   * A list of entrypoint names (`"popup"`, `"options"`, etc.) to build. Will speed up the build if
-   * your extension has lots of entrypoints, and you don't need to build all of them to develop a
-   * feature.
-   */
-  filterEntrypoints?: string[];
-  /**
-   * Output directory that stored build folders and ZIPs.
-   *
-   * @default ".output"
-   */
-  outDir?: string;
-  /**
-   * > Only available when using the JS API. Not available in `wxt.config.ts` files
-   *
-   * Path to `wxt.config.ts` file or `false` to disable config file discovery.
-   *
-   * @default "wxt.config.ts"
-   */
-  configFile?: string | false;
-  /**
-   * Set to `true` to show debug logs. Overriden by the command line `--debug` option.
-   *
-   * @default false
-   */
-  debug?: boolean;
-  /**
-   * Explicitly set a mode to run in. This will override the default mode for each command, and can
-   * be overridden by the command line `--mode` option.
-   */
-  mode?: string;
-  /**
-   * Customize auto-import options. Set to `false` to disable auto-imports.
-   *
-   * For example, to add a directory to auto-import from, you can use:
-   *
-   * ```ts
-   * export default defineConfig({
-   *   imports: {
-   *     dirs: ["some-directory"]
-   *   }
-   * })
-   * ```
-   */
-  imports?: Partial<UnimportOptions> | false;
-  /**
-   * Explicitly set a browser to build for. This will override the default browser for each command,
-   * and can be overridden by the command line `--browser` option.
-   *
-   * @default
-   * "chrome"
-   */
-  browser?: TargetBrowser;
-  /**
-   * Explicitly set a manifest version to target. This will override the default manifest version
-   * for each command, and can be overridden by the command line `--mv2` or `--mv3` option.
-   */
-  manifestVersion?: TargetManifestVersion;
-  /**
-   * Override the logger used.
-   *
-   * @default
-   * consola
-   */
-  logger?: Logger;
-  /**
-   * Customize the `manifest.json` output. Can be an object, promise, or function that returns an
-   * object or promise.
-   */
-  manifest?: UserManifest | Promise<UserManifest> | UserManifestFn;
-  /**
-   * Custom runner options. Options set here can be overridden in a `web-ext.config.ts` file.
-   */
-  runner?: ExtensionRunnerConfig;
-  zip?: {
-    /**
-     * Configure the filename output when zipping files.
-     *
-     * Available template variables:
-     *
-     * - `{{name}}` - The project's name converted to kebab-case
-     * - `{{version}}` - The version_name or version from the manifest
-     * - `{{browser}}` - The target browser from the `--browser` CLI flag
-     * - `{{manifestVersion}}` - Either "2" or "3"
-     *
-     * @default "{{name}}-{{version}}-{{browser}}.zip"
-     */
-    artifactTemplate?: string;
-    /**
-     * Configure the filename output when zipping files.
-     *
-     * Available template variables:
-     *
-     * - `{{name}}` - The project's name converted to kebab-case
-     * - `{{version}}` - The version_name or version from the manifest
-     * - `{{browser}}` - The target browser from the `--browser` CLI flag
-     * - `{{manifestVersion}}` - Either "2" or "3"
-     *
-     * @default "{{name}}-{{version}}-sources.zip"
-     */
-    sourcesTemplate?: string;
-    /**
-     * Override the artifactTemplate's `{name}` template variable. Defaults to the `package.json`'s
-     * name, or if that doesn't exist, the current working directories name.
-     */
-    name?: string;
-    /**
-     * Root directory to ZIP when generating the sources ZIP.
-     *
-     * @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 Firefox. Patterns are relative to your
-     * `config.zip.sourcesRoot`.
-     *
-     * Hidden files, node_modules, and tests are ignored by default.
-     *
-     * @example
-     * [
-     *   "coverage", // Ignore the coverage directory in the `sourcesRoot`
-     * ]
-     */
-    excludeSources?: string[];
-  };
-
-  /**
-   * Transform the final manifest before it's written to the file system. Edit the `manifest`
-   * parameter directly, do not return a new object. Return values are ignored.
-   *
-   * @example
-   * defineConfig({
-   *   // Add a CSS-only content script.
-   *   transformManifest(manifest) {
-   *     manifest.content_scripts.push({
-   *       matches: ["*://google.com/*"],
-   *       css: ["content-scripts/some-example.css"],
-   *     });
-   *   }
-   * })
-   */
-  transformManifest?: (manifest: Manifest.WebExtensionManifest) => void;
-  analysis?: {
-    /**
-     * Explicitly include bundle analysis when running `wxt build`. This can be overridden by the
-     * command line `--analysis` option.
-     *
-     * @default false
-     */
-    enabled?: boolean;
-    /**
-     * When running `wxt build --analyze` or setting `analysis.enabled` to true, customize how the
-     * bundle will be visualized. See
-     * [`rollup-plugin-visualizer`](https://github.com/btd/rollup-plugin-visualizer#how-to-use-generated-files)
-     * for more details.
-     *
-     * @default "treemap"
-     */
-    template?: PluginVisualizerOptions['template'];
-  };
-  /**
-   * Add additional paths to the `.wxt/tsconfig.json`. Use this instead of overwriting the `paths`
-   * in the root `tsconfig.json` if you want to add new paths.
-   *
-   * The key is the import alias and the value is either a relative path to the root directory or an absolute path.
-   *
-   * @example
-   * {
-   *   "testing": "src/utils/testing.ts"
-   * }
-   */
-  alias?: Record<string, string>;
-  /**
-   * Experimental settings - use with caution.
-   */
-  experimental?: {
-    /**
-     * Whether to use [`webextension-polyfill`](https://www.npmjs.com/package/webextension-polyfill)
-     * when importing `browser` from `wxt/browser`.
-     *
-     * When set to `false`, WXT will export the chrome global instead of the polyfill from
-     * `wxt/browser`.
-     *
-     * You should use `browser` to access the web extension APIs.
-     *
-     * @experimental This option will remain experimental until Manifest V2 is dead.
-     *
-     * @default true
-     * @example
-     * export default defineConfig({
-     *   experimental: {
-     *     includeBrowserPolyfill: false
-     *   }
-     * })
-     */
-    includeBrowserPolyfill?: boolean;
-  };
-  /**
-   * Config effecting dev mode only.
-   */
-  dev?: {
-    /**
-     * Controls whether a custom keyboard shortcut command, `Alt+R`, is added during dev mode to
-     * quickly reload the extension.
-     *
-     * If false, the shortcut is not added during development.
-     *
-     * If set to a custom string, you can override the key combo used. See
-     * [Chrome's command docs](https://developer.chrome.com/docs/extensions/reference/api/commands)
-     * for available options.
-     *
-     * @default "Alt+R"
-     */
-    reloadCommand?: string | false;
-  };
-}
-
-// TODO: Extract to @wxt/vite-builder and use module augmentation to include the vite field
-export interface InlineConfig {
-  /**
-   * Return custom Vite options from a function. See
-   * <https://vitejs.dev/config/shared-options.html>.
-   *
-   * [`root`](#root), [`configFile`](#configfile), and [`mode`](#mode) should be set in WXT's config
-   * instead of Vite's.
-   *
-   * This is a function because any vite plugins added need to be recreated for each individual
-   * build step, incase they have internal state causing them to fail when reused.
-   */
-  vite?: (env: ConfigEnv) => WxtViteConfig | Promise<WxtViteConfig>;
-}
-
-// TODO: Move into @wxt/vite-builder
-export type WxtViteConfig = Omit<
-  vite.UserConfig,
-  'root' | 'configFile' | 'mode'
->;
-
-export interface BuildOutput {
-  manifest: Manifest.WebExtensionManifest;
-  publicAssets: OutputAsset[];
-  steps: BuildStepOutput[];
-}
-
-export type OutputFile = OutputChunk | OutputAsset;
-
-export interface OutputChunk {
-  type: 'chunk';
-  /**
-   * Relative, normalized path relative to the output directory.
-   *
-   * Ex: "content-scripts/overlay.js"
-   */
-  fileName: string;
-  /**
-   * Absolute, normalized paths to all dependencies this chunk relies on.
-   */
-  moduleIds: string[];
-}
-
-export interface OutputAsset {
-  type: 'asset';
-  /**
-   * Relative, normalized path relative to the output directory.
-   *
-   * Ex: "icons/16.png"
-   */
-  fileName: string;
-}
-
-export interface BuildStepOutput {
-  entrypoints: EntrypointGroup;
-  chunks: OutputFile[];
-}
-
-export interface WxtDevServer
-  extends Omit<WxtBuilderServer, 'listen' | 'close'>,
-    ServerInfo {
-  /**
-   * Stores the current build output of the server.
-   */
-  currentOutput: BuildOutput | undefined;
-  /**
-   * Start the server.
-   */
-  start(): Promise<void>;
-  /**
-   * Stop the server.
-   */
-  stop(): Promise<void>;
-  /**
-   * Close the browser, stop the server, rebuild the entire extension, and start the server again.
-   */
-  restart(): Promise<void>;
-  /**
-   * Transform the HTML for dev mode.
-   */
-  transformHtml(
-    url: string,
-    html: string,
-    originalUrl?: string | undefined,
-  ): Promise<string>;
-  /**
-   * Tell the extension to reload by running `browser.runtime.reload`.
-   */
-  reloadExtension: () => void;
-  /**
-   * Tell an extension page to reload.
-   *
-   * The path is the bundle path, not the input paths, so if the input paths is
-   * "src/options/index.html", you would pass "options.html" because that's where it is written to
-   * in the dist directory, and where it's available at in the actual extension.
-   *
-   * @example
-   * server.reloadPage("popup.html")
-   * server.reloadPage("sandbox.html")
-   */
-  reloadPage: (path: string) => void;
-  /**
-   * Tell the extension to restart a content script.
-   *
-   * @param contentScript The manifest definition for a content script
-   */
-  reloadContentScript: (
-    contentScript: Omit<Scripting.RegisteredContentScript, 'id'>,
-  ) => void;
-  /**
-   * Grab the latest runner config and restart the browser.
-   */
-  restartBrowser: () => void;
-}
-
-export type TargetBrowser = string;
-export type TargetManifestVersion = 2 | 3;
-
-export type UserConfig = Omit<InlineConfig, 'configFile'>;
-
-export interface Logger {
-  debug(...args: any[]): void;
-  log(...args: any[]): void;
-  info(...args: any[]): void;
-  warn(...args: any[]): void;
-  error(...args: any[]): void;
-  fatal(...args: any[]): void;
-  success(...args: any[]): void;
-  level: LogLevel;
-}
-
-export interface BaseEntrypointOptions {
-  include?: TargetBrowser[];
-  exclude?: TargetBrowser[];
-}
-
-export interface BaseEntrypoint {
-  /**
-   * The entrypoint's name. This is the filename or dirname without the type suffix.
-   *
-   * Examples:
-   * - `popup.html` &rarr; `popup`
-   * - `options/index.html` &rarr; `options`
-   * - `named.sandbox.html` &rarr; `named`
-   * - `named.sandbox/index.html` &rarr; `named`
-   * - `sandbox.html` &rarr; `sandbox`
-   * - `sandbox/index.html` &rarr; `sandbox`
-   * - `overlay.content.ts` &rarr; `overlay`
-   * - `overlay.content/index.ts` &rarr; `overlay`
-   *
-   * The name is used when generating an output file:
-   * `<entrypoint.outputDir>/<entrypoint.name>.<ext>`
-   */
-  name: string;
-  /**
-   * Absolute path to the entrypoint's input file.
-   */
-  inputPath: string;
-  /**
-   * Absolute path to the entrypoint's output directory. Can be the`InternalConfg.outDir` or a
-   * subdirectory of it.
-   */
-  outputDir: string;
-  options: BaseEntrypointOptions;
-  skipped: boolean;
-}
-
-export interface GenericEntrypoint extends BaseEntrypoint {
-  type:
-    | 'sandbox'
-    | 'bookmarks'
-    | 'history'
-    | 'newtab'
-    | 'sidepanel'
-    | 'devtools'
-    | 'unlisted-page'
-    | 'unlisted-script'
-    | 'unlisted-style'
-    | 'content-script-style';
-}
-
-export interface BackgroundEntrypoint extends BaseEntrypoint {
-  type: 'background';
-  options: {
-    persistent?: boolean;
-    type?: 'module';
-  } & BaseEntrypointOptions;
-}
-
-export interface ContentScriptEntrypoint extends BaseEntrypoint {
-  type: 'content-script';
-  options: Omit<ContentScriptDefinition, 'main'> & BaseEntrypointOptions;
-}
-
-export interface PopupEntrypoint extends BaseEntrypoint {
-  type: 'popup';
-  options: {
-    /**
-     * Defaults to "browser_action" to be equivalent to MV3's "action" key
-     */
-    mv2Key?: 'browser_action' | 'page_action';
-    defaultIcon?: Record<string, string>;
-    defaultTitle?: string;
-    browserStyle?: boolean;
-  } & BaseEntrypointOptions;
-}
-
-export interface OptionsEntrypoint extends BaseEntrypoint {
-  type: 'options';
-  options: {
-    openInTab?: boolean;
-    browserStyle?: boolean;
-    chromeStyle?: boolean;
-  } & BaseEntrypointOptions;
-}
-
-export type Entrypoint =
-  | GenericEntrypoint
-  | BackgroundEntrypoint
-  | ContentScriptEntrypoint
-  | PopupEntrypoint
-  | OptionsEntrypoint;
-
-export type EntrypointGroup = Entrypoint | Entrypoint[];
-
-export type OnContentScriptStopped = (cb: () => void) => void;
-
-export type ContentScriptDefinition =
-  | ContentScriptIsolatedWorldDefinition
-  | ContentScriptMainWorldDefinition;
-
-export interface ContentScriptIsolatedWorldDefinition
-  extends ContentScriptBaseDefinition {
-  /**
-   * See https://developer.chrome.com/docs/extensions/develop/concepts/content-scripts#isolated_world
-   * @default "ISOLATED"
-   */
-  world?: 'ISOLATED';
-  /**
-   * Main function executed when the content script is loaded.
-   */
-  main(ctx: ContentScriptContext): void | Promise<void>;
-}
-
-export interface ContentScriptMainWorldDefinition
-  extends ContentScriptBaseDefinition {
-  /**
-   * See https://developer.chrome.com/docs/extensions/develop/concepts/content-scripts#isolated_world
-   */
-  world: 'MAIN';
-  /**
-   * Main function executed when the content script is loaded.
-   */
-  main(): void | Promise<void>;
-}
-
-export interface ContentScriptBaseDefinition extends ExcludableEntrypoint {
-  matches: PerBrowserOption<Manifest.ContentScript['matches']>;
-  /**
-   * See https://developer.chrome.com/docs/extensions/mv3/content_scripts/
-   * @default "documentIdle"
-   */
-  runAt?: PerBrowserOption<Manifest.ContentScript['run_at']>;
-  /**
-   * See https://developer.chrome.com/docs/extensions/mv3/content_scripts/
-   * @default false
-   */
-  matchAboutBlank?: PerBrowserOption<
-    Manifest.ContentScript['match_about_blank']
-  >;
-  /**
-   * See https://developer.chrome.com/docs/extensions/mv3/content_scripts/
-   * @default []
-   */
-  excludeMatches?: PerBrowserOption<Manifest.ContentScript['exclude_matches']>;
-  /**
-   * See https://developer.chrome.com/docs/extensions/mv3/content_scripts/
-   * @default []
-   */
-  includeGlobs?: PerBrowserOption<Manifest.ContentScript['include_globs']>;
-  /**
-   * See https://developer.chrome.com/docs/extensions/mv3/content_scripts/
-   * @default []
-   */
-  excludeGlobs?: PerBrowserOption<Manifest.ContentScript['exclude_globs']>;
-  /**
-   * See https://developer.chrome.com/docs/extensions/mv3/content_scripts/
-   * @default false
-   */
-  allFrames?: PerBrowserOption<Manifest.ContentScript['all_frames']>;
-  /**
-   * See https://developer.chrome.com/docs/extensions/mv3/content_scripts/
-   * @default false
-   */
-  matchOriginAsFallback?: PerBrowserOption<boolean>;
-  /**
-   * Customize how imported/generated styles are injected with the content script. Regardless of the
-   * mode selected, CSS will always be built and included in the output directory.
-   *
-   * - `"manifest"` - Include the CSS in the manifest, under the content script's `css` array.
-   * - `"manual"` - Exclude the CSS from the manifest. You are responsible for manually loading it
-   *   onto the page. Use `browser.runtime.getURL("content-scripts/<name>.css")` to get the file's
-   *   URL
-   * - `"ui"` - Exclude the CSS from the manifest. CSS will be automatically added to your UI when
-   *   calling `createContentScriptUi`
-   *
-   * @default "manifest"
-   */
-  cssInjectionMode?: PerBrowserOption<'manifest' | 'manual' | 'ui'>;
-}
-
-export interface BackgroundDefinition extends ExcludableEntrypoint {
-  type?: PerBrowserOption<'module'>;
-  persistent?: PerBrowserOption<boolean>;
-  main(): void;
-}
-
-export interface UnlistedScriptDefinition extends ExcludableEntrypoint {
-  /**
-   * Main function executed when the unlisted script is ran.
-   */
-  main(): void | Promise<void>;
-}
-
-export type PerBrowserOption<T> = T | { [browser: TargetBrowser]: T };
-
-export interface ExcludableEntrypoint {
-  /**
-   * List of target browsers to include this entrypoint in. Defaults to being included in all
-   * builds. Cannot be used with `exclude`. You must choose one of the two options.
-   *
-   * @default undefined
-   */
-  include?: TargetBrowser[];
-  /**
-   * List of target browsers to exclude this entrypoint from. Cannot be used with `include`. You
-   * must choose one of the two options.
-   *
-   * @default undefined
-   */
-  exclude?: TargetBrowser[];
-}
-
-/**
- * Manifest customization available in the `wxt.config.ts` file. You cannot configure entrypoints
- * here, they are configured inline.
- */
-export type UserManifest = Partial<
-  Omit<
-    Manifest.WebExtensionManifest,
-    | 'background'
-    | 'chrome_url_overrides'
-    | 'devtools_page'
-    | 'manifest_version'
-    | 'options_page'
-    | 'options_ui'
-    | 'sandbox'
-    | 'sidepanel'
-    | 'sidebar_action'
-  >
->;
-
-export type UserManifestFn = (
-  env: ConfigEnv,
-) => UserManifest | Promise<UserManifest>;
-
-export interface ConfigEnv {
-  mode: string;
-  command: 'build' | 'serve';
-  /**
-   * Browser passed in from the CLI
-   */
-  browser: TargetBrowser;
-  /**
-   * Manifest version passed in from the CLI
-   */
-  manifestVersion: 2 | 3;
-}
-
-/**
- * Configure how the browser starts up.
- */
-export interface ExtensionRunnerConfig {
-  /**
-   * Whether or not to open the browser with the extension installed in dev mode.
-   *
-   * @default false
-   */
-  disabled?: boolean;
-  /**
-   * @see https://extensionworkshop.com/documentation/develop/web-ext-command-reference/#browser-console
-   */
-  openConsole?: boolean;
-  /**
-   * @see https://extensionworkshop.com/documentation/develop/web-ext-command-reference/#devtools
-   */
-  openDevtools?: boolean;
-  /**
-   * List of browser names and the binary that should be used to open the browser.
-   *
-   * @see https://extensionworkshop.com/documentation/develop/web-ext-command-reference/#chromium-binary
-   * @see https://extensionworkshop.com/documentation/develop/web-ext-command-reference/#firefox
-   */
-  binaries?: Record<string, string>;
-  /**
-   * @see https://extensionworkshop.com/documentation/develop/web-ext-command-reference/#firefox-profile
-   */
-  firefoxProfile?: string;
-  /**
-   * @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
-   */
-  firefoxPrefs?: Record<string, string>;
-  /**
-   * @see https://extensionworkshop.com/documentation/develop/web-ext-command-reference/#args
-   */
-  firefoxArgs?: string[];
-  /**
-   * @see https://extensionworkshop.com/documentation/develop/web-ext-command-reference/#args
-   */
-  chromiumArgs?: string[];
-  /**
-   * @see https://extensionworkshop.com/documentation/develop/web-ext-command-reference/#start-url
-   */
-  startUrls?: string[];
-}
-
-export interface WxtBuilder {
-  /**
-   * Name of tool used to build. Ex: "Vite" or "Webpack".
-   */
-  name: string;
-  /**
-   * Version of tool used to build. Ex: "5.0.2"
-   */
-  version: string;
-  /**
-   * Build a single entrypoint group. This is effectively one of the multiple "steps" during the
-   * build process.
-   */
-  build(group: EntrypointGroup): Promise<BuildStepOutput>;
-  /**
-   * Start a dev server at the provided port.
-   */
-  createServer(info: ServerInfo): Promise<WxtBuilderServer>;
-}
-
-export interface WxtBuilderServer {
-  /**
-   * Start the server.
-   */
-  listen(): Promise<void>;
-  /**
-   * Stop the server.
-   */
-  close(): Promise<void>;
-  /**
-   * Transform the HTML for dev mode.
-   */
-  transformHtml(
-    url: string,
-    html: string,
-    originalUrl?: string | undefined,
-  ): Promise<string>;
-  /**
-   * The web socket server used to communicate with the extension.
-   */
-  ws: {
-    /**
-     * Send a message via the server's websocket, with an optional payload.
-     *
-     * @example
-     * ws.send("wxt:reload-extension");
-     * ws.send("wxt:reload-content-script", { ... });
-     */
-    send(message: string, payload?: any): void;
-    /**
-     * Listen for messages over the server's websocket.
-     */
-    on(message: string, cb: (payload: any) => void): void;
-  };
-  /**
-   * Chokidar file watcher instance.
-   */
-  watcher: FSWatcher;
-}
-
-export interface ServerInfo {
-  /**
-   * Ex: `3000`
-   */
-  port: number;
-  /**
-   * Ex: `"localhost"`
-   */
-  hostname: string;
-  /**
-   * Ex: `"http://localhost:3000"`
-   */
-  origin: string;
-}
@@ -1,2 +1,928 @@
-export * from './external';
-export * from './internal';
+import type * as vite from 'vite';
+import type { Manifest, Scripting } from '~/browser';
+import { UnimportOptions } from 'unimport';
+import { LogLevel } from 'consola';
+import { ContentScriptContext } from '../client/content-scripts/content-script-context';
+import type { PluginVisualizerOptions } from 'rollup-plugin-visualizer';
+import type { FSWatcher } from 'chokidar';
+import { ResolvedConfig as C12ResolvedConfig } from 'c12';
+import { Hookable, NestedHooks } from 'hookable';
+
+export interface InlineConfig {
+  /**
+   * Your project's root directory containing the `package.json` used to fill out the
+   * `manifest.json`.
+   *
+   * @default process.cwd()
+   */
+  root?: string;
+  /**
+   * Directory containing all source code. Set to `"src"` to move all source code to a `src/`
+   * directory.
+   *
+   * @default config.root
+   */
+  srcDir?: string;
+  /**
+   * Directory containing files that will be copied to the output directory as-is.
+   *
+   * @default "${config.root}/public"
+   */
+  publicDir?: string;
+  /**
+   * @default "${config.srcDir}/entrypoints"
+   */
+  entrypointsDir?: string;
+  /**
+   * A list of entrypoint names (`"popup"`, `"options"`, etc.) to build. Will speed up the build if
+   * your extension has lots of entrypoints, and you don't need to build all of them to develop a
+   * feature.
+   */
+  filterEntrypoints?: string[];
+  /**
+   * Output directory that stored build folders and ZIPs.
+   *
+   * @default ".output"
+   */
+  outDir?: string;
+  /**
+   * > Only available when using the JS API. Not available in `wxt.config.ts` files
+   *
+   * Path to `wxt.config.ts` file or `false` to disable config file discovery.
+   *
+   * @default "wxt.config.ts"
+   */
+  configFile?: string | false;
+  /**
+   * Set to `true` to show debug logs. Overriden by the command line `--debug` option.
+   *
+   * @default false
+   */
+  debug?: boolean;
+  /**
+   * Explicitly set a mode to run in. This will override the default mode for each command, and can
+   * be overridden by the command line `--mode` option.
+   */
+  mode?: string;
+  /**
+   * Customize auto-import options. Set to `false` to disable auto-imports.
+   *
+   * For example, to add a directory to auto-import from, you can use:
+   *
+   * ```ts
+   * export default defineConfig({
+   *   imports: {
+   *     dirs: ["some-directory"]
+   *   }
+   * })
+   * ```
+   */
+  imports?: Partial<UnimportOptions> | false;
+  /**
+   * Explicitly set a browser to build for. This will override the default browser for each command,
+   * and can be overridden by the command line `--browser` option.
+   *
+   * @default
+   * "chrome"
+   */
+  browser?: TargetBrowser;
+  /**
+   * Explicitly set a manifest version to target. This will override the default manifest version
+   * for each command, and can be overridden by the command line `--mv2` or `--mv3` option.
+   */
+  manifestVersion?: TargetManifestVersion;
+  /**
+   * Override the logger used.
+   *
+   * @default
+   * consola
+   */
+  logger?: Logger;
+  /**
+   * Customize the `manifest.json` output. Can be an object, promise, or function that returns an
+   * object or promise.
+   */
+  manifest?: UserManifest | Promise<UserManifest> | UserManifestFn;
+  /**
+   * Custom runner options. Options set here can be overridden in a `web-ext.config.ts` file.
+   */
+  runner?: ExtensionRunnerConfig;
+  zip?: {
+    /**
+     * Configure the filename output when zipping files.
+     *
+     * Available template variables:
+     *
+     * - `{{name}}` - The project's name converted to kebab-case
+     * - `{{version}}` - The version_name or version from the manifest
+     * - `{{browser}}` - The target browser from the `--browser` CLI flag
+     * - `{{manifestVersion}}` - Either "2" or "3"
+     *
+     * @default "{{name}}-{{version}}-{{browser}}.zip"
+     */
+    artifactTemplate?: string;
+    /**
+     * Configure the filename output when zipping files.
+     *
+     * Available template variables:
+     *
+     * - `{{name}}` - The project's name converted to kebab-case
+     * - `{{version}}` - The version_name or version from the manifest
+     * - `{{browser}}` - The target browser from the `--browser` CLI flag
+     * - `{{manifestVersion}}` - Either "2" or "3"
+     *
+     * @default "{{name}}-{{version}}-sources.zip"
+     */
+    sourcesTemplate?: string;
+    /**
+     * Override the artifactTemplate's `{name}` template variable. Defaults to the `package.json`'s
+     * name, or if that doesn't exist, the current working directories name.
+     */
+    name?: string;
+    /**
+     * Root directory to ZIP when generating the sources ZIP.
+     *
+     * @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 Firefox. Patterns are relative to your
+     * `config.zip.sourcesRoot`.
+     *
+     * Hidden files, node_modules, and tests are ignored by default.
+     *
+     * @example
+     * [
+     *   "coverage", // Ignore the coverage directory in the `sourcesRoot`
+     * ]
+     */
+    excludeSources?: string[];
+  };
+
+  /**
+   * @deprecated Use `hooks.build.manifestGenerated` to modify your manifest instead. This option
+   *             will be removed in v1.0
+   *
+   * Transform the final manifest before it's written to the file system. Edit the `manifest`
+   * parameter directly, do not return a new object. Return values are ignored.
+   *
+   * @example
+   * defineConfig({
+   *   // Add a CSS-only content script.
+   *   transformManifest(manifest) {
+   *     manifest.content_scripts.push({
+   *       matches: ["*://google.com/*"],
+   *       css: ["content-scripts/some-example.css"],
+   *     });
+   *   }
+   * })
+   */
+  transformManifest?: (manifest: Manifest.WebExtensionManifest) => void;
+  analysis?: {
+    /**
+     * Explicitly include bundle analysis when running `wxt build`. This can be overridden by the
+     * command line `--analysis` option.
+     *
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * When running `wxt build --analyze` or setting `analysis.enabled` to true, customize how the
+     * bundle will be visualized. See
+     * [`rollup-plugin-visualizer`](https://github.com/btd/rollup-plugin-visualizer#how-to-use-generated-files)
+     * for more details.
+     *
+     * @default "treemap"
+     */
+    template?: PluginVisualizerOptions['template'];
+  };
+  /**
+   * Add additional paths to the `.wxt/tsconfig.json`. Use this instead of overwriting the `paths`
+   * in the root `tsconfig.json` if you want to add new paths.
+   *
+   * The key is the import alias and the value is either a relative path to the root directory or an absolute path.
+   *
+   * @example
+   * {
+   *   "testing": "src/utils/testing.ts"
+   * }
+   */
+  alias?: Record<string, string>;
+  /**
+   * Experimental settings - use with caution.
+   */
+  experimental?: {
+    /**
+     * Whether to use [`webextension-polyfill`](https://www.npmjs.com/package/webextension-polyfill)
+     * when importing `browser` from `wxt/browser`.
+     *
+     * When set to `false`, WXT will export the chrome global instead of the polyfill from
+     * `wxt/browser`.
+     *
+     * You should use `browser` to access the web extension APIs.
+     *
+     * @experimental This option will remain experimental until Manifest V2 is dead.
+     *
+     * @default true
+     * @example
+     * export default defineConfig({
+     *   experimental: {
+     *     includeBrowserPolyfill: false
+     *   }
+     * })
+     */
+    includeBrowserPolyfill?: boolean;
+  };
+  /**
+   * Config effecting dev mode only.
+   */
+  dev?: {
+    /**
+     * Controls whether a custom keyboard shortcut command, `Alt+R`, is added during dev mode to
+     * quickly reload the extension.
+     *
+     * If false, the shortcut is not added during development.
+     *
+     * If set to a custom string, you can override the key combo used. See
+     * [Chrome's command docs](https://developer.chrome.com/docs/extensions/reference/api/commands)
+     * for available options.
+     *
+     * @default "Alt+R"
+     */
+    reloadCommand?: string | false;
+  };
+  /**
+   * Project hooks for running logic during the build process.
+   */
+  hooks?: NestedHooks<WxtHooks>;
+}
+
+// TODO: Extract to @wxt/vite-builder and use module augmentation to include the vite field
+export interface InlineConfig {
+  /**
+   * Return custom Vite options from a function. See
+   * <https://vitejs.dev/config/shared-options.html>.
+   *
+   * [`root`](#root), [`configFile`](#configfile), and [`mode`](#mode) should be set in WXT's config
+   * instead of Vite's.
+   *
+   * This is a function because any vite plugins added need to be recreated for each individual
+   * build step, incase they have internal state causing them to fail when reused.
+   */
+  vite?: (env: ConfigEnv) => WxtViteConfig | Promise<WxtViteConfig>;
+}
+
+// TODO: Move into @wxt/vite-builder
+export type WxtViteConfig = Omit<
+  vite.UserConfig,
+  'root' | 'configFile' | 'mode'
+>;
+
+export interface BuildOutput {
+  manifest: Manifest.WebExtensionManifest;
+  publicAssets: OutputAsset[];
+  steps: BuildStepOutput[];
+}
+
+export type OutputFile = OutputChunk | OutputAsset;
+
+export interface OutputChunk {
+  type: 'chunk';
+  /**
+   * Relative, normalized path relative to the output directory.
+   *
+   * Ex: "content-scripts/overlay.js"
+   */
+  fileName: string;
+  /**
+   * Absolute, normalized paths to all dependencies this chunk relies on.
+   */
+  moduleIds: string[];
+}
+
+export interface OutputAsset {
+  type: 'asset';
+  /**
+   * Relative, normalized path relative to the output directory.
+   *
+   * Ex: "icons/16.png"
+   */
+  fileName: string;
+}
+
+export interface BuildStepOutput {
+  entrypoints: EntrypointGroup;
+  chunks: OutputFile[];
+}
+
+export interface WxtDevServer
+  extends Omit<WxtBuilderServer, 'listen' | 'close'>,
+    ServerInfo {
+  /**
+   * Stores the current build output of the server.
+   */
+  currentOutput: BuildOutput | undefined;
+  /**
+   * Start the server.
+   */
+  start(): Promise<void>;
+  /**
+   * Stop the server.
+   */
+  stop(): Promise<void>;
+  /**
+   * Close the browser, stop the server, rebuild the entire extension, and start the server again.
+   */
+  restart(): Promise<void>;
+  /**
+   * Transform the HTML for dev mode.
+   */
+  transformHtml(
+    url: string,
+    html: string,
+    originalUrl?: string | undefined,
+  ): Promise<string>;
+  /**
+   * Tell the extension to reload by running `browser.runtime.reload`.
+   */
+  reloadExtension: () => void;
+  /**
+   * Tell an extension page to reload.
+   *
+   * The path is the bundle path, not the input paths, so if the input paths is
+   * "src/options/index.html", you would pass "options.html" because that's where it is written to
+   * in the dist directory, and where it's available at in the actual extension.
+   *
+   * @example
+   * server.reloadPage("popup.html")
+   * server.reloadPage("sandbox.html")
+   */
+  reloadPage: (path: string) => void;
+  /**
+   * Tell the extension to restart a content script.
+   *
+   * @param contentScript The manifest definition for a content script
+   */
+  reloadContentScript: (
+    contentScript: Omit<Scripting.RegisteredContentScript, 'id'>,
+  ) => void;
+  /**
+   * Grab the latest runner config and restart the browser.
+   */
+  restartBrowser: () => void;
+}
+
+export type TargetBrowser = string;
+export type TargetManifestVersion = 2 | 3;
+
+export type UserConfig = Omit<InlineConfig, 'configFile'>;
+
+export interface Logger {
+  debug(...args: any[]): void;
+  log(...args: any[]): void;
+  info(...args: any[]): void;
+  warn(...args: any[]): void;
+  error(...args: any[]): void;
+  fatal(...args: any[]): void;
+  success(...args: any[]): void;
+  level: LogLevel;
+}
+
+export interface BaseEntrypointOptions {
+  include?: TargetBrowser[];
+  exclude?: TargetBrowser[];
+}
+
+export interface BaseEntrypoint {
+  /**
+   * The entrypoint's name. This is the filename or dirname without the type suffix.
+   *
+   * Examples:
+   * - `popup.html` &rarr; `popup`
+   * - `options/index.html` &rarr; `options`
+   * - `named.sandbox.html` &rarr; `named`
+   * - `named.sandbox/index.html` &rarr; `named`
+   * - `sandbox.html` &rarr; `sandbox`
+   * - `sandbox/index.html` &rarr; `sandbox`
+   * - `overlay.content.ts` &rarr; `overlay`
+   * - `overlay.content/index.ts` &rarr; `overlay`
+   *
+   * The name is used when generating an output file:
+   * `<entrypoint.outputDir>/<entrypoint.name>.<ext>`
+   */
+  name: string;
+  /**
+   * Absolute path to the entrypoint's input file.
+   */
+  inputPath: string;
+  /**
+   * Absolute path to the entrypoint's output directory. Can be the`InternalConfg.outDir` or a
+   * subdirectory of it.
+   */
+  outputDir: string;
+  options: BaseEntrypointOptions;
+  skipped: boolean;
+}
+
+export interface GenericEntrypoint extends BaseEntrypoint {
+  type:
+    | 'sandbox'
+    | 'bookmarks'
+    | 'history'
+    | 'newtab'
+    | 'sidepanel'
+    | 'devtools'
+    | 'unlisted-page'
+    | 'unlisted-script'
+    | 'unlisted-style'
+    | 'content-script-style';
+}
+
+export interface BackgroundEntrypoint extends BaseEntrypoint {
+  type: 'background';
+  options: {
+    persistent?: boolean;
+    type?: 'module';
+  } & BaseEntrypointOptions;
+}
+
+export interface ContentScriptEntrypoint extends BaseEntrypoint {
+  type: 'content-script';
+  options: Omit<ContentScriptDefinition, 'main'> & BaseEntrypointOptions;
+}
+
+export interface PopupEntrypoint extends BaseEntrypoint {
+  type: 'popup';
+  options: {
+    /**
+     * Defaults to "browser_action" to be equivalent to MV3's "action" key
+     */
+    mv2Key?: 'browser_action' | 'page_action';
+    defaultIcon?: Record<string, string>;
+    defaultTitle?: string;
+    browserStyle?: boolean;
+  } & BaseEntrypointOptions;
+}
+
+export interface OptionsEntrypoint extends BaseEntrypoint {
+  type: 'options';
+  options: {
+    openInTab?: boolean;
+    browserStyle?: boolean;
+    chromeStyle?: boolean;
+  } & BaseEntrypointOptions;
+}
+
+export type Entrypoint =
+  | GenericEntrypoint
+  | BackgroundEntrypoint
+  | ContentScriptEntrypoint
+  | PopupEntrypoint
+  | OptionsEntrypoint;
+
+export type EntrypointGroup = Entrypoint | Entrypoint[];
+
+export type OnContentScriptStopped = (cb: () => void) => void;
+
+export type ContentScriptDefinition =
+  | ContentScriptIsolatedWorldDefinition
+  | ContentScriptMainWorldDefinition;
+
+export interface ContentScriptIsolatedWorldDefinition
+  extends ContentScriptBaseDefinition {
+  /**
+   * See https://developer.chrome.com/docs/extensions/develop/concepts/content-scripts#isolated_world
+   * @default "ISOLATED"
+   */
+  world?: 'ISOLATED';
+  /**
+   * Main function executed when the content script is loaded.
+   */
+  main(ctx: ContentScriptContext): void | Promise<void>;
+}
+
+export interface ContentScriptMainWorldDefinition
+  extends ContentScriptBaseDefinition {
+  /**
+   * See https://developer.chrome.com/docs/extensions/develop/concepts/content-scripts#isolated_world
+   */
+  world: 'MAIN';
+  /**
+   * Main function executed when the content script is loaded.
+   */
+  main(): void | Promise<void>;
+}
+
+export interface ContentScriptBaseDefinition extends ExcludableEntrypoint {
+  matches: PerBrowserOption<Manifest.ContentScript['matches']>;
+  /**
+   * See https://developer.chrome.com/docs/extensions/mv3/content_scripts/
+   * @default "documentIdle"
+   */
+  runAt?: PerBrowserOption<Manifest.ContentScript['run_at']>;
+  /**
+   * See https://developer.chrome.com/docs/extensions/mv3/content_scripts/
+   * @default false
+   */
+  matchAboutBlank?: PerBrowserOption<
+    Manifest.ContentScript['match_about_blank']
+  >;
+  /**
+   * See https://developer.chrome.com/docs/extensions/mv3/content_scripts/
+   * @default []
+   */
+  excludeMatches?: PerBrowserOption<Manifest.ContentScript['exclude_matches']>;
+  /**
+   * See https://developer.chrome.com/docs/extensions/mv3/content_scripts/
+   * @default []
+   */
+  includeGlobs?: PerBrowserOption<Manifest.ContentScript['include_globs']>;
+  /**
+   * See https://developer.chrome.com/docs/extensions/mv3/content_scripts/
+   * @default []
+   */
+  excludeGlobs?: PerBrowserOption<Manifest.ContentScript['exclude_globs']>;
+  /**
+   * See https://developer.chrome.com/docs/extensions/mv3/content_scripts/
+   * @default false
+   */
+  allFrames?: PerBrowserOption<Manifest.ContentScript['all_frames']>;
+  /**
+   * See https://developer.chrome.com/docs/extensions/mv3/content_scripts/
+   * @default false
+   */
+  matchOriginAsFallback?: PerBrowserOption<boolean>;
+  /**
+   * Customize how imported/generated styles are injected with the content script. Regardless of the
+   * mode selected, CSS will always be built and included in the output directory.
+   *
+   * - `"manifest"` - Include the CSS in the manifest, under the content script's `css` array.
+   * - `"manual"` - Exclude the CSS from the manifest. You are responsible for manually loading it
+   *   onto the page. Use `browser.runtime.getURL("content-scripts/<name>.css")` to get the file's
+   *   URL
+   * - `"ui"` - Exclude the CSS from the manifest. CSS will be automatically added to your UI when
+   *   calling `createContentScriptUi`
+   *
+   * @default "manifest"
+   */
+  cssInjectionMode?: PerBrowserOption<'manifest' | 'manual' | 'ui'>;
+}
+
+export interface BackgroundDefinition extends ExcludableEntrypoint {
+  type?: PerBrowserOption<'module'>;
+  persistent?: PerBrowserOption<boolean>;
+  main(): void;
+}
+
+export interface UnlistedScriptDefinition extends ExcludableEntrypoint {
+  /**
+   * Main function executed when the unlisted script is ran.
+   */
+  main(): void | Promise<void>;
+}
+
+export type PerBrowserOption<T> = T | { [browser: TargetBrowser]: T };
+
+export interface ExcludableEntrypoint {
+  /**
+   * List of target browsers to include this entrypoint in. Defaults to being included in all
+   * builds. Cannot be used with `exclude`. You must choose one of the two options.
+   *
+   * @default undefined
+   */
+  include?: TargetBrowser[];
+  /**
+   * List of target browsers to exclude this entrypoint from. Cannot be used with `include`. You
+   * must choose one of the two options.
+   *
+   * @default undefined
+   */
+  exclude?: TargetBrowser[];
+}
+
+/**
+ * Manifest customization available in the `wxt.config.ts` file. You cannot configure entrypoints
+ * here, they are configured inline.
+ */
+export type UserManifest = Partial<
+  Omit<
+    Manifest.WebExtensionManifest,
+    | 'background'
+    | 'chrome_url_overrides'
+    | 'devtools_page'
+    | 'manifest_version'
+    | 'options_page'
+    | 'options_ui'
+    | 'sandbox'
+    | 'sidepanel'
+    | 'sidebar_action'
+  >
+>;
+
+export type UserManifestFn = (
+  env: ConfigEnv,
+) => UserManifest | Promise<UserManifest>;
+
+export interface ConfigEnv {
+  mode: string;
+  command: 'build' | 'serve';
+  /**
+   * Browser passed in from the CLI
+   */
+  browser: TargetBrowser;
+  /**
+   * Manifest version passed in from the CLI
+   */
+  manifestVersion: 2 | 3;
+}
+
+/**
+ * Configure how the browser starts up.
+ */
+export interface ExtensionRunnerConfig {
+  /**
+   * Whether or not to open the browser with the extension installed in dev mode.
+   *
+   * @default false
+   */
+  disabled?: boolean;
+  /**
+   * @see https://extensionworkshop.com/documentation/develop/web-ext-command-reference/#browser-console
+   */
+  openConsole?: boolean;
+  /**
+   * @see https://extensionworkshop.com/documentation/develop/web-ext-command-reference/#devtools
+   */
+  openDevtools?: boolean;
+  /**
+   * List of browser names and the binary that should be used to open the browser.
+   *
+   * @see https://extensionworkshop.com/documentation/develop/web-ext-command-reference/#chromium-binary
+   * @see https://extensionworkshop.com/documentation/develop/web-ext-command-reference/#firefox
+   */
+  binaries?: Record<string, string>;
+  /**
+   * @see https://extensionworkshop.com/documentation/develop/web-ext-command-reference/#firefox-profile
+   */
+  firefoxProfile?: string;
+  /**
+   * @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
+   */
+  firefoxPrefs?: Record<string, string>;
+  /**
+   * @see https://extensionworkshop.com/documentation/develop/web-ext-command-reference/#args
+   */
+  firefoxArgs?: string[];
+  /**
+   * @see https://extensionworkshop.com/documentation/develop/web-ext-command-reference/#args
+   */
+  chromiumArgs?: string[];
+  /**
+   * @see https://extensionworkshop.com/documentation/develop/web-ext-command-reference/#start-url
+   */
+  startUrls?: string[];
+}
+
+export interface WxtBuilder {
+  /**
+   * Name of tool used to build. Ex: "Vite" or "Webpack".
+   */
+  name: string;
+  /**
+   * Version of tool used to build. Ex: "5.0.2"
+   */
+  version: string;
+  /**
+   * Build a single entrypoint group. This is effectively one of the multiple "steps" during the
+   * build process.
+   */
+  build(group: EntrypointGroup): Promise<BuildStepOutput>;
+  /**
+   * Start a dev server at the provided port.
+   */
+  createServer(info: ServerInfo): Promise<WxtBuilderServer>;
+}
+
+export interface WxtBuilderServer {
+  /**
+   * Start the server.
+   */
+  listen(): Promise<void>;
+  /**
+   * Stop the server.
+   */
+  close(): Promise<void>;
+  /**
+   * Transform the HTML for dev mode.
+   */
+  transformHtml(
+    url: string,
+    html: string,
+    originalUrl?: string | undefined,
+  ): Promise<string>;
+  /**
+   * The web socket server used to communicate with the extension.
+   */
+  ws: {
+    /**
+     * Send a message via the server's websocket, with an optional payload.
+     *
+     * @example
+     * ws.send("wxt:reload-extension");
+     * ws.send("wxt:reload-content-script", { ... });
+     */
+    send(message: string, payload?: any): void;
+    /**
+     * Listen for messages over the server's websocket.
+     */
+    on(message: string, cb: (payload: any) => void): void;
+  };
+  /**
+   * Chokidar file watcher instance.
+   */
+  watcher: FSWatcher;
+}
+
+export interface ServerInfo {
+  /**
+   * Ex: `3000`
+   */
+  port: number;
+  /**
+   * Ex: `"localhost"`
+   */
+  hostname: string;
+  /**
+   * Ex: `"http://localhost:3000"`
+   */
+  origin: string;
+}
+
+export type HookResult = Promise<void> | void;
+
+export interface WxtHooks {
+  /**
+   * Called after WXT initialization, when the WXT instance is ready to work.
+   * @param wxt The configured WXT object
+   * @returns Promise
+   */
+  ready: (wxt: Wxt) => HookResult;
+  /**
+   * Called before the build is started in both dev mode and build mode.
+   *
+   * @param wxt The configured WXT object
+   */
+  'build:before': (wxt: Wxt) => HookResult;
+  /**
+   * Called once the build process has finished.
+   * @param wxt The configured WXT object
+   * @param output The results of the build
+   */
+  'build:done': (wxt: Wxt, output: Readonly<BuildOutput>) => HookResult;
+  /**
+   * Called once the manifest has been generated. Used to transform the manifest by reference before
+   * it is written to the output directory.
+   * @param wxt The configured WXT object
+   * @param manifest The manifest that was generated
+   */
+  'build:manifestGenerated': (
+    wxt: Wxt,
+    manifest: Manifest.WebExtensionManifest,
+  ) => HookResult;
+  /**
+   * Called once all entrypoints have been loaded from the `entrypointsDir`.
+   * @param wxt The configured WXT object
+   * @param entrypoints The list of entrypoints to be built
+   */
+  'entrypoints:resolved': (wxt: Wxt, entrypoints: Entrypoint[]) => HookResult;
+  /**
+   * Called once all entrypoints have been grouped into their build groups.
+   * @param wxt The configured WXT object
+   * @param entrypoints The list of groups to build in each build step
+   */
+  'entrypoints:grouped': (wxt: Wxt, groups: EntrypointGroup[]) => HookResult;
+}
+
+export interface Wxt {
+  config: ResolvedConfig;
+  hooks: Hookable<WxtHooks>;
+  /**
+   * Alias for config.logger
+   */
+  logger: Logger;
+  /**
+   * Reload config file and update the `config` field with the result.
+   */
+  reloadConfig: () => Promise<void>;
+}
+
+export interface ResolvedConfig {
+  root: string;
+  srcDir: string;
+  publicDir: string;
+  wxtDir: string;
+  typesDir: string;
+  entrypointsDir: string;
+  filterEntrypoints?: Set<string>;
+  outBaseDir: string;
+  outDir: string;
+  debug: boolean;
+  mode: string;
+  command: 'build' | 'serve';
+  browser: TargetBrowser;
+  manifestVersion: TargetManifestVersion;
+  env: ConfigEnv;
+  logger: Logger;
+  imports: false | Partial<UnimportOptions>;
+  manifest: UserManifest;
+  fsCache: FsCache;
+  server?: WxtDevServer;
+  runnerConfig: C12ResolvedConfig<ExtensionRunnerConfig>;
+  zip: {
+    name?: string;
+    artifactTemplate: string;
+    sourcesTemplate: string;
+    includeSources: string[];
+    excludeSources: string[];
+    sourcesRoot: string;
+  };
+  transformManifest: (manifest: Manifest.WebExtensionManifest) => void;
+  analysis: {
+    enabled: boolean;
+    template: NonNullable<PluginVisualizerOptions['template']>;
+  };
+  userConfigMetadata: Omit<C12ResolvedConfig<UserConfig>, 'config'>;
+  /**
+   * Import aliases to absolute paths.
+   */
+  alias: Record<string, string>;
+  experimental: {
+    includeBrowserPolyfill: boolean;
+  };
+  builder: WxtBuilder;
+  dev: {
+    reloadCommand: string | false;
+  };
+  hooks: Partial<WxtHooks>;
+}
+
+export interface FsCache {
+  set(key: string, value: string): Promise<void>;
+  get(key: string): Promise<string | undefined>;
+}
+
+export interface ExtensionRunner {
+  openBrowser(): Promise<void>;
+  closeBrowser(): Promise<void>;
+}
+
+export type VirtualEntrypointType =
+  | 'content-script-main-world'
+  | 'content-script-isolated-world'
+  | 'background'
+  | 'unlisted-script';
@@ -1,80 +0,0 @@
-import {
-  WxtDevServer,
-  Logger,
-  TargetBrowser,
-  TargetManifestVersion,
-  UserManifest,
-  ExtensionRunnerConfig,
-  ConfigEnv,
-  UserConfig,
-  WxtBuilder,
-} from './external';
-import { UnimportOptions } from 'unimport';
-import { ResolvedConfig } from 'c12';
-import type { Manifest } from '~/browser';
-import type { PluginVisualizerOptions } from 'rollup-plugin-visualizer';
-
-export interface InternalConfig {
-  root: string;
-  srcDir: string;
-  publicDir: string;
-  wxtDir: string;
-  typesDir: string;
-  entrypointsDir: string;
-  filterEntrypoints?: Set<string>;
-  outBaseDir: string;
-  outDir: string;
-  debug: boolean;
-  mode: string;
-  command: 'build' | 'serve';
-  browser: TargetBrowser;
-  manifestVersion: TargetManifestVersion;
-  env: ConfigEnv;
-  logger: Logger;
-  imports: false | Partial<UnimportOptions>;
-  manifest: UserManifest;
-  fsCache: FsCache;
-  server?: WxtDevServer;
-  runnerConfig: ResolvedConfig<ExtensionRunnerConfig>;
-  zip: {
-    name?: string;
-    artifactTemplate: string;
-    sourcesTemplate: string;
-    includeSources: string[];
-    excludeSources: string[];
-    sourcesRoot: string;
-  };
-  transformManifest: (manifest: Manifest.WebExtensionManifest) => void;
-  analysis: {
-    enabled: boolean;
-    template: NonNullable<PluginVisualizerOptions['template']>;
-  };
-  userConfigMetadata: Omit<ResolvedConfig<UserConfig>, 'config'>;
-  /**
-   * Import aliases to absolute paths.
-   */
-  alias: Record<string, string>;
-  experimental: {
-    includeBrowserPolyfill: boolean;
-  };
-  builder: WxtBuilder;
-  dev: {
-    reloadCommand: string | false;
-  };
-}
-
-export interface FsCache {
-  set(key: string, value: string): Promise<void>;
-  get(key: string): Promise<string | undefined>;
-}
-
-export interface ExtensionRunner {
-  openBrowser(config: InternalConfig): Promise<void>;
-  closeBrowser(): Promise<void>;
-}
-
-export type VirtualEntrypointType =
-  | 'content-script-main-world'
-  | 'content-script-isolated-world'
-  | 'background'
-  | 'unlisted-script';
@@ -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' {
@@ -23,6 +23,6 @@
    "@types/react-dom": "^18.2.18",
    "@vitejs/plugin-react": "^4.2.1",
    "typescript": "^5.3.3",
-    "wxt": "^0.15.0"
+    "wxt": "^0.16.0"
  }
 }
@@ -20,6 +20,6 @@
  "devDependencies": {
    "typescript": "^5.3.3",
    "vite-plugin-solid": "^2.8.0",
-    "wxt": "^0.15.0"
+    "wxt": "^0.16.0"
  }
 }
@@ -20,6 +20,6 @@
    "svelte-check": "^3.6.2",
    "tslib": "^2.6.2",
    "typescript": "^5.3.3",
-    "wxt": "^0.15.0"
+    "wxt": "^0.16.0"
  }
 }
@@ -16,6 +16,6 @@
  },
  "devDependencies": {
    "typescript": "^5.3.3",
-    "wxt": "^0.15.0"
+    "wxt": "^0.16.0"
  }
 }
@@ -21,6 +21,6 @@
    "@vitejs/plugin-vue": "^5.0.1",
    "typescript": "^5.3.3",
    "vue-tsc": "^1.8.27",
-    "wxt": "^0.15.0"
+    "wxt": "^0.16.0"
  }
 }
Author	SHA1	Message	Date
GitHub Actions	dd05ed4d4c	chore(release): v0.16.3	2024-02-04 23:41:38 +00:00
Aaron	21636defda	feat: Hooks (#419 ) Deprecated `transformManifest` since a hook now exists for it.	2024-02-04 17:37:31 -06:00
Aaron	bb022646e3	chore: Register global `wxt` instance (#418 )	2024-02-04 16:34:10 -06:00
Aaron Klinker	37ad2c7ceb	fix(init): Use `ungh` to prevent rate limits when loading templates	2024-02-04 14:11:41 -06:00
dependabot[bot]	b992631e00	chore(deps): bump rollup-plugin-visualizer from 5.9.3 to 5.12.0 (#412 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2024-02-04 03:14:47 -06:00
dependabot[bot]	35a5cc6717	chore(deps-dev): bump typescript from 5.3.2 to 5.3.3 (#409 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2024-02-04 03:14:15 -06:00
dependabot[bot]	310b56fe5d	chore(deps): bump defu from 6.1.3 to 6.1.4 (#413 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2024-02-04 03:13:28 -06:00
dependabot[bot]	148234382e	chore(deps): bump @types/webextension-polyfill from 0.10.5 to 0.10.7 (#410 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2024-02-04 03:13:03 -06:00
dependabot[bot]	c1a97b77b0	chore(deps): bump actions/checkout from 3 to 4 (#407 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2024-02-04 03:11:32 -06:00
Chen Hua	557ccb4854	docs: fix typo of opinionated (#416 )	2024-02-04 03:11:03 -06:00
Chen Hua	83e7e8aab9	docs: Fix typo of intuitive (#415 )	2024-02-04 03:10:20 -06:00
dependabot[bot]	7bf490c59d	chore(deps-dev): bump happy-dom from 12.10.3 to 13.3.8 (#411 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2024-02-04 03:08:24 -06:00
dependabot[bot]	9670babdbb	chore(deps): bump codecov/codecov-action from 3 to 4 (#408 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2024-02-04 03:06:11 -06:00
Florian Metz	42dfc2d5cf	chore: Add dependabot for github actions (#404 )	2024-02-03 16:32:46 -06:00
GitHub Actions	1527f0e275	chore(release): v0.16.2	2024-02-03 21:02:28 +00:00
Aaron	66bd957ee0	fix: Don't crash background service worker when using `import.meta.url` (#402 )	2024-02-03 14:57:34 -06:00
GitHub Actions	72e3c5baa2	chore(release): v0.16.1	2024-02-03 19:57:51 +00:00
Aaron Klinker	9318346ab3	fix: Don't require config to run `wxt submit init`	2024-02-03 13:52:15 -06:00
Aaron Klinker	1d6aceab0a	Update changelog	2024-02-03 11:05:16 -06:00
Florian Metz	c1b5a9d270	docs: Add premid extension to homepage (#399 )	2024-02-02 22:46:46 -06:00
Aaron Klinker	f0b2a12724	chore(templates): Upgrade to wxt `^0.16.0`	2024-02-02 16:20:24 -06:00
Aaron Klinker	c45677ed48	Update changelog	2024-02-02 16:19:33 -06:00
GitHub Actions	7a3f075e21	chore(release): v0.16.0	2024-02-02 16:55:11 +00:00
Aaron Klinker	1e12ce2a0d	docs: Document how to opt into ESM	2024-02-02 10:48:00 -06:00
Aaron	eca30296a7	feat!: ESM background support (#398 ) 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.	2024-02-02 10:17:43 -06:00
dependabot[bot]	41fa320815	chore(deps-dev): bump @vitest/coverage-v8 from 1.0.1 to 1.2.2 (#397 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2024-02-02 07:07:50 -06:00
dependabot[bot]	873c24fa50	chore(deps-dev): bump p-map from 7.0.0 to 7.0.1 (#396 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2024-02-02 07:06:51 -06:00
dependabot[bot]	d92db5ba8f	chore(deps-dev): bump lint-staged from 15.2.0 to 15.2.1 (#395 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2024-02-02 07:06:31 -06:00
dependabot[bot]	1a6fe33f97	chore(deps): bump fast-glob from 3.3.1 to 3.3.2 (#394 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2024-02-02 07:05:42 -06:00
GitHub Actions	2db4ea77a9	chore(release): v0.15.4	2024-01-31 17:42:07 +00:00
Aaron	ba5349ccaf	fix(submit): Load `.env.submit` automatically when running `wxt submit` and `wxt submit init` (#391 )	2024-01-31 11:38:11 -06:00
GitHub Actions	addb689de9	chore(release): v0.15.3	2024-01-31 14:59:26 +00:00
Aaron	2af8d28b82	fix(dev): Reload `<name>/index.html` entrypoints properly on save (#390 )	2024-01-31 08:50:23 -06:00
Aaron Klinker	ddbc66813e	Update changelog	2024-01-30 13:04:32 -06:00
GitHub Actions	0c8fc013a8	chore(release): v0.15.2	2024-01-30 19:01:54 +00:00
Aaron	26e30aaae9	feat: Add `submit` command (#370 )	2024-01-30 12:55:17 -06:00
Nenad Novaković	6557dfe430	fix(dev): Resolve `script` and `link` aliases (#387 ) Co-authored-by: Aaron Klinker <aaronklinker1@gmail.com>	2024-01-30 12:05:31 -06:00
Aaron Klinker	9cee9eefb4	Update changelog	2024-01-29 14:12:27 -06:00