wxt 0.18.15 → 0.19.0

package/dist/core/builders/vite/plugins/index.d.ts

@@ -0,0 +1,17 @@
+export * from './devHtmlPrerender';
+export * from './devServerGlobals';
+export * from './download';
+export * from './multipageMove';
+export * from './resolveVirtualModules';
+export * from './tsconfigPaths';
+export * from './noopBackground';
+export * from './cssEntrypoints';
+export * from './bundleAnalysis';
+export * from './globals';
+export * from './extensionApiMock';
+export * from './resolveExtensionApi';
+export * from './entrypointGroupGlobals';
+export * from './defineImportMeta';
+export * from './removeEntrypointMainFunction';
+export * from './wxtPluginLoader';
+export * from './resolveAppConfig';

package/dist/core/builders/vite/plugins/index.mjs

@@ -0,0 +1,17 @@
+export * from "./devHtmlPrerender.mjs";
+export * from "./devServerGlobals.mjs";
+export * from "./download.mjs";
+export * from "./multipageMove.mjs";
+export * from "./resolveVirtualModules.mjs";
+export * from "./tsconfigPaths.mjs";
+export * from "./noopBackground.mjs";
+export * from "./cssEntrypoints.mjs";
+export * from "./bundleAnalysis.mjs";
+export * from "./globals.mjs";
+export * from "./extensionApiMock.mjs";
+export * from "./resolveExtensionApi.mjs";
+export * from "./entrypointGroupGlobals.mjs";
+export * from "./defineImportMeta.mjs";
+export * from "./removeEntrypointMainFunction.mjs";
+export * from "./wxtPluginLoader.mjs";
+export * from "./resolveAppConfig.mjs";

package/dist/core/builders/vite/plugins/multipageMove.d.ts

@@ -0,0 +1,20 @@
+import type * as vite from 'vite';
+import { Entrypoint, ResolvedConfig } from '../../../../types';
+/**
+ * Ensures the HTML files output by a multipage build are in the correct location. This does two
+ * things:
+ *
+ * 1. Moves the HMTL files to their final location at `<outDir>/<entrypoint.name>.html`.
+ * 2. Updates the bundle so it summarizes the files correctly in the returned build output.
+ *
+ * Assets (JS and CSS) are output to the `<outDir>/assets` directory, and don't need to be modified.
+ * HTML files access them via absolute URLs, so we don't need to update any import paths in the HTML
+ * files either.
+ *
+ * THIS PLUGIN SHOULD ONLY BE APPLIED TO MULTIPAGE BUILDS. It should not be added to every build.
+ */
+export declare function multipageMove(entrypoints: Entrypoint[], config: ResolvedConfig): vite.Plugin;
+/**
+ * Recursively remove all directories that are empty/
+ */
+export declare function removeEmptyDirs(dir: string): Promise<void>;

package/dist/core/builders/vite/plugins/multipageMove.mjs

@@ -0,0 +1,59 @@
+import { dirname, extname, resolve, join } from "node:path";
+import { getEntrypointBundlePath } from "../../../utils/entrypoints.mjs";
+import fs, { ensureDir } from "fs-extra";
+import { normalizePath } from "../../../utils/paths.mjs";
+export function multipageMove(entrypoints, config) {
+  return {
+    name: "wxt:multipage-move",
+    async writeBundle(_, bundle) {
+      for (const oldBundlePath in bundle) {
+        const entrypoint = entrypoints.find(
+          (entry) => !!normalizePath(entry.inputPath).endsWith(oldBundlePath)
+        );
+        if (entrypoint == null) {
+          config.logger.debug(
+            `No entrypoint found for ${oldBundlePath}, leaving in chunks directory`
+          );
+          continue;
+        }
+        const newBundlePath = getEntrypointBundlePath(
+          entrypoint,
+          config.outDir,
+          extname(oldBundlePath)
+        );
+        if (newBundlePath === oldBundlePath) {
+          config.logger.debug(
+            "HTML file is already in the correct location",
+            oldBundlePath
+          );
+          continue;
+        }
+        const oldAbsPath = resolve(config.outDir, oldBundlePath);
+        const newAbsPath = resolve(config.outDir, newBundlePath);
+        await ensureDir(dirname(newAbsPath));
+        await fs.move(oldAbsPath, newAbsPath, { overwrite: true });
+        const renamedChunk = {
+          ...bundle[oldBundlePath],
+          fileName: newBundlePath
+        };
+        delete bundle[oldBundlePath];
+        bundle[newBundlePath] = renamedChunk;
+      }
+      removeEmptyDirs(config.outDir);
+    }
+  };
+}
+export async function removeEmptyDirs(dir) {
+  const files = await fs.readdir(dir);
+  for (const file of files) {
+    const filePath = join(dir, file);
+    const stats = await fs.stat(filePath);
+    if (stats.isDirectory()) {
+      await removeEmptyDirs(filePath);
+    }
+  }
+  try {
+    await fs.rmdir(dir);
+  } catch {
+  }
+}

