wxt 0.0.2 → 0.1.1-alpha1

package/dist/index.js

@@ -8,25 +8,27 @@ import { consola } from "consola";
 import createJITI from "jiti";
 import transform from "jiti/dist/babel";
 import { resolve } from "path";
-import { scanExports } from "unimport";
+import { createUnimport } from "unimport";
+import fs from "fs-extra";
 async function importTsFile(root, path5) {
-  const clientImports = await scanExports(
+  const unimport2 = createUnimport({});
+  await unimport2.scanImportsFromFile(
     resolve(root, "node_modules/wxt/dist/client.js")
   );
+  const text = await fs.readFile(path5, "utf-8");
+  const res = await unimport2.injectImports(text, path5);
+  const transformedText = res.code;
   const jiti = createJITI(__filename, {
     cache: false,
     esmResolve: true,
     interopDefault: true,
+    alias: {
+      "webextension-polyfill": "wxt"
+    },
     transform(opts) {
+      if (opts.filename === path5)
+        opts.source = transformedText;
       opts.source = opts.source.replace(/^import ['"].*\.css['"];?$/gm, "");
-      opts.source = opts.source.replace(
-        /^import\s+.*\s+from ['"]webextension-polyfill['"];?$/gm,
-        ""
-      );
-      if (opts.filename === path5) {
-        const imports = clientImports.map((i) => `import { ${i.name} } from "${i.from}";`).join("\n") + "\n";
-        opts.source = imports + opts.source;
-      }
       return transform(opts);
     }
   });
@@ -209,7 +211,7 @@ function download(config) {
 
 // src/core/vite-plugins/multipageMove.ts
 import { dirname as dirname2, extname, resolve as resolve4 } from "node:path";
-import fs, { ensureDir } from "fs-extra";
+import fs2, { ensureDir } from "fs-extra";
 function multipageMove(entrypoints, config) {
   return {
     name: "wxt:multipage-move",
@@ -237,7 +239,7 @@ function multipageMove(entrypoints, config) {
         const oldAbsPath = resolve4(config.outDir, oldBundlePath);
         const newAbsPath = resolve4(config.outDir, newBundlePath);
         await ensureDir(dirname2(newAbsPath));
-        await fs.move(oldAbsPath, newAbsPath, { overwrite: true });
+        await fs2.move(oldAbsPath, newAbsPath, { overwrite: true });
         const renamedChunk = {
           ...bundle[oldBundlePath],
           fileName: newBundlePath
@@ -250,7 +252,7 @@ function multipageMove(entrypoints, config) {
 }
 
 // src/core/vite-plugins/unimport.ts
-import { createUnimport } from "unimport";
+import { createUnimport as createUnimport2 } from "unimport";
 
 // src/core/utils/auto-imports.ts
 import { mergeConfig as mergeConfig2 } from "vite";
@@ -274,7 +276,7 @@ function getUnimportOptions(config) {
 // src/core/vite-plugins/unimport.ts
 function unimport(config) {
   const options = getUnimportOptions(config);
-  const unimport2 = createUnimport(options);
+  const unimport2 = createUnimport2(options);
   return {
     name: "wxt:unimport",
     async config() {
@@ -287,7 +289,7 @@ function unimport(config) {
 }
 
 // src/core/vite-plugins/virtualEntrypoint.ts
-import fs2 from "fs-extra";
+import fs3 from "fs-extra";
 import { resolve as resolve5 } from "path";
 function virtualEntrypoin(type, config) {
   const virtualId = `virtual:wxt-${type}?`;
@@ -305,7 +307,7 @@ function virtualEntrypoin(type, config) {
       if (!id.startsWith(resolvedVirtualId))
         return;
       const inputPath = id.replace(resolvedVirtualId, "");
-      const template = await fs2.readFile(
+      const template = await fs3.readFile(
         resolve5(
           config.root,
           `node_modules/wxt/dist/virtual-modules/${type}-entrypoint.js`
@@ -318,7 +320,7 @@ function virtualEntrypoin(type, config) {
 }
 
 // src/core/utils/createFsCache.ts
-import fs3, { ensureDir as ensureDir2 } from "fs-extra";
+import fs4, { ensureDir as ensureDir2 } from "fs-extra";
 import { dirname as dirname3, resolve as resolve6 } from "path";
 function createFsCache(wxtDir) {
   const getPath = (key) => resolve6(wxtDir, "cache", encodeURIComponent(key));
@@ -326,12 +328,12 @@ function createFsCache(wxtDir) {
     async set(key, value) {
       const path5 = getPath(key);
       await ensureDir2(dirname3(path5));
-      await fs3.writeFile(path5, value, "utf-8");
+      await fs4.writeFile(path5, value, "utf-8");
     },
     async get(key) {
       const path5 = getPath(key);
       try {
-        return await fs3.readFile(path5, "utf-8");
+        return await fs4.readFile(path5, "utf-8");
       } catch {
         return void 0;
       }
@@ -470,15 +472,246 @@ async function getInternalConfig(config, command) {
   return finalConfig;
 }
 
+// src/index.ts
+import pc3 from "picocolors";
+import * as vite6 from "vite";
+
+// src/core/utils/arrays.ts
+function every(array, predicate) {
+  for (let i = 0; i < array.length; i++)
+    if (!predicate(array[i], i))
+      return false;
+  return true;
+}
+
+// src/core/utils/detectDevChanges.ts
+function detectDevChanges(changedFiles, currentOutput) {
+  if (currentOutput == null)
+    return { type: "no-change" };
+  const changedSteps = new Set(
+    changedFiles.flatMap(
+      (changedFile) => findEffectedSteps(changedFile, currentOutput)
+    )
+  );
+  if (changedSteps.size === 0)
+    return { type: "no-change" };
+  const unchangedOutput = {
+    manifest: currentOutput.manifest,
+    steps: [],
+    publicAssets: []
+  };
+  const changedOutput = {
+    manifest: currentOutput.manifest,
+    steps: [],
+    publicAssets: []
+  };
+  for (const step of currentOutput.steps) {
+    if (changedSteps.has(step)) {
+      changedOutput.steps.push(step);
+    } else {
+      unchangedOutput.steps.push(step);
+    }
+  }
+  for (const asset of currentOutput.publicAssets) {
+    if (changedSteps.has(asset)) {
+      changedOutput.publicAssets.push(asset);
+    } else {
+      unchangedOutput.publicAssets.push(asset);
+    }
+  }
+  const isOnlyHtmlChanges = changedFiles.length > 0 && every(changedFiles, ([_, file]) => file.endsWith(".html"));
+  if (isOnlyHtmlChanges) {
+    return {
+      type: "html-reload",
+      cachedOutput: unchangedOutput,
+      rebuildGroups: changedOutput.steps.map((step) => step.entrypoints)
+    };
+  }
+  const isOnlyContentScripts = changedOutput.steps.length > 0 && every(
+    changedOutput.steps.flatMap((step) => step.entrypoints),
+    (entry) => entry.type === "content-script"
+  );
+  if (isOnlyContentScripts) {
+    return {
+      type: "content-script-reload",
+      cachedOutput: unchangedOutput,
+      changedSteps: changedOutput.steps,
+      rebuildGroups: changedOutput.steps.map((step) => step.entrypoints)
+    };
+  }
+  return {
+    type: "extension-reload",
+    cachedOutput: unchangedOutput,
+    rebuildGroups: changedOutput.steps.map((step) => step.entrypoints)
+  };
+}
+function findEffectedSteps(changedFile, currentOutput) {
+  const changes = [];
+  const changedPath = changedFile[1];
+  const isChunkEffected = (chunk) => (
+    // If it's an HTML file with the same path, is is effected because HTML files need to be pre-rendered
+    // TODO: use bundle path to support `<name>/index.html`?
+    chunk.type === "asset" && changedPath.endsWith(chunk.fileName) || // If it's a chunk that depends on the changed file, it is effected
+    chunk.type === "chunk" && chunk.moduleIds.includes(changedPath)
+  );
+  for (const step of currentOutput.steps) {
+    const effectedChunk = step.chunks.find((chunk) => isChunkEffected(chunk));
+    if (effectedChunk)
+      changes.push(step);
+  }
+  const effectedAsset = currentOutput.publicAssets.find(
+    (chunk) => isChunkEffected(chunk)
+  );
+  if (effectedAsset)
+    changes.push(effectedAsset);
+  return changes;
+}
+
+// src/index.ts
+import { Mutex } from "async-mutex";
+import { consola as consola3 } from "consola";
+import { relative as relative6 } from "node:path";
+
+// src/core/build/buildEntrypoints.ts
+import * as vite3 from "vite";
+
+// src/core/utils/removeEmptyDirs.ts
+import fs5 from "fs-extra";
+import path3 from "path";
+async function removeEmptyDirs(dir) {
+  const files = await fs5.readdir(dir);
+  for (const file of files) {
+    const filePath = path3.join(dir, file);
+    const stats = await fs5.stat(filePath);
+    if (stats.isDirectory()) {
+      await removeEmptyDirs(filePath);
+    }
+  }
+  try {
+    await fs5.rmdir(dir);
+  } catch {
+  }
+}
+
+// src/core/build/buildEntrypoints.ts
+import glob from "fast-glob";
+import fs6 from "fs-extra";
+import { dirname as dirname4, resolve as resolve8 } from "path";
+async function buildEntrypoints(groups, config) {
+  const steps = [];
+  for (const group of groups) {
+    const step = Array.isArray(group) ? await buildMultipleEntrypoints(group, config) : await buildSingleEntrypoint(group, config);
+    steps.push(step);
+  }
+  const publicAssets = await copyPublicDirectory(config);
+  await removeEmptyDirs(config.outDir);
+  return { publicAssets, steps };
+}
+async function buildSingleEntrypoint(entrypoint, config) {
+  const isVirtual = ["background", "content-script"].includes(entrypoint.type);
+  const entry = isVirtual ? `virtual:wxt-${entrypoint.type}?${entrypoint.inputPath}` : entrypoint.inputPath;
+  const libMode = {
+    build: {
+      lib: {
+        entry,
+        formats: ["iife"],
+        name: entrypoint.name,
+        fileName: entrypoint.name
+      },
+      rollupOptions: {
+        output: {
+          // There's only a single output for this build, so we use the desired bundle path for the
+          // entry output (like "content-scripts/overlay.js")
+          entryFileNames: getEntrypointBundlePath(
+            entrypoint,
+            config.outDir,
+            ".js"
+          ),
+          // Output content script CSS to assets/ with a hash to prevent conflicts. Defaults to
+          // "[name].[ext]" in lib mode, which usually results in "style.css". That means multiple
+          // content scripts with styles would overwrite each other if it weren't changed below.
+          assetFileNames: `assets/${entrypoint.name}.[ext]`
+        }
+      }
+    }
+  };
+  const entryConfig = vite3.mergeConfig(
+    libMode,
+    config.vite
+  );
+  const result = await vite3.build(entryConfig);
+  return {
+    entrypoints: entrypoint,
+    chunks: getBuildOutputChunks(result)
+  };
+}
+async function buildMultipleEntrypoints(entrypoints, config) {
+  const multiPage = {
+    plugins: [multipageMove(entrypoints, config)],
+    build: {
+      rollupOptions: {
+        input: entrypoints.reduce((input, entry) => {
+          input[entry.name] = entry.inputPath;
+          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",
+          // We can't control the "name", so we need a hash to prevent conflicts
+          assetFileNames: "assets/[name]-[hash].[ext]"
+        }
+      }
+    }
+  };
+  const entryConfig = vite3.mergeConfig(
+    multiPage,
+    config.vite
+  );
+  const result = await vite3.build(entryConfig);
+  return {
+    entrypoints,
+    chunks: getBuildOutputChunks(result)
+  };
+}
+function getBuildOutputChunks(result) {
+  if ("on" in result)
+    throw Error("wxt does not support vite watch mode.");
+  if (Array.isArray(result))
+    return result.flatMap(({ output }) => output);
+  return result.output;
+}
+async function copyPublicDirectory(config) {
+  const publicAssets = [];
+  if (!await fs6.exists(config.publicDir))
+    return publicAssets;
+  const files = await glob("**/*", { cwd: config.publicDir });
+  for (const file of files) {
+    const srcPath = resolve8(config.publicDir, file);
+    const outPath = resolve8(config.outDir, file);
+    await fs6.ensureDir(dirname4(outPath));
+    await fs6.copyFile(srcPath, outPath);
+    publicAssets.push({
+      type: "asset",
+      fileName: file,
+      name: file,
+      needsCodeReference: false,
+      source: await fs6.readFile(srcPath)
+    });
+  }
+  return publicAssets;
+}
+
 // src/core/build/findEntrypoints.ts
-import { relative as relative3, resolve as resolve8 } from "path";
-import fs4 from "fs-extra";
+import { relative as relative3, resolve as resolve9 } from "path";
+import fs7 from "fs-extra";
 import picomatch from "picomatch";
 import { parseHTML as parseHTML2 } from "linkedom";
 import JSON5 from "json5";
-import glob from "fast-glob";
+import glob2 from "fast-glob";
 async function findEntrypoints(config) {
-  const relativePaths = await glob("**/*", {
+  const relativePaths = await glob2("**/*", {
     cwd: config.entrypointsDir
   });
   relativePaths.sort();
@@ -487,7 +720,7 @@ async function findEntrypoints(config) {
   const entrypoints = [];
   await Promise.all(
     relativePaths.map(async (relativePath) => {
-      const path5 = resolve8(config.entrypointsDir, relativePath);
+      const path5 = resolve9(config.entrypointsDir, relativePath);
       const matchingGlob = pathGlobs.find(
         (glob3) => picomatch.isMatch(relativePath, glob3)
       );
@@ -547,7 +780,7 @@ ${JSON.stringify(
 }
 async function getPopupEntrypoint(config, path5) {
   const options = {};
-  const content = await fs4.readFile(path5, "utf-8");
+  const content = await fs7.readFile(path5, "utf-8");
   const { document } = parseHTML2(content);
   const title = document.querySelector("title");
   if (title != null)
@@ -577,7 +810,7 @@ async function getPopupEntrypoint(config, path5) {
 }
 async function getOptionsEntrypoint(config, path5) {
   const options = {};
-  const content = await fs4.readFile(path5, "utf-8");
+  const content = await fs7.readFile(path5, "utf-8");
   const { document } = parseHTML2(content);
   const openInTabContent = document.querySelector("meta[name='manifest.open_in_tab']")?.getAttribute("content");
   if (openInTabContent) {
@@ -624,7 +857,7 @@ async function getContentScriptEntrypoint(config, name, path5) {
     type: "content-script",
     name: getEntrypointName(config.entrypointsDir, path5),
     inputPath: path5,
-    outputDir: resolve8(config.outDir, "content-scripts"),
+    outputDir: resolve9(config.outDir, "content-scripts"),
     options
   };
 }
@@ -659,140 +892,112 @@ var PATH_GLOB_TO_TYPE_MAP = {
   "*/*": "ignored"
 };
 
-// src/core/build/buildEntrypoints.ts
-import * as vite3 from "vite";
-
-// src/core/utils/removeEmptyDirs.ts
-import fs5 from "fs-extra";
-import path3 from "path";
-async function removeEmptyDirs(dir) {
-  const files = await fs5.readdir(dir);
-  for (const file of files) {
-    const filePath = path3.join(dir, file);
-    const stats = await fs5.stat(filePath);
-    if (stats.isDirectory()) {
-      await removeEmptyDirs(filePath);
-    }
-  }
-  try {
-    await fs5.rmdir(dir);
-  } catch {
-  }
+// src/core/build/generateTypesDir.ts
+import { createUnimport as createUnimport3 } from "unimport";
+import fs8 from "fs-extra";
+import { relative as relative4, resolve as resolve10 } from "path";
+async function generateTypesDir(entrypoints, config) {
+  await fs8.ensureDir(config.typesDir);
+  const references = [];
+  references.push(await writeImportsDeclarationFile(config));
+  references.push(await writePathsDeclarationFile(entrypoints, config));
+  references.push(await writeGlobalsDeclarationFile(config));
+  const mainReference = await writeMainDeclarationFile(references, config);
+  await writeTsConfigFile(mainReference, config);
 }
-
-// src/core/build/buildEntrypoints.ts
-import glob2 from "fast-glob";
-import fs6 from "fs-extra";
-import { dirname as dirname4, resolve as resolve9 } from "path";
-async function buildEntrypoints(groups, config) {
-  const steps = [];
-  for (const group of groups) {
-    const step = Array.isArray(group) ? await buildMultipleEntrypoints(group, config) : await buildSingleEntrypoint(group, config);
-    steps.push(step);
-  }
-  const publicAssets = await copyPublicDirectory(config);
-  await removeEmptyDirs(config.outDir);
-  return { publicAssets, steps };
+async function writeImportsDeclarationFile(config) {
+  const filePath = resolve10(config.typesDir, "imports.d.ts");
+  const unimport2 = createUnimport3(getUnimportOptions(config));
+  await unimport2.scanImportsFromDir(void 0, { cwd: config.srcDir });
+  await fs8.writeFile(
+    filePath,
+    ["// Generated by wxt", await unimport2.generateTypeDeclarations()].join(
+      "\n"
+    ) + "\n"
+  );
+  return filePath;
 }
-async function buildSingleEntrypoint(entrypoint, config) {
-  const isVirtual = ["background", "content-script"].includes(entrypoint.type);
-  const entry = isVirtual ? `virtual:wxt-${entrypoint.type}?${entrypoint.inputPath}` : entrypoint.inputPath;
-  const libMode = {
-    build: {
-      lib: {
-        entry,
-        formats: ["iife"],
-        name: entrypoint.name,
-        fileName: entrypoint.name
-      },
-      rollupOptions: {
-        output: {
-          // There's only a single output for this build, so we use the desired bundle path for the
-          // entry output (like "content-scripts/overlay.js")
-          entryFileNames: getEntrypointBundlePath(
-            entrypoint,
-            config.outDir,
-            ".js"
-          ),
-          // Output content script CSS to assets/ with a hash to prevent conflicts. Defaults to
-          // "[name].[ext]" in lib mode, which usually results in "style.css". That means multiple
-          // content scripts with styles would overwrite each other if it weren't changed below.
-          assetFileNames: `assets/${entrypoint.name}.[ext]`
-        }
-      }
-    }
-  };
-  const entryConfig = vite3.mergeConfig(
-    libMode,
-    config.vite
+async function writePathsDeclarationFile(entrypoints, config) {
+  const filePath = resolve10(config.typesDir, "paths.d.ts");
+  await fs8.writeFile(
+    filePath,
+    [
+      "// Generated by wxt",
+      "type EntrypointPath =",
+      ...entrypoints.map((entry) => {
+        const path5 = getEntrypointBundlePath(
+          entry,
+          config.outDir,
+          entry.inputPath.endsWith(".html") ? ".html" : ".js"
+        );
+        return `  | "/${path5}"`;
+      }).sort()
+    ].join("\n") + "\n"
   );
-  const result = await vite3.build(entryConfig);
-  return {
-    entrypoints: entrypoint,
-    chunks: getBuildOutputChunks(result)
-  };
+  return filePath;
 }
-async function buildMultipleEntrypoints(entrypoints, config) {
-  const multiPage = {
-    plugins: [multipageMove(entrypoints, config)],
-    build: {
-      rollupOptions: {
-        input: entrypoints.reduce((input, entry) => {
-          input[entry.name] = entry.inputPath;
-          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",
-          // We can't control the "name", so we need a hash to prevent conflicts
-          assetFileNames: "assets/[name]-[hash].[ext]"
-        }
-      }
-    }
-  };
-  const entryConfig = vite3.mergeConfig(
-    multiPage,
-    config.vite
+async function writeGlobalsDeclarationFile(config) {
+  const filePath = resolve10(config.typesDir, "globals.d.ts");
+  const globals = getGlobals(config);
+  await fs8.writeFile(
+    filePath,
+    [
+      "// Generated by wxt",
+      "export {}",
+      "declare global {",
+      ...globals.map((global) => `  const ${global.name}: ${global.type};`),
+      "}"
+    ].join("\n") + "\n",
+    "utf-8"
   );
-  const result = await vite3.build(entryConfig);
-  return {
-    entrypoints,
-    chunks: getBuildOutputChunks(result)
-  };
+  return filePath;
 }
-function getBuildOutputChunks(result) {
-  if ("on" in result)
-    throw Error("wxt does not support vite watch mode.");
-  if (Array.isArray(result))
-    return result.flatMap(({ output }) => output);
-  return result.output;
+async function writeMainDeclarationFile(references, config) {
+  const dir = config.wxtDir;
+  const filePath = resolve10(dir, "wxt.d.ts");
+  await fs8.writeFile(
+    filePath,
+    [
+      "// Generated by wxt",
+      ...references.map(
+        (ref) => `/// <reference types="./${relative4(dir, ref)}" />`
+      )
+    ].join("\n") + "\n"
+  );
+  return filePath;
 }
-async function copyPublicDirectory(config) {
-  const publicAssets = [];
-  if (!await fs6.exists(config.publicDir))
-    return publicAssets;
-  const files = await glob2("**/*", { cwd: config.publicDir });
-  for (const file of files) {
-    const srcPath = resolve9(config.publicDir, file);
-    const outPath = resolve9(config.outDir, file);
-    await fs6.ensureDir(dirname4(outPath));
-    await fs6.copyFile(srcPath, outPath);
-    publicAssets.push({
-      type: "asset",
-      fileName: file,
-      name: file,
-      needsCodeReference: false,
-      source: await fs6.readFile(srcPath)
-    });
-  }
-  return publicAssets;
+async function writeTsConfigFile(mainReference, config) {
+  const dir = config.wxtDir;
+  await fs8.writeFile(
+    resolve10(dir, "tsconfig.json"),
+    `{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "noEmit": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+
+    /* Type Checking */
+    "strict": true,
+
+    /* Completeness */
+    "skipLibCheck": true
+  },
+  "include": [
+    "${relative4(dir, config.root)}/**/*",
+    "./${relative4(dir, mainReference)}"
+  ],
+  "exclude": ["${relative4(dir, config.outBaseDir)}"]
+}`
+  );
 }
 
 // src/core/utils/manifest.ts
-import fs7 from "fs-extra";
-import { resolve as resolve10 } from "path";
+import fs9 from "fs-extra";
+import { resolve as resolve11 } from "path";
 
 // src/core/utils/ContentSecurityPolicy.ts
 var ContentSecurityPolicy = class _ContentSecurityPolicy {
@@ -840,8 +1045,8 @@ var ContentSecurityPolicy = class _ContentSecurityPolicy {
 // src/core/utils/manifest.ts
 async function writeManifest(manifest, output, config) {
   const str = config.mode === "production" ? JSON.stringify(manifest) : JSON.stringify(manifest, null, 2);
-  await fs7.ensureDir(config.outDir);
-  await fs7.writeFile(resolve10(config.outDir, "manifest.json"), str, "utf-8");
+  await fs9.ensureDir(config.outDir);
+  await fs9.writeFile(resolve11(config.outDir, "manifest.json"), str, "utf-8");
   output.publicAssets.unshift({
     type: "asset",
     fileName: "manifest.json",
@@ -869,10 +1074,12 @@ async function generateMainfest(entrypoints, buildOutput, config) {
   addEntrypoints(manifest, entrypoints, buildOutput, config);
   if (config.command === "serve")
     addDevModeCsp(manifest, config);
+  if (config.command === "serve")
+    addDevModePermissions(manifest, config);
   return manifest;
 }
 async function getPackageJson(config) {
-  return await fs7.readJson(resolve10(config.root, "package.json"));
+  return await fs9.readJson(resolve11(config.root, "package.json"));
 }
 function simplifyVersion(versionName) {
   const version3 = /^((0|[1-9][0-9]{0,8})([.](0|[1-9][0-9]{0,8})){0,3}).*$/.exec(
@@ -1025,23 +1232,23 @@ function addEntrypoints(manifest, entrypoints, buildOutput, config) {
     }
   }
   if (contentScripts?.length) {
-    if (config.command === "serve") {
-      const permissionsKey = config.manifestVersion === 2 ? "permissions" : "host_permissions";
-      const hostPermissions = new Set(manifest[permissionsKey] ?? []);
+    if (config.command === "serve" && config.manifestVersion === 3) {
+      const hostPermissions = new Set(manifest.host_permissions ?? []);
       contentScripts.forEach((script) => {
         script.options.matches.forEach((matchPattern) => {
           hostPermissions.add(matchPattern);
         });
       });
-      manifest[permissionsKey] = Array.from(hostPermissions).sort();
+      hostPermissions.forEach(
+        (permission) => addHostPermission(manifest, permission)
+      );
     } else {
       const hashToEntrypointsMap = contentScripts.reduce((map, script) => {
         const hash = JSON.stringify(script.options);
-        if (!map.has(hash)) {
-          map.set(hash, [script]);
-        } else {
+        if (map.has(hash))
           map.get(hash)?.push(script);
-        }
+        else
+          map.set(hash, [script]);
         return map;
       }, /* @__PURE__ */ new Map());
       manifest.content_scripts = Array.from(hashToEntrypointsMap.entries()).map(
@@ -1062,13 +1269,9 @@ function addDevModeCsp(manifest, config) {
   const permission = `http://${config.server?.hostname ?? ""}/*`;
   const allowedCsp = config.server?.origin ?? "http://localhost:*";
   if (manifest.manifest_version === 3) {
-    manifest.host_permissions ??= [];
-    if (!manifest.host_permissions.includes(permission))
-      manifest.host_permissions.push(permission);
+    addHostPermission(manifest, permission);
   } else {
-    manifest.permissions ??= [];
-    if (!manifest.permissions.includes(permission))
-      manifest.permissions.push(permission);
+    addPermission(manifest, permission);
   }
   const csp = new ContentSecurityPolicy(
     manifest.manifest_version === 3 ? (
@@ -1086,6 +1289,11 @@ function addDevModeCsp(manifest, config) {
     manifest.content_security_policy = csp.toString();
   }
 }
+function addDevModePermissions(manifest, config) {
+  addPermission(manifest, "tabs");
+  if (config.manifestVersion === 3)
+    addPermission(manifest, "scripting");
+}
 function getContentScriptCssFiles(contentScripts, buildOutput) {
   const css = [];
   const allChunks = buildOutput.steps.flatMap((step) => step.chunks);
@@ -1100,9 +1308,71 @@ function getContentScriptCssFiles(contentScripts, buildOutput) {
     return css;
   return void 0;
 }
+function addPermission(manifest, permission) {
+  manifest.permissions ??= [];
+  if (manifest.permissions.includes(permission))
+    return;
+  manifest.permissions.push(permission);
+}
+function addHostPermission(manifest, hostPermission) {
+  manifest.host_permissions ??= [];
+  if (manifest.host_permissions.includes(hostPermission))
+    return;
+  manifest.host_permissions.push(hostPermission);
+}
+
+// src/core/build.ts
+import pc2 from "picocolors";
+import * as vite4 from "vite";
+import fs11 from "fs-extra";
+
+// src/core/utils/groupEntrypoints.ts
+function groupEntrypoints(entrypoints) {
+  const groupIndexMap = {};
+  const groups = [];
+  for (const entry of entrypoints) {
+    const group = ENTRY_TYPE_TO_GROUP_MAP[entry.type];
+    if (group === "no-group") {
+      groups.push(entry);
+    } else {
+      let groupIndex = groupIndexMap[group];
+      if (groupIndex == null) {
+        groupIndex = groups.push([]) - 1;
+        groupIndexMap[group] = groupIndex;
+      }
+      groups[groupIndex].push(entry);
+    }
+  }
+  return groups;
+}
+var ENTRY_TYPE_TO_GROUP_MAP = {
+  sandbox: "sandbox-page",
+  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",
+  background: "no-group",
+  "content-script": "no-group",
+  "unlisted-script": "no-group"
+};
+
+// src/core/utils/formatDuration.ts
+function formatDuration(duration) {
+  if (duration < 1e3)
+    return `${duration} ms`;
+  if (duration < 1e4)
+    return `${(duration / 1e3).toFixed(3)} s`;
+  if (duration < 6e4)
+    return `${(duration / 1e3).toFixed(1)} s`;
+  return `${(duration / 1e3).toFixed(0)} s`;
+}
 
 // src/core/log/printBuildSummary.ts
-import path4, { extname as extname2, relative as relative4, resolve as resolve11 } from "path";
+import path4, { extname as extname2, relative as relative5, resolve as resolve12 } from "path";
 
 // src/core/log/printTable.ts
 function printTable(log, rows, gap = 2) {
@@ -1132,7 +1402,7 @@ function printTable(log, rows, gap = 2) {
 
 // src/core/log/printBuildSummary.ts
 import pc from "picocolors";
-import fs8 from "fs-extra";
+import fs10 from "fs-extra";
 import { filesize } from "filesize";
 async function printBuildSummary(output, config) {
   const chunks = [
@@ -1150,13 +1420,13 @@ async function printBuildSummary(output, config) {
   const chunkRows = await Promise.all(
     chunks.map(async (chunk, i) => {
       const file = [
-        relative4(process.cwd(), config.outDir) + path4.sep,
+        relative5(process.cwd(), config.outDir) + path4.sep,
         chunk.fileName
       ];
       const ext = extname2(chunk.fileName);
       const prefix = i === chunks.length - 1 ? "  \u2514\u2500" : "  \u251C\u2500";
       const color = CHUNK_COLORS[ext] ?? DEFAULT_COLOR;
-      const stats = await fs8.lstat(resolve11(config.outDir, chunk.fileName));
+      const stats = await fs10.lstat(resolve12(config.outDir, chunk.fileName));
       totalSize += stats.size;
       const size = String(filesize(stats.size));
       return [
@@ -1184,115 +1454,63 @@ var CHUNK_COLORS = {
   ".js": pc.cyan
 };
 
-// src/index.ts
-import fs10 from "fs-extra";
-
-// src/core/build/generateTypesDir.ts
-import { createUnimport as createUnimport2 } from "unimport";
-import fs9 from "fs-extra";
-import { relative as relative5, resolve as resolve12 } from "path";
-async function generateTypesDir(entrypoints, config) {
-  await fs9.ensureDir(config.typesDir);
-  const references = [];
-  references.push(await writeImportsDeclarationFile(config));
-  references.push(await writePathsDeclarationFile(entrypoints, config));
-  references.push(await writeGlobalsDeclarationFile(config));
-  const mainReference = await writeMainDeclarationFile(references, config);
-  await writeTsConfigFile(mainReference, config);
-}
-async function writeImportsDeclarationFile(config) {
-  const filePath = resolve12(config.typesDir, "imports.d.ts");
-  const unimport2 = createUnimport2(getUnimportOptions(config));
-  await unimport2.scanImportsFromDir(void 0, { cwd: config.srcDir });
-  await fs9.writeFile(
-    filePath,
-    ["// Generated by wxt", await unimport2.generateTypeDeclarations()].join(
-      "\n"
-    ) + "\n"
+// src/core/build.ts
+async function buildInternal(config) {
+  const verb = config.command === "serve" ? "Pre-rendering" : "Building";
+  const target = `${config.browser}-mv${config.manifestVersion}`;
+  config.logger.info(
+    `${verb} ${pc2.cyan(target)} for ${pc2.cyan(config.mode)} with ${pc2.green(
+      `Vite ${vite4.version}`
+    )}`
   );
-  return filePath;
-}
-async function writePathsDeclarationFile(entrypoints, config) {
-  const filePath = resolve12(config.typesDir, "paths.d.ts");
-  await fs9.writeFile(
-    filePath,
-    [
-      "// Generated by wxt",
-      "type EntrypointPath =",
-      ...entrypoints.map((entry) => {
-        const path5 = getEntrypointBundlePath(
-          entry,
-          config.outDir,
-          entry.inputPath.endsWith(".html") ? ".html" : ".js"
-        );
-        return `  | "/${path5}"`;
-      }).sort()
-    ].join("\n") + "\n"
-  );
-  return filePath;
-}
-async function writeGlobalsDeclarationFile(config) {
-  const filePath = resolve12(config.typesDir, "globals.d.ts");
-  const globals = getGlobals(config);
-  await fs9.writeFile(
-    filePath,
-    [
-      "// Generated by wxt",
-      "export {}",
-      "declare global {",
-      ...globals.map((global) => `  const ${global.name}: ${global.type};`),
-      "}"
-    ].join("\n") + "\n",
-    "utf-8"
-  );
-  return filePath;
-}
-async function writeMainDeclarationFile(references, config) {
-  const dir = config.wxtDir;
-  const filePath = resolve12(dir, "wxt.d.ts");
-  await fs9.writeFile(
-    filePath,
-    [
-      "// Generated by wxt",
-      ...references.map(
-        (ref) => `/// <reference types="./${relative5(dir, ref)}" />`
-      )
-    ].join("\n") + "\n"
+  const startTime = Date.now();
+  await fs11.rm(config.outDir, { recursive: true, force: true });
+  await fs11.ensureDir(config.outDir);
+  const entrypoints = await findEntrypoints(config);
+  const groups = groupEntrypoints(entrypoints);
+  const { output } = await rebuild(config, groups);
+  config.logger.success(
+    `Built extension in ${formatDuration(Date.now() - startTime)}`
   );
-  return filePath;
+  await printBuildSummary(output, config);
+  return output;
 }
-async function writeTsConfigFile(mainReference, config) {
-  const dir = config.wxtDir;
-  await fs9.writeFile(
-    resolve12(dir, "tsconfig.json"),
-    `{
-  "compilerOptions": {
-    "target": "ESNext",
-    "module": "ESNext",
-    "moduleResolution": "Bundler",
-    "noEmit": true,
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-
-    /* Type Checking */
-    "strict": true,
-
-    /* Completeness */
-    "skipLibCheck": true
-  },
-  "include": [
-    "${relative5(dir, config.root)}/**/*",
-    "./${relative5(dir, mainReference)}"
-  ],
-  "exclude": ["${relative5(dir, config.outBaseDir)}"]
-}`
+async function rebuild(config, entrypointGroups, existingOutput = {
+  steps: [],
+  publicAssets: []
+}) {
+  const allEntrypoints = await findEntrypoints(config);
+  await generateTypesDir(allEntrypoints, config);
+  const newOutput = await buildEntrypoints(entrypointGroups, config);
+  const mergedOutput = {
+    steps: [...existingOutput.steps, ...newOutput.steps],
+    publicAssets: [...existingOutput.publicAssets, ...newOutput.publicAssets]
+  };
+  const newManifest = await generateMainfest(
+    allEntrypoints,
+    mergedOutput,
+    config
   );
+  const finalOutput = {
+    manifest: newManifest,
+    ...newOutput
+  };
+  await writeManifest(newManifest, finalOutput, config);
+  return {
+    output: {
+      manifest: newManifest,
+      steps: [...existingOutput.steps, ...finalOutput.steps],
+      publicAssets: [
+        ...existingOutput.publicAssets,
+        ...finalOutput.publicAssets
+      ]
+    },
+    manifest: newManifest
+  };
 }
 
-// src/index.ts
-import pc2 from "picocolors";
-import * as vite4 from "vite";
+// src/core/server.ts
+import * as vite5 from "vite";
 
 // src/core/utils/findOpenPort.ts
 import net from "node:net";
@@ -1317,17 +1535,6 @@ function findOpenPortRecursive(port, startPort, endPort) {
   });
 }
 
-// src/core/utils/formatDuration.ts
-function formatDuration(duration) {
-  if (duration < 1e3)
-    return `${duration} ms`;
-  if (duration < 1e4)
-    return `${(duration / 1e3).toFixed(3)} s`;
-  if (duration < 6e4)
-    return `${(duration / 1e3).toFixed(1)} s`;
-  return `${(duration / 1e3).toFixed(0)} s`;
-}
-
 // src/core/runners/createWebExtRunner.ts
 function createWebExtRunner() {
   let runner;
@@ -1385,120 +1592,93 @@ function createWebExtRunner() {
 var WARN_LOG_LEVEL = 40;
 var ERROR_LOG_LEVEL = 50;
 
-// src/core/utils/groupEntrypoints.ts
-function groupEntrypoints(entrypoints) {
-  const groupIndexMap = {};
-  const groups = [];
-  for (const entry of entrypoints) {
-    const group = ENTRY_TYPE_TO_GROUP_MAP[entry.type];
-    if (group === "no-group") {
-      groups.push(entry);
-    } else {
-      let groupIndex = groupIndexMap[group];
-      if (groupIndex == null) {
-        groupIndex = groups.push([]) - 1;
-        groupIndexMap[group] = groupIndex;
-      }
-      groups[groupIndex].push(entry);
+// src/core/server.ts
+async function getServerInfo() {
+  const port = await findOpenPort(3e3, 3010);
+  const hostname = "localhost";
+  const origin = `http://${hostname}:${port}`;
+  const serverConfig = {
+    server: {
+      origin
     }
-  }
-  return groups;
+  };
+  return {
+    port,
+    hostname,
+    origin,
+    viteServerConfig: serverConfig
+  };
 }
-var ENTRY_TYPE_TO_GROUP_MAP = {
-  sandbox: "sandbox-page",
-  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",
-  background: "no-group",
-  "content-script": "no-group",
-  "unlisted-script": "no-group"
-};
-
-// src/core/utils/detectDevChanges.ts
-function detectDevChanges(changedFiles, currentOutput) {
-  if (currentOutput == null)
-    return { type: "no-change" };
-  const changedSteps = new Set(
-    changedFiles.flatMap(
-      (changedFile) => findEffectedSteps(changedFile, currentOutput)
-    )
+async function setupServer(serverInfo, config) {
+  const runner = createWebExtRunner();
+  const viteServer = await vite5.createServer(
+    vite5.mergeConfig(serverInfo, config.vite)
   );
-  if (changedSteps.size === 0)
-    return { type: "no-change" };
-  const unchangedOutput = {
-    manifest: currentOutput.manifest,
-    steps: [],
-    publicAssets: []
+  const start = async () => {
+    await viteServer.listen(server.port);
+    config.logger.success(`Started dev server @ ${serverInfo.origin}`);
+    server.currentOutput = await buildInternal(config);
+    config.logger.info("Opening browser...");
+    await runner.openBrowser(config);
+    config.logger.success("Opened!");
   };
-  const changedOutput = {
-    manifest: currentOutput.manifest,
-    steps: [],
-    publicAssets: []
+  const reloadExtension = () => {
+    viteServer.ws.send("wxt:reload-extension");
   };
-  for (const step of currentOutput.steps) {
-    if (changedSteps.has(step)) {
-      changedOutput.steps.push(step);
-    } else {
-      unchangedOutput.steps.push(step);
-    }
-  }
-  for (const asset of currentOutput.publicAssets) {
-    if (changedSteps.has(asset)) {
-      changedOutput.publicAssets.push(asset);
-    } else {
-      unchangedOutput.publicAssets.push(asset);
-    }
-  }
-  const isOnlyHtmlChanges = !changedFiles.find(
-    ([_, file]) => !file.endsWith(".html")
-  );
-  if (isOnlyHtmlChanges) {
-    return {
-      type: "html-reload",
-      cachedOutput: unchangedOutput,
-      rebuildGroups: changedOutput.steps.map((step) => step.entrypoints)
-    };
-  }
-  return {
-    type: "extension-reload",
-    cachedOutput: unchangedOutput,
-    rebuildGroups: changedOutput.steps.map((step) => step.entrypoints)
+  const reloadPage = (path5) => {
+    viteServer.ws.send("wxt:reload-page", path5);
   };
+  const reloadContentScript = (contentScript) => {
+    viteServer.ws.send("wxt:reload-content-script", contentScript);
+  };
+  const server = {
+    ...viteServer,
+    start,
+    currentOutput: {
+      manifest: {
+        manifest_version: 3,
+        name: "",
+        version: ""
+      },
+      publicAssets: [],
+      steps: []
+    },
+    port: serverInfo.port,
+    hostname: serverInfo.hostname,
+    origin: serverInfo.origin,
+    reloadExtension,
+    reloadPage,
+    reloadContentScript
+  };
+  return server;
 }
-function findEffectedSteps(changedFile, currentOutput) {
-  const changes = [];
-  const changedPath = changedFile[1];
-  const isChunkEffected = (chunk) => (
-    // If it's an HTML file with the same path, is is effected because HTML files need to be pre-rendered
-    // TODO: use bundle path to support `<name>/index.html`?
-    chunk.type === "asset" && changedPath.endsWith(chunk.fileName) || // If it's a chunk that depends on the changed file, it is effected
-    chunk.type === "chunk" && chunk.moduleIds.includes(changedPath)
-  );
-  for (const step of currentOutput.steps) {
-    const effectedChunk = step.chunks.find((chunk) => isChunkEffected(chunk));
-    if (effectedChunk)
-      changes.push(step);
+function reloadContentScripts(steps, config, server) {
+  if (config.manifestVersion === 3) {
+    steps.forEach((step) => {
+      const entry = step.entrypoints;
+      if (Array.isArray(entry) || entry.type !== "content-script")
+        return;
+      const js = [getEntrypointBundlePath(entry, config.outDir, ".js")];
+      const css = getContentScriptCssFiles([entry], server.currentOutput);
+      server.reloadContentScript({
+        js,
+        css,
+        ...entry.options
+      });
+    });
+  } else {
+    server.reloadExtension();
   }
-  const effectedAsset = currentOutput.publicAssets.find(
-    (chunk) => isChunkEffected(chunk)
-  );
-  if (effectedAsset)
-    changes.push(effectedAsset);
-  return changes;
 }
-
-// src/index.ts
-import { Mutex } from "async-mutex";
-import { consola as consola3 } from "consola";
-import { relative as relative6 } from "node:path";
+function reloadHtmlPages(groups, server, config) {
+  groups.flat().forEach((entry) => {
+    const path5 = getEntrypointBundlePath(entry, config.outDir, ".html");
+    server.reloadPage(path5);
+  });
+}
 
 // package.json
-var version = "0.0.2";
+var version2 = "0.1.1-alpha1";
 
 // src/core/utils/defineConfig.ts
 function defineConfig(config) {
@@ -1516,45 +1696,40 @@ async function build2(config) {
   return await buildInternal(internalConfig);
 }
 async function createServer2(config) {
-  const port = await findOpenPort(3e3, 3010);
-  const hostname = "localhost";
-  const origin = `http://${hostname}:${port}`;
-  const serverConfig = {
-    server: {
-      origin
-    }
+  const serverInfo = await getServerInfo();
+  const getLatestInternalConfig = () => {
+    const viteConfig = vite6.mergeConfig(
+      serverInfo.viteServerConfig,
+      config?.vite ?? {}
+    );
+    return getInternalConfig({ ...config, vite: viteConfig }, "serve");
   };
-  let internalConfig = await getInternalConfig(
-    vite4.mergeConfig(serverConfig, config ?? {}),
-    "serve"
-  );
-  const runner = createWebExtRunner();
-  let hasBuiltOnce = false;
-  let currentOutput;
+  let internalConfig = await getLatestInternalConfig();
+  const server = await setupServer(serverInfo, internalConfig);
+  internalConfig.server = server;
   const fileChangedMutex = new Mutex();
   const changeQueue = [];
-  const viteServer = await vite4.createServer(internalConfig.vite);
-  viteServer.watcher.on("all", async (event, path5, stats) => {
-    if (!hasBuiltOnce || path5.startsWith(internalConfig.outBaseDir))
+  server.ws.on("wxt:background-initialized", () => {
+    reloadContentScripts(server.currentOutput.steps, internalConfig, server);
+  });
+  server.watcher.on("all", async (event, path5, _stats) => {
+    if (path5.startsWith(internalConfig.outBaseDir))
       return;
     changeQueue.push([event, path5]);
     await fileChangedMutex.runExclusive(async () => {
       const fileChanges = changeQueue.splice(0, changeQueue.length);
-      const changes = detectDevChanges(fileChanges, currentOutput);
+      const changes = detectDevChanges(fileChanges, server.currentOutput);
       if (changes.type === "no-change")
         return;
       consola3.info(
-        `Changed: ${Array.from(new Set(fileChanges.map((change) => change[1]))).map((file) => pc2.dim(relative6(internalConfig.root, file))).join(", ")}`
+        `Changed: ${Array.from(new Set(fileChanges.map((change) => change[1]))).map((file) => pc3.dim(relative6(internalConfig.root, file))).join(", ")}`
       );
       const rebuiltNames = changes.rebuildGroups.flat().map((entry) => {
-        return pc2.cyan(
+        return pc3.cyan(
           relative6(internalConfig.outDir, getEntrypointOutputFile(entry, ""))
         );
-      }).join(pc2.dim(", "));
-      internalConfig = await getInternalConfig(
-        vite4.mergeConfig(serverConfig, config ?? {}),
-        "serve"
-      );
+      }).join(pc3.dim(", "));
+      internalConfig = await getLatestInternalConfig();
       internalConfig.server = server;
       const { output: newOutput } = await rebuild(
         internalConfig,
@@ -1562,102 +1737,28 @@ async function createServer2(config) {
         changes.rebuildGroups,
         changes.cachedOutput
       );
-      currentOutput = newOutput;
+      server.currentOutput = newOutput;
       switch (changes.type) {
         case "extension-reload":
           server.reloadExtension();
-          consola3.success(`Reloaded extension: ${rebuiltNames}`);
           break;
         case "html-reload":
-          changes.rebuildGroups.flat().forEach((entry) => {
-            const path6 = getEntrypointBundlePath(
-              entry,
-              internalConfig.outDir,
-              ".html"
-            );
-            server.reloadPage(path6);
-          });
-          consola3.success(`Reloaded pages: ${rebuiltNames}`);
+          reloadHtmlPages(changes.rebuildGroups, server, internalConfig);
+          break;
+        case "content-script-reload":
+          reloadContentScripts(changes.changedSteps, internalConfig, server);
           break;
       }
+      consola3.success(`Reloaded: ${rebuiltNames}`);
     });
   });
-  const server = {
-    ...viteServer,
-    async listen(port2, isRestart) {
-      const res = await viteServer.listen(port2, isRestart);
-      if (!isRestart) {
-        internalConfig.logger.success(`Started dev server @ ${origin}`);
-        internalConfig.logger.info("Opening browser...");
-        await runner.openBrowser(internalConfig);
-        internalConfig.logger.success("Opened!");
-      }
-      return res;
-    },
-    port,
-    hostname,
-    origin,
-    reloadExtension: () => {
-      server.ws.send("wxt:reload-extension");
-    },
-    reloadPage: (path5) => {
-      server.ws.send("wxt:reload-page", path5);
-    }
-  };
-  internalConfig.logger.info("Created dev server");
-  internalConfig.server = server;
-  currentOutput = await buildInternal(internalConfig);
-  hasBuiltOnce = true;
   return server;
 }
-async function buildInternal(config) {
-  const verb = config.command === "serve" ? "Pre-rendering" : "Building";
-  const target = `${config.browser}-mv${config.manifestVersion}`;
-  config.logger.info(
-    `${verb} ${pc2.cyan(target)} for ${pc2.cyan(config.mode)} with ${pc2.green(
-      `Vite ${vite4.version}`
-    )}`
-  );
-  const startTime = Date.now();
-  await fs10.rm(config.outDir, { recursive: true, force: true });
-  await fs10.ensureDir(config.outDir);
-  const entrypoints = await findEntrypoints(config);
-  const groups = groupEntrypoints(entrypoints);
-  const { output } = await rebuild(config, groups);
-  config.logger.success(
-    `Built extension in ${formatDuration(Date.now() - startTime)}`
-  );
-  await printBuildSummary(output, config);
-  return output;
-}
-async function rebuild(config, entrypointGroups, existingOutput = {
-  steps: [],
-  publicAssets: []
-}) {
-  const allEntrypoints = await findEntrypoints(config);
-  await generateTypesDir(allEntrypoints, config);
-  const buildOutput = await buildEntrypoints(entrypointGroups, config);
-  const manifest = await generateMainfest(allEntrypoints, buildOutput, config);
-  const output = {
-    manifest,
-    ...buildOutput
-  };
-  await writeManifest(manifest, output, config);
-  return {
-    output: {
-      manifest,
-      steps: [...existingOutput.steps, ...output.steps],
-      publicAssets: [...existingOutput.publicAssets, ...output.publicAssets]
-    },
-    manifest
-  };
-}
 export {
   build2 as build,
   createServer2 as createServer,
   defineConfig,
   defineRunnerConfig,
-  rebuild,
-  version
+  version2 as version
 };
 //# sourceMappingURL=index.js.map