@modern-js/app-tools 2.57.2-alpha.0 → 2.58.1-alpha.0

package/dist/esm/plugins/deploy/dependencies/index.js

@@ -1,4 +1,6 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
 import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
 import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
@@ -7,15 +9,21 @@ import path from "node:path";
 import { fs as fse, pkgUp, semver } from "@modern-js/utils";
 import { readPackageJSON } from "pkg-types";
 import { parseNodeModulePath } from "mlly";
-import { linkPackage, writePackage, isFile, findEntryFiles, traceFiles as defaultTraceFiles, findPackageParents, resolveTracedPath, readDirRecursive } from "./utils";
+import { linkPackage, writePackage, isFile, findEntryFiles, traceFiles as defaultTraceFiles, findPackageParents, resolveTracedPath, readDirRecursive, isSubPath } from "./utils";
+import { nodeFileTrace } from "@vercel/nft";
 var handleDependencies = function() {
   var _ref = _async_to_generator(function(param) {
-    var appDir, serverRootDir, includeEntries, _param_traceFiles, traceFiles, entryFilter, modifyPackageJson, copyWholePackage, base, entryFiles, fileTrace, currentProjectModules, tracedFiles, _, tracedPackages, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, tracedFile, pkgName, tracedPackage, pkgJSON, tracedPackageVersion, shouldCopyWholePackage, _tracedPackageVersion_files, allFiles, err, multiVersionPkgs, singleVersionPackages, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, tracedPackage1, versions, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, version, projectPkgJson, _iteratorNormalCompletion3, _didIteratorError3, _iteratorError3, _loop, _iterator3, _step3, err, outputPkgPath, newPkgJson, finalPkgJson;
+    var appDir, serverRootDir, includeEntries, _param_traceFiles, traceFiles, entryFilter, modifyPackageJson, copyWholePackage, _param_cacheOptions, cacheOptions, traceOptions, base, startTime, entryFiles, fileTrace, currentProjectModules, dependencySearchRoot, tracedFiles, _, tracedPackages, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, tracedFile, pkgName, tracedPackage, pkgJSON, tracedPackageVersion, shouldCopyWholePackage, _tracedPackageVersion_files, allFiles, err, multiVersionPkgs, singleVersionPackages, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, tracedPackage1, versions, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, version, projectPkgJson, _iteratorNormalCompletion3, _didIteratorError3, _iteratorError3, _loop, _iterator3, _step3, err, outputPkgPath, newPkgJson, finalPkgJson, endTime;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
-          appDir = param.appDir, serverRootDir = param.serverRootDir, includeEntries = param.includeEntries, _param_traceFiles = param.traceFiles, traceFiles = _param_traceFiles === void 0 ? defaultTraceFiles : _param_traceFiles, entryFilter = param.entryFilter, modifyPackageJson = param.modifyPackageJson, copyWholePackage = param.copyWholePackage;
+          appDir = param.appDir, serverRootDir = param.serverRootDir, includeEntries = param.includeEntries, _param_traceFiles = param.traceFiles, traceFiles = _param_traceFiles === void 0 ? defaultTraceFiles : _param_traceFiles, entryFilter = param.entryFilter, modifyPackageJson = param.modifyPackageJson, copyWholePackage = param.copyWholePackage, _param_cacheOptions = param.cacheOptions, cacheOptions = _param_cacheOptions === void 0 ? {
+            cacheDir: ".modern-js/deploy",
+            fileCache: true,
+            analysisCache: true
+          } : _param_cacheOptions, traceOptions = param.traceOptions;
           base = "/";
+          startTime = Date.now();
           return [
             4,
             findEntryFiles(serverRootDir, entryFilter)
@@ -24,11 +32,20 @@ var handleDependencies = function() {
           entryFiles = _state.sent();
           return [
             4,
-            traceFiles(entryFiles.concat(includeEntries), serverRootDir, base)
+            traceFiles({
+              entryFiles: entryFiles.concat(includeEntries),
+              serverRootDir,
+              cacheOptions: _object_spread_props(_object_spread({}, cacheOptions), {
+                cacheDir: path.resolve(appDir, cacheOptions.cacheDir)
+              }),
+              base,
+              traceOptions
+            })
           ];
         case 2:
           fileTrace = _state.sent();
           currentProjectModules = path.join(appDir, "node_modules");
+          dependencySearchRoot = path.resolve(appDir, "../../../../../../");
           _ = Object.fromEntries;
           return [
             4,
@@ -50,7 +67,7 @@ var handleDependencies = function() {
                       ];
                     case 1:
                       filePath = _state2.sent();
-                      if (filePath.startsWith(serverRootDir) || filePath.startsWith(appDir) && !filePath.startsWith(currentProjectModules)) {
+                      if (isSubPath(serverRootDir, filePath) || isSubPath(appDir, filePath) && !isSubPath(currentProjectModules, filePath)) {
                         return [
                           2
                         ];
@@ -105,7 +122,7 @@ var handleDependencies = function() {
                       _state2.label = 6;
                     case 6:
                       packageJsonPath = _tmp;
-                      if (!packageJsonPath)
+                      if (!(packageJsonPath && isSubPath(dependencySearchRoot, packageJsonPath)))
                         return [
                           3,
                           8
@@ -138,7 +155,7 @@ var handleDependencies = function() {
                         path: filePath,
                         parents,
                         isDirectDep: parents.some(function(parent) {
-                          return parent.startsWith(appDir) && !parent.startsWith(currentProjectModules);
+                          return isSubPath(appDir, parent) && !isSubPath(currentProjectModules, parent);
                         }),
                         subpath,
                         pkgName: pkgName2,
@@ -591,6 +608,8 @@ var handleDependencies = function() {
           ];
         case 24:
           _state.sent();
+          endTime = Date.now();
+          console.log("handleDependencies cost:", endTime - startTime);
           return [
             2
           ];
@@ -602,5 +621,6 @@ var handleDependencies = function() {
   };
 }();
 export {
-  handleDependencies
+  handleDependencies,
+  nodeFileTrace
 };

package/dist/esm/plugins/deploy/dependencies/utils.js

@@ -1,4 +1,7 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
 import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import path from "path";
@@ -334,30 +337,299 @@ var findPackageParents = function(pkg, version, tracedFiles) {
     return parentPkg;
   });
 };
-var traceFiles = function() {
-  var _ref = _async_to_generator(function(entryFiles, serverRootDir) {
-    var base;
-    var _arguments = arguments;
+function serializeMap(map) {
+  return _serializeMap.apply(this, arguments);
+}
+function _serializeMap() {
+  _serializeMap = // function serializeMap(map: Map<string, any>) {
+  //   return JSON.stringify(map, (key, value) => {
+  //     if (value instanceof Map) {
+  //       return {
+  //         dataType: 'Map',
+  //         value: [...value.entries()],
+  //       };
+  //     }
+  //     if (value instanceof Set) {
+  //       return {
+  //         dataType: 'Set',
+  //         value: [...value],
+  //       };
+  //     }
+  //     return value;
+  //   });
+  // }
+  _async_to_generator(function(map) {
+    var resolvedMap;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
-          base = _arguments.length > 2 && _arguments[2] !== void 0 ? _arguments[2] : "/";
+          resolvedMap = /* @__PURE__ */ new Map();
           return [
             4,
-            nodeFileTrace(entryFiles, {
-              base,
-              processCwd: serverRootDir
-            })
+            Promise.all(Array.from(map.entries()).map(function() {
+              var _ref = _async_to_generator(function(param) {
+                var _param, key, value, _, _tmp, _tmp1;
+                return _ts_generator(this, function(_state2) {
+                  switch (_state2.label) {
+                    case 0:
+                      _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
+                      _ = resolvedMap.set;
+                      _tmp = [
+                        key
+                      ];
+                      if (!_instanceof(value, Promise))
+                        return [
+                          3,
+                          2
+                        ];
+                      return [
+                        4,
+                        Promise.resolve(value)
+                      ];
+                    case 1:
+                      _tmp1 = _state2.sent();
+                      return [
+                        3,
+                        3
+                      ];
+                    case 2:
+                      _tmp1 = value;
+                      _state2.label = 3;
+                    case 3:
+                      _.apply(resolvedMap, _tmp.concat([
+                        _tmp1
+                      ]));
+                      return [
+                        2
+                      ];
+                  }
+                });
+              });
+              return function(_) {
+                return _ref.apply(this, arguments);
+              };
+            }()))
           ];
         case 1:
+          _state.sent();
           return [
             2,
+            JSON.stringify(resolvedMap, function(key, value) {
+              if (_instanceof(value, Map)) {
+                return {
+                  dataType: "Map",
+                  value: Array.from(value.entries())
+                };
+              }
+              if (_instanceof(value, Set)) {
+                return {
+                  dataType: "Set",
+                  value: Array.from(value)
+                };
+              }
+              return value;
+            })
+          ];
+      }
+    });
+  });
+  return _serializeMap.apply(this, arguments);
+}
+function deserializeMap(serializedData) {
+  return JSON.parse(serializedData, function(key, value) {
+    if (value && value.dataType === "Map") {
+      return new Map(value.value);
+    }
+    if (value && value.dataType === "Set") {
+      return new Set(value.value);
+    }
+    return value;
+  });
+}
+var traceFiles = function() {
+  var _ref = _async_to_generator(function(param) {
+    var entryFiles, serverRootDir, _param_base, base, cacheOptions, traceOptions, cacheDir, enableFileCache, enableAnalysisCache, analysisCacheFile, fileCacheFile, cache, _tmp, analysisCache, _tmp1, fileCache, res, analysisCache1, fileCache1, newAnalysisCache, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, key, _, _tmp2, newFileCache, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, key1, _1, _tmp3;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          entryFiles = param.entryFiles, serverRootDir = param.serverRootDir, _param_base = param.base, base = _param_base === void 0 ? "/" : _param_base, cacheOptions = param.cacheOptions, traceOptions = param.traceOptions;
+          cacheDir = cacheOptions.cacheDir, enableFileCache = cacheOptions.fileCache, enableAnalysisCache = cacheOptions.analysisCache;
+          analysisCacheFile = path.join(cacheDir, "analysis-cache.json");
+          fileCacheFile = path.join(cacheDir, "file-cache.json");
+          cache = /* @__PURE__ */ Object.create(null);
+          _tmp = enableAnalysisCache;
+          if (!_tmp)
+            return [
+              3,
+              2
+            ];
+          return [
+            4,
+            fse.pathExists(analysisCacheFile)
+          ];
+        case 1:
+          _tmp = _state.sent();
+          _state.label = 2;
+        case 2:
+          if (!_tmp)
+            return [
+              3,
+              4
+            ];
+          return [
+            4,
+            fse.readFile(analysisCacheFile)
+          ];
+        case 3:
+          analysisCache = _state.sent().toString();
+          cache.analysisCache = deserializeMap(analysisCache);
+          _state.label = 4;
+        case 4:
+          _tmp1 = enableFileCache;
+          if (!_tmp1)
+            return [
+              3,
+              6
+            ];
+          return [
+            4,
+            fse.pathExists(fileCacheFile)
+          ];
+        case 5:
+          _tmp1 = _state.sent();
+          _state.label = 6;
+        case 6:
+          if (!_tmp1)
+            return [
+              3,
+              8
+            ];
+          return [
+            4,
+            fse.readFile(fileCacheFile)
+          ];
+        case 7:
+          fileCache = _state.sent().toString();
+          cache.fileCache = deserializeMap(fileCache);
+          _state.label = 8;
+        case 8:
+          return [
+            4,
+            nodeFileTrace(entryFiles, _object_spread({
+              base,
+              processCwd: serverRootDir,
+              cache
+            }, traceOptions))
+          ];
+        case 9:
+          res = _state.sent();
+          analysisCache1 = cache.analysisCache, fileCache1 = cache.fileCache;
+          if (!(analysisCache1 || fileCache1))
+            return [
+              3,
+              14
+            ];
+          return [
+            4,
+            fse.ensureDir(cacheDir)
+          ];
+        case 10:
+          _state.sent();
+          if (!analysisCache1)
+            return [
+              3,
+              12
+            ];
+          newAnalysisCache = new Map(analysisCache1);
+          _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+          try {
+            for (_iterator = newAnalysisCache.keys()[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+              key = _step.value;
+              if (!key.includes("node_modules/")) {
+                newAnalysisCache.delete(key);
+              }
+            }
+          } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+              }
+            } finally {
+              if (_didIteratorError) {
+                throw _iteratorError;
+              }
+            }
+          }
+          _ = fse.writeFile;
+          _tmp2 = [
+            analysisCacheFile
+          ];
+          return [
+            4,
+            serializeMap(newAnalysisCache)
+          ];
+        case 11:
+          _.apply(fse, _tmp2.concat([
+            _state.sent()
+          ]));
+          _state.label = 12;
+        case 12:
+          if (!fileCache1)
+            return [
+              3,
+              14
+            ];
+          newFileCache = new Map(fileCache1);
+          _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
+          try {
+            for (_iterator1 = newFileCache.keys()[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+              key1 = _step1.value;
+              if (!key1.includes("node_modules/")) {
+                newFileCache.delete(key1);
+              }
+            }
+          } catch (err) {
+            _didIteratorError1 = true;
+            _iteratorError1 = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                _iterator1.return();
+              }
+            } finally {
+              if (_didIteratorError1) {
+                throw _iteratorError1;
+              }
+            }
+          }
+          console.time("111");
+          _1 = fse.writeFile;
+          _tmp3 = [
+            fileCacheFile
+          ];
+          return [
+            4,
+            serializeMap(newFileCache)
+          ];
+        case 13:
+          _1.apply(fse, _tmp3.concat([
             _state.sent()
+          ]));
+          console.timeEnd("111");
+          _state.label = 14;
+        case 14:
+          console.log("ffffffff", __filename);
+          return [
+            2,
+            res
           ];
       }
     });
   });
-  return function traceFiles2(entryFiles, serverRootDir) {
+  return function traceFiles2(_) {
     return _ref.apply(this, arguments);
   };
 }();
@@ -374,10 +646,18 @@ var resolveTracedPath = function() {
     return _ref.apply(this, arguments);
   };
 }();
+var isSubPath = function(parentPath, childPath) {
+  if (!parentPath || !childPath) {
+    return false;
+  }
+  var relative = path.relative(parentPath, childPath);
+  return relative && !relative.startsWith("..");
+};
 export {
   findEntryFiles,
   findPackageParents,
   isFile,
+  isSubPath,
   linkPackage,
   readDirRecursive,
   resolveTracedPath,

package/dist/esm/utils/config.js

@@ -5,6 +5,7 @@ import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import * as path from "path";
 import { bundle } from "@modern-js/node-bundle-require";
 import { fs, getServerConfig, ensureAbsolutePath, OUTPUT_CONFIG_FILE, CONFIG_FILE_EXTENSIONS } from "@modern-js/utils";
+import { stringify } from "flatted";
 var defineServerConfig = function(config) {
   return config;
 };
@@ -88,33 +89,18 @@ var buildServerConfig = function() {
     return _ref.apply(this, arguments);
   };
 }();
-var safeReplacer = function() {
-  var cache = [];
-  var keyCache = [];
-  return function safeReplacer2(key, value) {
-    if (typeof value === "object" && value !== null) {
-      var index = cache.indexOf(value);
-      if (index !== -1) {
-        return "[Circular ".concat(keyCache[index], "]");
-      }
-      cache.push(value);
-      keyCache.push(key || "root");
-    }
-    return value;
-  };
-};
 var emitResolvedConfig = function() {
   var _ref = _async_to_generator(function(appDirectory, resolvedConfig) {
-    var _resolvedConfig_output_distPath, outputPath;
+    var _resolvedConfig_output_distPath, outputPath, output;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
           outputPath = ensureAbsolutePath(appDirectory, path.join(((_resolvedConfig_output_distPath = resolvedConfig.output.distPath) === null || _resolvedConfig_output_distPath === void 0 ? void 0 : _resolvedConfig_output_distPath.root) || "./dist", OUTPUT_CONFIG_FILE));
+          output = stringify(resolvedConfig);
           return [
             4,
-            fs.writeJSON(outputPath, resolvedConfig, {
-              spaces: 2,
-              replacer: safeReplacer()
+            fs.writeFile(outputPath, output, {
+              encoding: "utf-8"
             })
           ];
         case 1:
@@ -132,6 +118,5 @@ var emitResolvedConfig = function() {
 export {
   buildServerConfig,
   defineServerConfig,
-  emitResolvedConfig,
-  safeReplacer
+  emitResolvedConfig
 };

package/dist/esm/utils/createServer.js

@@ -38,7 +38,7 @@ var createServer = function() {
             createDevServer(options, applyPlugins)
           ];
         case 1:
-          server = _state.sent();
+          server = _state.sent().server;
           return [
             2,
             server

package/dist/esm-node/builder/builder-rspack/adapterCopy.js

@@ -40,10 +40,10 @@ const builderPluginAdpaterCopy = (options) => ({
       const filepaths = (await fs.readdir(publicDir)).map((file) => path.resolve(publicDir, file));
       await Promise.all(filepaths.filter((file) => HTML_REGEXP.test(file)).map(async (file) => {
         const content = await fs.readFile(file, "utf-8");
-        if (publicPath) {
+        if (publicPath && typeof publicPath === "string") {
           await fs.writeFile(file, content.replace(/<%=\s*assetPrefix\s*%>/g, removeTailSlash(publicPath)));
         } else {
-          logger.warn("Expect get a string from `publicPath`, but receive `undefined`.");
+          logger.warn(`Expect get a string from \`publicPath\`, but receive \`${typeof publicPath}\`.`);
           await fs.writeFile(file, content.replace(/<%=\s*assetPrefix\s*%>/g, removeTailSlash("/")));
         }
       }));

package/dist/esm-node/builder/generator/getBuilderEnvironments.js

@@ -19,7 +19,7 @@ function getBuilderEnvironments(normalizedConfig, appContext) {
   const serverEntries = {};
   for (const entry in entries) {
     const v = entries[entry];
-    serverEntries[entry] = v.map((entry2) => entry2.replace("index.jsx", "index.server.jsx"));
+    serverEntries[entry] = v.map((entry2) => entry2.replace("index.jsx", "index.server.jsx")).map((entry2) => entry2.replace("bootstrap.jsx", "bootstrap.server.jsx"));
   }
   const environments = {
     web: {

package/dist/esm-node/builder/generator/index.js

@@ -17,7 +17,7 @@ async function generateBuilder(options, bundlerType) {
   return builder;
 }
 async function applyBuilderPlugins(builder, options) {
-  const { builderPluginAdapterBasic, builderPluginAdapterHtml, builderPluginAdapterSSR, builderPluginAdapterWorker } = await import("../shared/builderPlugins/index.js");
+  const { builderPluginAdapterBasic, builderPluginAdapterHtml, builderPluginAdapterSSR, builderPluginAdapterWorker } = await import("../shared/builderPlugins");
   builder.addPlugins([
     builderPluginAdapterBasic(),
     builderPluginAdapterSSR(options),

package/dist/esm-node/builder/index.js

@@ -1,9 +1,9 @@
 async function createBuilderGenerator(bundler) {
   if (bundler === "rspack") {
-    const { createRspackBuilderForModern } = await import("./builder-rspack/index.js");
+    const { createRspackBuilderForModern } = await import("./builder-rspack");
     return createRspackBuilderForModern;
   }
-  const { createWebpackBuilderForModern } = await import("./builder-webpack/index.js");
+  const { createWebpackBuilderForModern } = await import("./builder-webpack");
   return createWebpackBuilderForModern;
 }
 export {

package/dist/esm-node/builder/shared/builderPlugins/adapterBasic.js

@@ -24,7 +24,7 @@ function applyNodeCompat(isServiceWorker, chain) {
     ".node.ts",
     ".node.tsx",
     ".server.js",
-    ".server.ts",
+    ".server.jsx",
     ".server.ts",
     ".server.tsx"
   ];

package/dist/esm-node/commands/build.js

@@ -3,7 +3,9 @@ import { logger } from "@modern-js/utils";
 import { loadServerPlugins } from "../utils/loadPlugins";
 import { generateRoutes } from "../utils/routes";
 import { buildServerConfig } from "../utils/config";
+import { registerCompiler } from "../utils/register";
 const build = async (api, options) => {
+  var _resolvedConfig_source;
   if (options === null || options === void 0 ? void 0 : options.analyze) {
     process.env.BUNDLE_ANALYZE = "true";
   }
@@ -11,6 +13,7 @@ const build = async (api, options) => {
   const appContext = api.useAppContext();
   const hookRunners = api.useHookRunners();
   await loadServerPlugins(api, appContext.appDirectory, appContext.metaName);
+  await registerCompiler(appContext.appDirectory, appContext.distDirectory, resolvedConfig === null || resolvedConfig === void 0 ? void 0 : (_resolvedConfig_source = resolvedConfig.source) === null || _resolvedConfig_source === void 0 ? void 0 : _resolvedConfig_source.alias);
   const { apiOnly } = appContext;
   if (apiOnly) {
     const { appDirectory: appDirectory2, distDirectory: distDirectory2, serverConfigFile: serverConfigFile2 } = appContext;

package/dist/esm-node/commands/dev.js

@@ -1,27 +1,23 @@
 import path from "node:path";
 import { ResolvedConfigContext } from "@modern-js/core";
-import { DEFAULT_DEV_HOST, SERVER_DIR, getMeta } from "@modern-js/utils";
+import { DEFAULT_DEV_HOST, SERVER_DIR, getMeta, logger } from "@modern-js/utils";
 import { createDevServer } from "@modern-js/server";
 import { applyPlugins } from "@modern-js/prod-server";
 import { loadServerPlugins } from "../utils/loadPlugins";
+import { registerCompiler } from "../utils/register";
 import { printInstructions } from "../utils/printInstructions";
 import { setServer } from "../utils/createServer";
 import { generateRoutes } from "../utils/routes";
 import { buildServerConfig } from "../utils/config";
-const dev = async (api, options, devServerOptions = {}) => {
-  var _normalizedConfig_source, _normalizedConfig_tools;
+const dev = async (api, options, devServerOptions) => {
+  var _normalizedConfig_source, _normalizedConfig_tools, _normalizedConfig_dev;
   if (options.analyze) {
     process.env.BUNDLE_ANALYZE = "true";
   }
   let normalizedConfig = api.useResolvedConfigContext();
   const appContext = api.useAppContext();
   const hookRunners = api.useHookRunners();
-  const { registerEsm } = await import("../esm/register-esm.mjs");
-  await registerEsm({
-    appDir: appContext.appDirectory,
-    distDir: appContext.distDirectory,
-    alias: (_normalizedConfig_source = normalizedConfig.source) === null || _normalizedConfig_source === void 0 ? void 0 : _normalizedConfig_source.alias
-  });
+  await registerCompiler(appContext.appDirectory, appContext.distDirectory, normalizedConfig === null || normalizedConfig === void 0 ? void 0 : (_normalizedConfig_source = normalizedConfig.source) === null || _normalizedConfig_source === void 0 ? void 0 : _normalizedConfig_source.alias);
   normalizedConfig = {
     ...normalizedConfig,
     cliOptions: options
@@ -64,20 +60,32 @@ const dev = async (api, options, devServerOptions = {}) => {
     plugins: pluginInstances,
     ...devServerOptions
   };
+  const host = ((_normalizedConfig_dev = normalizedConfig.dev) === null || _normalizedConfig_dev === void 0 ? void 0 : _normalizedConfig_dev.host) || DEFAULT_DEV_HOST;
   if (apiOnly) {
-    var _normalizedConfig_dev;
-    const app = await createDevServer(serverOptions, applyPlugins);
-    const host = ((_normalizedConfig_dev = normalizedConfig.dev) === null || _normalizedConfig_dev === void 0 ? void 0 : _normalizedConfig_dev.host) || DEFAULT_DEV_HOST;
-    app.listen({
+    const { server } = await createDevServer({
+      ...serverOptions,
+      runCompile: false
+    }, (devServerOptions === null || devServerOptions === void 0 ? void 0 : devServerOptions.applyPlugins) || applyPlugins);
+    server.listen({
       port,
       host
     }, () => {
       printInstructions(hookRunners, appContext, normalizedConfig);
     });
   } else {
-    const { server } = await appContext.builder.startDevServer({
-      serverOptions,
-      applyPlugins
+    const { server, afterListen } = await createDevServer({
+      ...serverOptions,
+      builder: appContext.builder
+    }, (devServerOptions === null || devServerOptions === void 0 ? void 0 : devServerOptions.applyPlugins) || applyPlugins);
+    server.listen({
+      port,
+      host
+    }, async (err) => {
+      if (err) {
+        logger.error("Occur error %s, when start dev server", err);
+      }
+      logger.debug("listen dev server done");
+      await afterListen();
     });
     setServer(server);
   }