package/dist/core/builders/vite/plugins/noopBackground.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from 'vite';
+/**
+ * In dev mode, if there's not a background script listed, we need to add one so that the web socket
+ * connection is setup and the extension reloads HTML pages and content scripts correctly.
+ */
+export declare function noopBackground(): Plugin;

package/dist/core/builders/vite/plugins/noopBackground.mjs

@@ -0,0 +1,17 @@
+import { VIRTUAL_NOOP_BACKGROUND_MODULE_ID } from "../../../utils/constants.mjs";
+export function noopBackground() {
+  const virtualModuleId = VIRTUAL_NOOP_BACKGROUND_MODULE_ID;
+  const resolvedVirtualModuleId = "\0" + virtualModuleId;
+  return {
+    name: "wxt:noop-background",
+    resolveId(id) {
+      if (id === virtualModuleId) return resolvedVirtualModuleId;
+    },
+    load(id) {
+      if (id === resolvedVirtualModuleId) {
+        return `import { defineBackground } from 'wxt/sandbox';
+export default defineBackground(() => void 0)`;
+      }
+    }
+  };
+}

package/dist/core/builders/vite/plugins/removeEntrypointMainFunction.d.ts

@@ -0,0 +1,6 @@
+import { ResolvedConfig } from '../../../../types';
+import * as vite from 'vite';
+/**
+ * Transforms entrypoints, removing the main function from the entrypoint if it exists.
+ */
+export declare function removeEntrypointMainFunction(config: ResolvedConfig, path: string): vite.Plugin;

package/dist/core/builders/vite/plugins/removeEntrypointMainFunction.mjs

@@ -0,0 +1,12 @@
+import { normalizePath } from "../../../utils/paths.mjs";
+import { removeMainFunctionCode } from "../../../utils/transform.mjs";
+import { resolve } from "node:path";
+export function removeEntrypointMainFunction(config, path) {
+  const absPath = normalizePath(resolve(config.root, path));
+  return {
+    name: "wxt:remove-entrypoint-main-function",
+    transform(code, id) {
+      if (id === absPath) return removeMainFunctionCode(code);
+    }
+  };
+}

package/dist/core/builders/vite/plugins/resolveAppConfig.d.ts

@@ -0,0 +1,6 @@
+import type * as vite from 'vite';
+import { ResolvedConfig } from '../../../../types';
+/**
+ * When importing `virtual:app-config`, resolve it to the `app.config.ts` file in the project.
+ */
+export declare function resolveAppConfig(config: ResolvedConfig): vite.Plugin;

package/dist/core/builders/vite/plugins/resolveAppConfig.mjs

@@ -0,0 +1,26 @@
+import { exists } from "fs-extra";
+import { resolve } from "node:path";
+export function resolveAppConfig(config) {
+  const virtualModuleId = "virtual:app-config";
+  const resolvedVirtualModuleId = "\0" + virtualModuleId;
+  const appConfigFile = resolve(config.srcDir, "app.config.ts");
+  return {
+    name: "wxt:resolve-app-config",
+    config() {
+      return {
+        optimizeDeps: {
+          // Prevent ESBuild from attempting to resolve the virtual module
+          // while optimizing WXT.
+          exclude: [virtualModuleId]
+        }
+      };
+    },
+    async resolveId(id) {
+      if (id !== virtualModuleId) return;
+      return await exists(appConfigFile) ? appConfigFile : resolvedVirtualModuleId;
+    },
+    load(id) {
+      if (id === resolvedVirtualModuleId) return `export default {}`;
+    }
+  };
+}

package/dist/core/builders/vite/plugins/resolveExtensionApi.d.ts

@@ -0,0 +1,10 @@
+import { ResolvedConfig } from '../../../../types';
+import type * as vite from 'vite';
+/**
+ * Apply the experimental config for which extension API is used. This only
+ * effects the extension API included at RUNTIME - during development, types
+ * depend on the import.
+ *
+ * NOTE: this only works if we import `wxt/browser` instead of using the relative path.
+ */
+export declare function resolveExtensionApi(config: ResolvedConfig): vite.Plugin;

package/dist/core/builders/vite/plugins/resolveExtensionApi.mjs

@@ -0,0 +1,15 @@
+export function resolveExtensionApi(config) {
+  return {
+    name: "wxt:resolve-extension-api",
+    config() {
+      if (config.extensionApi === "webextension-polyfill") return;
+      return {
+        resolve: {
+          alias: [
+            { find: /^wxt\/browser$/, replacement: "wxt/browser/chrome" }
+          ]
+        }
+      };
+    }
+  };
+}

package/dist/core/builders/vite/plugins/resolveVirtualModules.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from 'vite';
+import { ResolvedConfig } from '../../../../types';
+/**
+ * Resolve all the virtual modules to the `node_modules/wxt/dist/virtual` directory.
+ */
+export declare function resolveVirtualModules(config: ResolvedConfig): Plugin[];

package/dist/core/builders/vite/plugins/resolveVirtualModules.mjs

@@ -0,0 +1,30 @@
+import { normalizePath } from "../../../utils/paths.mjs";
+import {
+  virtualModuleNames
+} from "../../../utils/virtual-modules.mjs";
+import fs from "fs-extra";
+import { resolve } from "path";
+export function resolveVirtualModules(config) {
+  return virtualModuleNames.map((name) => {
+    const virtualId = `virtual:wxt-${name}?`;
+    const resolvedVirtualId = "\0" + virtualId;
+    return {
+      name: `wxt:resolve-virtual-${name}`,
+      resolveId(id) {
+        const index = id.indexOf(virtualId);
+        if (index === -1) return;
+        const inputPath = normalizePath(id.substring(index + virtualId.length));
+        return resolvedVirtualId + inputPath;
+      },
+      async load(id) {
+        if (!id.startsWith(resolvedVirtualId)) return;
+        const inputPath = id.replace(resolvedVirtualId, "");
+        const template = await fs.readFile(
+          resolve(config.wxtModuleDir, `dist/virtual/${name}.mjs`),
+          "utf-8"
+        );
+        return template.replace(`virtual:user-${name}`, inputPath);
+      }
+    };
+  });
+}

package/dist/core/builders/vite/plugins/tsconfigPaths.d.ts

@@ -0,0 +1,3 @@
+import { ResolvedConfig } from '../../../../types';
+import type * as vite from 'vite';
+export declare function tsconfigPaths(config: ResolvedConfig): vite.Plugin;

package/dist/core/builders/vite/plugins/tsconfigPaths.mjs

@@ -0,0 +1,12 @@
+export function tsconfigPaths(config) {
+  return {
+    name: "wxt:aliases",
+    async config() {
+      return {
+        resolve: {
+          alias: config.alias
+        }
+      };
+    }
+  };
+}

package/dist/core/builders/vite/plugins/wxtPluginLoader.d.ts

@@ -0,0 +1,6 @@
+import type * as vite from 'vite';
+import { ResolvedConfig } from '../../../../types';
+/**
+ * Resolve and load plugins for each entrypoint. This handles both JS entrypoints via the `virtual:wxt-plugins` import, and HTML files by adding `virtual:wxt-html-plugins` to the document's `<head>`
+ */
+export declare function wxtPluginLoader(config: ResolvedConfig): vite.Plugin;

package/dist/core/builders/vite/plugins/wxtPluginLoader.mjs

@@ -0,0 +1,56 @@
+import { parseHTML } from "linkedom";
+import { normalizePath } from "../../../utils/paths.mjs";
+export function wxtPluginLoader(config) {
+  const virtualModuleId = "virtual:wxt-plugins";
+  const resolvedVirtualModuleId = "\0" + virtualModuleId;
+  const virtualHtmlModuleId = "virtual:wxt-html-plugins";
+  const resolvedVirtualHtmlModuleId = "\0" + virtualHtmlModuleId;
+  return {
+    name: "wxt:plugin-loader",
+    resolveId(id) {
+      if (id === virtualModuleId) return resolvedVirtualModuleId;
+      if (id === virtualHtmlModuleId) return resolvedVirtualHtmlModuleId;
+    },
+    load(id) {
+      if (id === resolvedVirtualModuleId) {
+        const imports = config.plugins.map(
+          (plugin, i) => `import initPlugin${i} from '${normalizePath(plugin)}';`
+        ).join("\n");
+        const initCalls = config.plugins.map((_, i) => `  initPlugin${i}();`).join("\n");
+        return `${imports}
+
+export function initPlugins() {
+${initCalls}
+}`;
+      }
+      if (id === resolvedVirtualHtmlModuleId) {
+        return `import { initPlugins } from '${virtualModuleId}';
+
+try {
+  initPlugins();
+} catch (err) {
+  console.error("[wxt] Failed to initialize plugins", err);
+}`;
+      }
+    },
+    transformIndexHtml: {
+      // Use "pre" so the new script is added before vite bundles all the scripts
+      order: "pre",
+      handler(html, _ctx) {
+        const src = config.command === "serve" ? `http://${config.dev.server?.hostname}:${config.dev.server?.port}/@id/${virtualHtmlModuleId}` : virtualHtmlModuleId;
+        const { document } = parseHTML(html);
+        const existing = document.querySelector(`script[src='${src}']`);
+        if (existing) return;
+        const script = document.createElement("script");
+        script.type = "module";
+        script.src = src;
+        if (document.head == null) {
+          const newHead = document.createElement("head");
+          document.documentElement.prepend(newHead);
+        }
+        document.head.prepend(script);
+        return document.toString();
+      }
+    }
+  };
+}

package/dist/core/clean.d.ts

@@ -0,0 +1,21 @@
+import { InlineConfig } from '../types';
+/**
+ * Remove generated/temp files from the directory.
+ *
+ * @param config Optional config that will override your `<root>/wxt.config.ts`.
+ *
+ * @example
+ * await clean();
+ */
+export declare function clean(config?: InlineConfig): Promise<void>;
+/**
+ * Remove generated/temp files from the directory.
+ *
+ * @deprecated
+ *
+ * @param root The directory to look for generated/temp files in. Defaults to `process.cwd()`. Can be relative to `process.cwd()` or absolute.
+ *
+ * @example
+ * await clean();
+ */
+export declare function clean(root?: string): Promise<void>;

package/dist/core/clean.mjs

@@ -0,0 +1,38 @@
+import path from "node:path";
+import glob from "fast-glob";
+import fs from "fs-extra";
+import pc from "picocolors";
+import { registerWxt, wxt } from "./wxt.mjs";
+export async function clean(config) {
+  if (typeof config === "string") {
+    config = { root: config };
+  }
+  await registerWxt("build", config);
+  wxt.logger.info("Cleaning Project");
+  const root = wxt.config.root;
+  const tempDirs = [
+    "node_modules/.vite",
+    "node_modules/.cache",
+    "**/.wxt",
+    `${path.relative(root, wxt.config.outBaseDir)}/*`
+  ];
+  wxt.logger.debug("Looking for:", tempDirs.map(pc.cyan).join(", "));
+  const directories = await glob(tempDirs, {
+    cwd: root,
+    absolute: true,
+    onlyDirectories: true,
+    deep: 2
+  });
+  if (directories.length === 0) {
+    wxt.logger.debug("No generated files found.");
+    return;
+  }
+  wxt.logger.debug(
+    "Found:",
+    directories.map((dir) => pc.cyan(path.relative(root, dir))).join(", ")
+  );
+  for (const directory of directories) {
+    await fs.rm(directory, { force: true, recursive: true });
+    wxt.logger.debug("Deleted " + pc.cyan(path.relative(root, directory)));
+  }
+}

package/dist/core/create-server.d.ts

@@ -0,0 +1,11 @@
+import { InlineConfig, WxtDevServer } from '../types';
+/**
+ * Creates a dev server and pre-builds all the files that need to exist before loading the extension.
+ *
+ * @example
+ * const server = await wxt.createServer({
+ *   // Enter config...
+ * });
+ * await server.start();
+ */
+export declare function createServer(inlineConfig?: InlineConfig): Promise<WxtDevServer>;

package/dist/core/create-server.mjs

@@ -0,0 +1,206 @@
+import { getEntrypointBundlePath, isHtmlEntrypoint } from "./utils/entrypoints.mjs";
+import {
+  getContentScriptCssFiles,
+  getContentScriptsCssMap
+} from "./utils/manifest.mjs";
+import {
+  internalBuild,
+  detectDevChanges,
+  rebuild,
+  findEntrypoints
+} from "./utils/building/index.mjs";
+import { createExtensionRunner } from "./runners/index.mjs";
+import { Mutex } from "async-mutex";
+import pc from "picocolors";
+import { relative } from "node:path";
+import { registerWxt, wxt } from "./wxt.mjs";
+import { unnormalizePath } from "./utils/paths.mjs";
+import {
+  getContentScriptJs,
+  mapWxtOptionsToRegisteredContentScript
+} from "./utils/content-scripts.mjs";
+export async function createServer(inlineConfig) {
+  await registerWxt("serve", inlineConfig, async (config) => {
+    const { port, hostname } = config.dev.server;
+    const serverInfo = {
+      port,
+      hostname,
+      origin: `http://${hostname}:${port}`
+    };
+    const server2 = {
+      ...serverInfo,
+      get watcher() {
+        return builderServer.watcher;
+      },
+      get ws() {
+        return builderServer.ws;
+      },
+      currentOutput: void 0,
+      async start() {
+        await builderServer.listen();
+        wxt.logger.success(`Started dev server @ ${serverInfo.origin}`);
+        await buildAndOpenBrowser();
+      },
+      async stop() {
+        await runner.closeBrowser();
+        await builderServer.close();
+      },
+      async restart() {
+        await closeAndRecreateRunner();
+        await buildAndOpenBrowser();
+      },
+      transformHtml(url, html, originalUrl) {
+        return builderServer.transformHtml(url, html, originalUrl);
+      },
+      reloadContentScript(payload) {
+        server2.ws.send("wxt:reload-content-script", payload);
+      },
+      reloadPage(path) {
+        server2.ws.send("wxt:reload-page", path);
+      },
+      reloadExtension() {
+        server2.ws.send("wxt:reload-extension");
+      },
+      async restartBrowser() {
+        await closeAndRecreateRunner();
+        await runner.openBrowser();
+      }
+    };
+    return server2;
+  });
+  const server = wxt.server;
+  let [runner, builderServer] = await Promise.all([
+    createExtensionRunner(),
+    wxt.builder.createServer(server)
+  ]);
+  const buildAndOpenBrowser = async () => {
+    server.currentOutput = await internalBuild();
+    try {
+      server.watcher.add(getExternalOutputDependencies(server));
+    } catch (err) {
+      wxt.config.logger.warn("Failed to register additional file paths:", err);
+    }
+    await runner.openBrowser();
+  };
+  const closeAndRecreateRunner = async () => {
+    await runner.closeBrowser();
+    await wxt.reloadConfig();
+    runner = await createExtensionRunner();
+  };
+  server.ws.on("wxt:background-initialized", () => {
+    if (server.currentOutput == null) return;
+    reloadContentScripts(server.currentOutput.steps, server);
+  });
+  const reloadOnChange = createFileReloader(server);
+  server.watcher.on("all", reloadOnChange);
+  return server;
+}
+function createFileReloader(server) {
+  const fileChangedMutex = new Mutex();
+  const changeQueue = [];
+  return async (event, path) => {
+    await wxt.reloadConfig();
+    if (path.startsWith(wxt.config.outBaseDir)) return;
+    if (path.startsWith(wxt.config.wxtDir)) return;
+    changeQueue.push([event, path]);
+    await fileChangedMutex.runExclusive(async () => {
+      if (server.currentOutput == null) return;
+      const fileChanges = changeQueue.splice(0, changeQueue.length).map(([_, file]) => file);
+      if (fileChanges.length === 0) return;
+      const changes = detectDevChanges(fileChanges, server.currentOutput);
+      if (changes.type === "no-change") return;
+      if (changes.type === "full-restart") {
+        wxt.logger.info("Config changed, restarting server...");
+        server.restart();
+        return;
+      }
+      if (changes.type === "browser-restart") {
+        wxt.logger.info("Runner config changed, restarting browser...");
+        server.restartBrowser();
+        return;
+      }
+      wxt.logger.info(
+        `Changed: ${Array.from(new Set(fileChanges)).map((file) => pc.dim(relative(wxt.config.root, file))).join(", ")}`
+      );
+      const allEntrypoints = await findEntrypoints();
+      try {
+        const { output: newOutput } = await rebuild(
+          allEntrypoints,
+          // TODO: this excludes new entrypoints, so they're not built until the dev command is restarted
+          changes.rebuildGroups,
+          changes.cachedOutput
+        );
+        server.currentOutput = newOutput;
+        switch (changes.type) {
+          case "extension-reload":
+            server.reloadExtension();
+            wxt.logger.success(`Reloaded extension`);
+            break;
+          case "html-reload":
+            const { reloadedNames } = reloadHtmlPages(
+              changes.rebuildGroups,
+              server
+            );
+            wxt.logger.success(`Reloaded: ${getFilenameList(reloadedNames)}`);
+            break;
+          case "content-script-reload":
+            reloadContentScripts(changes.changedSteps, server);
+            const rebuiltNames = changes.rebuildGroups.flat().map((entry) => entry.name);
+            wxt.logger.success(`Reloaded: ${getFilenameList(rebuiltNames)}`);
+            break;
+        }
+      } catch (err) {
+      }
+    });
+  };
+}
+function reloadContentScripts(steps, server) {
+  if (wxt.config.manifestVersion === 3) {
+    steps.forEach((step) => {
+      if (server.currentOutput == null) return;
+      const entry = step.entrypoints;
+      if (Array.isArray(entry) || entry.type !== "content-script") return;
+      const js = getContentScriptJs(wxt.config, entry);
+      const cssMap = getContentScriptsCssMap(server.currentOutput, [entry]);
+      const css = getContentScriptCssFiles([entry], cssMap);
+      server.reloadContentScript({
+        registration: entry.options.registration,
+        contentScript: mapWxtOptionsToRegisteredContentScript(
+          entry.options,
+          js,
+          css
+        )
+      });
+    });
+  } else {
+    server.reloadExtension();
+  }
+}
+function reloadHtmlPages(groups, server) {
+  const htmlEntries = groups.flat().filter(isHtmlEntrypoint);
+  htmlEntries.forEach((entry) => {
+    const path = getEntrypointBundlePath(entry, wxt.config.outDir, ".html");
+    server.reloadPage(path);
+  });
+  return {
+    reloadedNames: htmlEntries.map((entry) => entry.name)
+  };
+}
+function getFilenameList(names) {
+  return names.map((name) => {
+    return pc.cyan(name);
+  }).join(pc.dim(", "));
+}
+function getExternalOutputDependencies(server) {
+  return server.currentOutput?.steps.flatMap((step, i) => {
+    if (Array.isArray(step.entrypoints) && i === 0) {
+      return [];
+    }
+    return step.chunks.flatMap((chunk) => {
+      if (chunk.type === "asset") return [];
+      return chunk.moduleIds;
+    });
+  }).filter(
+    (file) => !file.includes("node_modules") && !file.startsWith("\0")
+  ).map(unnormalizePath).filter((file) => !file.startsWith(wxt.config.root)) ?? [];
+}

package/dist/core/define-config.d.ts

@@ -0,0 +1,2 @@
+import { UserConfig } from '../types';
+export declare function defineConfig(config: UserConfig): UserConfig;

package/dist/core/define-config.mjs

@@ -0,0 +1,3 @@
+export function defineConfig(config) {
+  return config;
+}

package/dist/core/define-runner-config.d.ts

@@ -0,0 +1,2 @@
+import { ExtensionRunnerConfig } from '../types';
+export declare function defineRunnerConfig(config: ExtensionRunnerConfig): ExtensionRunnerConfig;

package/dist/core/define-runner-config.mjs

@@ -0,0 +1,3 @@
+export function defineRunnerConfig(config) {
+  return config;
+}

package/dist/core/index.d.ts

@@ -0,0 +1,8 @@
+export * from './build';
+export * from './clean';
+export * from './define-config';
+export * from './define-runner-config';
+export * from './create-server';
+export * from './initialize';
+export * from './prepare';
+export * from './zip';

package/dist/core/index.mjs

@@ -0,0 +1,8 @@
+export * from "./build.mjs";
+export * from "./clean.mjs";
+export * from "./define-config.mjs";
+export * from "./define-runner-config.mjs";
+export * from "./create-server.mjs";
+export * from "./initialize.mjs";
+export * from "./prepare.mjs";
+export * from "./zip.mjs";