@modern-js/runtime 2.65.1 → 2.65.3

package/dist/esm/core/server/stream/shared.js

@@ -1,9 +1,7 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
-import { run } from "@modern-js/runtime-utils/node";
 import { time } from "@modern-js/runtime-utils/time";
-import { parseHeaders } from "@modern-js/runtime-utils/universal/request";
 import { wrapRuntimeContextProvider } from "../../react/wrapper";
 import { SSRErrors, SSRTimings } from "../tracer";
 import { getSSRConfigByEntry } from "../utils";
@@ -34,7 +32,7 @@ function getReadableStreamFromString(content) {
 function createRenderStreaming(createReadableStreamPromise) {
   return function() {
     var _ref = _async_to_generator(function(request, serverRoot, options) {
-      var createReadableStreamFromElement, headersData;
+      var createReadableStreamFromElement, end, runtimeContext, config, resource, onError, onTiming, htmlTemplate, entryName, ssrConfig, RSCServerRoot, rootElement, stream;
       return _ts_generator(this, function(_state) {
         switch (_state.label) {
           case 0:
@@ -44,68 +42,56 @@ function createRenderStreaming(createReadableStreamPromise) {
             ];
           case 1:
             createReadableStreamFromElement = _state.sent();
-            headersData = parseHeaders(request);
+            end = time();
+            runtimeContext = options.runtimeContext, config = options.config, resource = options.resource;
+            onError = options.onError, onTiming = options.onTiming;
+            htmlTemplate = resource.htmlTemplate, entryName = resource.entryName;
+            ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries);
+            RSCServerRoot = function(param) {
+              var children = param.children;
+              return /* @__PURE__ */ _jsx(_Fragment, {
+                children
+              });
+            };
+            rootElement = wrapRuntimeContextProvider(serverRoot, Object.assign(runtimeContext, {
+              ssr: true
+            }));
+            rootElement = /* @__PURE__ */ _jsx(RSCServerRoot, {
+              children: rootElement
+            });
+            return [
+              4,
+              createReadableStreamFromElement(request, rootElement, {
+                config,
+                htmlTemplate,
+                runtimeContext,
+                ssrConfig,
+                entryName,
+                rscClientManifest: options.rscClientManifest,
+                rscSSRManifest: options.rscSSRManifest,
+                rscServerManifest: options.rscServerManifest,
+                rscRoot: options.rscRoot,
+                onShellReady: function onShellReady() {
+                  var cost = end();
+                  onTiming(SSRTimings.RENDER_SHELL, cost);
+                },
+                onAllReady: function onAllReady() {
+                  var cost = end();
+                  onTiming(SSRTimings.RENDER_HTML, cost);
+                },
+                onShellError: function onShellError(error) {
+                  onError(error, SSRErrors.RENDER_SHELL);
+                },
+                onError: function onError1(error) {
+                  onError(error, SSRErrors.RENDER_STREAM);
+                }
+              })
+            ];
+          case 2:
+            stream = _state.sent();
             return [
               2,
-              run(headersData, /* @__PURE__ */ _async_to_generator(function() {
-                var end, runtimeContext, config, resource, onError, onTiming, htmlTemplate, entryName, ssrConfig, RSCServerRoot, rootElement, stream;
-                return _ts_generator(this, function(_state2) {
-                  switch (_state2.label) {
-                    case 0:
-                      end = time();
-                      runtimeContext = options.runtimeContext, config = options.config, resource = options.resource;
-                      onError = options.onError, onTiming = options.onTiming;
-                      htmlTemplate = resource.htmlTemplate, entryName = resource.entryName;
-                      ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries);
-                      RSCServerRoot = function(param) {
-                        var children = param.children;
-                        return /* @__PURE__ */ _jsx(_Fragment, {
-                          children
-                        });
-                      };
-                      rootElement = wrapRuntimeContextProvider(serverRoot, Object.assign(runtimeContext, {
-                        ssr: true
-                      }));
-                      rootElement = /* @__PURE__ */ _jsx(RSCServerRoot, {
-                        children: rootElement
-                      });
-                      return [
-                        4,
-                        createReadableStreamFromElement(request, rootElement, {
-                          config,
-                          htmlTemplate,
-                          runtimeContext,
-                          ssrConfig,
-                          entryName,
-                          rscClientManifest: options.rscClientManifest,
-                          rscSSRManifest: options.rscSSRManifest,
-                          rscServerManifest: options.rscServerManifest,
-                          rscRoot: options.rscRoot,
-                          onShellReady: function onShellReady() {
-                            var cost = end();
-                            onTiming(SSRTimings.RENDER_SHELL, cost);
-                          },
-                          onAllReady: function onAllReady() {
-                            var cost = end();
-                            onTiming(SSRTimings.RENDER_HTML, cost);
-                          },
-                          onShellError: function onShellError(error) {
-                            onError(error, SSRErrors.RENDER_SHELL);
-                          },
-                          onError: function onError1(error) {
-                            onError(error, SSRErrors.RENDER_STREAM);
-                          }
-                        })
-                      ];
-                    case 1:
-                      stream = _state2.sent();
-                      return [
-                        2,
-                        stream
-                      ];
-                  }
-                });
-              }))
+              stream
             ];
         }
       });

package/dist/esm/core/server/string/index.js

@@ -1,9 +1,7 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import { run } from "@modern-js/runtime-utils/node";
 import { time } from "@modern-js/runtime-utils/time";
-import { parseHeaders } from "@modern-js/runtime-utils/universal/request";
 import ReactDomServer from "react-dom/server";
 import ReactHelmet from "react-helmet";
 import { RenderLevel } from "../../constants";
@@ -19,98 +17,89 @@ import { SSRDataCollector } from "./ssrData";
 import { StyledCollector } from "./styledComponent";
 var renderString = function() {
   var _ref = _async_to_generator(function(request, serverRoot, options) {
-    var headersData;
+    var _runtimeContext_ssrContext, resource, runtimeContext, config, onError, onTiming, tracer, routerContext, htmlTemplate, entryName, loadableStats, routeManifest, ssrConfig, chunkSet, prefetchData, e, collectors, rootElement, html;
     return _ts_generator(this, function(_state) {
-      headersData = parseHeaders(request);
-      return [
-        2,
-        run(headersData, /* @__PURE__ */ _async_to_generator(function() {
-          var _runtimeContext_ssrContext, resource, runtimeContext, config, onError, onTiming, tracer, routerContext, htmlTemplate, entryName, loadableStats, routeManifest, ssrConfig, chunkSet, prefetchData, e, collectors, rootElement, html;
-          return _ts_generator(this, function(_state2) {
-            switch (_state2.label) {
-              case 0:
-                resource = options.resource, runtimeContext = options.runtimeContext, config = options.config, onError = options.onError, onTiming = options.onTiming;
-                tracer = {
-                  onError,
-                  onTiming
-                };
-                routerContext = runtimeContext.routerContext;
-                htmlTemplate = resource.htmlTemplate, entryName = resource.entryName, loadableStats = resource.loadableStats, routeManifest = resource.routeManifest;
-                ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries);
-                chunkSet = {
-                  renderLevel: RenderLevel.CLIENT_RENDER,
-                  ssrScripts: "",
-                  jsChunk: "",
-                  cssChunk: ""
-                };
-                prefetchData = {};
-                _state2.label = 1;
-              case 1:
-                _state2.trys.push([
-                  1,
-                  3,
-                  ,
-                  4
-                ]);
-                return [
-                  4,
-                  prefetch(serverRoot, request, options, ssrConfig, tracer)
-                ];
-              case 2:
-                prefetchData = _state2.sent();
-                chunkSet.renderLevel = RenderLevel.SERVER_PREFETCH;
-                return [
-                  3,
-                  4
-                ];
-              case 3:
-                e = _state2.sent();
-                chunkSet.renderLevel = RenderLevel.CLIENT_RENDER;
-                tracer.onError(e, SSRErrors.PRERENDER);
-                return [
-                  3,
-                  4
-                ];
-              case 4:
-                collectors = [
-                  new StyledCollector(chunkSet),
-                  new LoadableCollector({
-                    stats: loadableStats,
-                    nonce: config.nonce,
-                    routeManifest,
-                    template: htmlTemplate,
-                    entryName,
-                    chunkSet,
-                    config
-                  }),
-                  new SSRDataCollector({
-                    request,
-                    prefetchData,
-                    ssrConfig,
-                    ssrContext: runtimeContext.ssrContext,
-                    chunkSet,
-                    routerContext,
-                    nonce: config.nonce,
-                    useJsonScript: config.useJsonScript
-                  })
-                ];
-                rootElement = wrapRuntimeContextProvider(serverRoot, Object.assign(runtimeContext, {
-                  ssr: true
-                }));
-                return [
-                  4,
-                  generateHtml(rootElement, htmlTemplate, chunkSet, collectors, ((_runtimeContext_ssrContext = runtimeContext.ssrContext) === null || _runtimeContext_ssrContext === void 0 ? void 0 : _runtimeContext_ssrContext.htmlModifiers) || [], tracer)
-                ];
-              case 5:
-                html = _state2.sent();
-                return [
-                  2,
-                  html
-                ];
-            }
-          });
-        }))
-      ];
+      switch (_state.label) {
+        case 0:
+          resource = options.resource, runtimeContext = options.runtimeContext, config = options.config, onError = options.onError, onTiming = options.onTiming;
+          tracer = {
+            onError,
+            onTiming
+          };
+          routerContext = runtimeContext.routerContext;
+          htmlTemplate = resource.htmlTemplate, entryName = resource.entryName, loadableStats = resource.loadableStats, routeManifest = resource.routeManifest;
+          ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries);
+          chunkSet = {
+            renderLevel: RenderLevel.CLIENT_RENDER,
+            ssrScripts: "",
+            jsChunk: "",
+            cssChunk: ""
+          };
+          prefetchData = {};
+          _state.label = 1;
+        case 1:
+          _state.trys.push([
+            1,
+            3,
+            ,
+            4
+          ]);
+          return [
+            4,
+            prefetch(serverRoot, request, options, ssrConfig, tracer)
+          ];
+        case 2:
+          prefetchData = _state.sent();
+          chunkSet.renderLevel = RenderLevel.SERVER_PREFETCH;
+          return [
+            3,
+            4
+          ];
+        case 3:
+          e = _state.sent();
+          chunkSet.renderLevel = RenderLevel.CLIENT_RENDER;
+          tracer.onError(e, SSRErrors.PRERENDER);
+          return [
+            3,
+            4
+          ];
+        case 4:
+          collectors = [
+            new StyledCollector(chunkSet),
+            new LoadableCollector({
+              stats: loadableStats,
+              nonce: config.nonce,
+              routeManifest,
+              template: htmlTemplate,
+              entryName,
+              chunkSet,
+              config
+            }),
+            new SSRDataCollector({
+              request,
+              prefetchData,
+              ssrConfig,
+              ssrContext: runtimeContext.ssrContext,
+              chunkSet,
+              routerContext,
+              nonce: config.nonce,
+              useJsonScript: config.useJsonScript
+            })
+          ];
+          rootElement = wrapRuntimeContextProvider(serverRoot, Object.assign(runtimeContext, {
+            ssr: true
+          }));
+          return [
+            4,
+            generateHtml(rootElement, htmlTemplate, chunkSet, collectors, ((_runtimeContext_ssrContext = runtimeContext.ssrContext) === null || _runtimeContext_ssrContext === void 0 ? void 0 : _runtimeContext_ssrContext.htmlModifiers) || [], tracer)
+          ];
+        case 5:
+          html = _state.sent();
+          return [
+            2,
+            html
+          ];
+      }
     });
   });
   return function renderString2(request, serverRoot, options) {

package/dist/esm/core/server/string/prefetch.js

@@ -1,110 +1,99 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { ChunkExtractor } from "@loadable/server";
-import { run } from "@modern-js/runtime-utils/node";
 import { time } from "@modern-js/runtime-utils/time";
-import { parseHeaders } from "@modern-js/runtime-utils/universal/request";
 import { renderToStaticMarkup } from "react-dom/server";
 import { wrapRuntimeContextProvider } from "../../react/wrapper";
 import { SSRErrors, SSRTimings } from "../tracer";
 var prefetch = function() {
   var _ref = _async_to_generator(function(App, request, options, ssrConfig, param) {
-    var onError, onTiming, headersData, context, resource, entryName, loadableStats;
+    var onError, onTiming, _context_store, context, resource, entryName, loadableStats, end, extractor, cost, error, loadersData, end1, cost1, e;
     return _ts_generator(this, function(_state) {
-      onError = param.onError, onTiming = param.onTiming;
-      headersData = parseHeaders(request);
-      context = options.runtimeContext, resource = options.resource;
-      entryName = resource.entryName, loadableStats = resource.loadableStats;
-      return [
-        2,
-        run(headersData, /* @__PURE__ */ _async_to_generator(function() {
-          var _context_store, end, extractor, cost, error, loadersData, end1, cost1, e;
-          return _ts_generator(this, function(_state2) {
-            switch (_state2.label) {
-              case 0:
-                if (typeof ssrConfig === "boolean" || !ssrConfig.disablePrerender) {
-                  try {
-                    end = time();
-                    if (loadableStats) {
-                      extractor = new ChunkExtractor({
-                        stats: loadableStats,
-                        entrypoints: [
-                          entryName
-                        ].filter(Boolean)
-                      });
-                      renderToStaticMarkup(extractor.collectChunks(wrapRuntimeContextProvider(App, Object.assign(context, {
-                        ssr: false
-                      }))));
-                    } else {
-                      renderToStaticMarkup(wrapRuntimeContextProvider(App, Object.assign(context, {
-                        ssr: false
-                      })));
-                    }
-                    cost = end();
-                    onTiming(SSRTimings.PRERENDER, cost);
-                  } catch (e2) {
-                    error = e2;
-                    onError(error, SSRErrors.PRERENDER);
-                    throw e2;
-                  }
-                }
-                if (!context.loaderManager.hasPendingLoaders()) {
-                  return [
-                    2,
-                    {
-                      initialData: context.initialData,
-                      i18nData: context.__i18nData__
-                    }
-                  ];
-                }
-                loadersData = {};
-                _state2.label = 1;
-              case 1:
-                _state2.trys.push([
-                  1,
-                  3,
-                  ,
-                  4
-                ]);
-                end1 = time();
-                return [
-                  4,
-                  context.loaderManager.awaitPendingLoaders()
-                ];
-              case 2:
-                loadersData = _state2.sent();
-                cost1 = end1();
-                onTiming(SSRTimings.USE_LOADER, cost1);
-                return [
-                  3,
-                  4
-                ];
-              case 3:
-                e = _state2.sent();
-                onError(e, SSRErrors.USE_LOADER);
-                throw e;
-              case 4:
-                Object.keys(loadersData).forEach(function(id) {
-                  var data = loadersData[id];
-                  if (data._error) {
-                    onError(data._error, SSRErrors.USE_LOADER);
-                    delete data._error;
-                  }
+      switch (_state.label) {
+        case 0:
+          onError = param.onError, onTiming = param.onTiming;
+          context = options.runtimeContext, resource = options.resource;
+          entryName = resource.entryName, loadableStats = resource.loadableStats;
+          if (typeof ssrConfig === "boolean" || !ssrConfig.disablePrerender) {
+            try {
+              end = time();
+              if (loadableStats) {
+                extractor = new ChunkExtractor({
+                  stats: loadableStats,
+                  entrypoints: [
+                    entryName
+                  ].filter(Boolean)
                 });
-                return [
-                  2,
-                  {
-                    loadersData,
-                    initialData: context.initialData,
-                    i18nData: context.__i18nData__,
-                    // todo: move to plugin state
-                    storeState: context === null || context === void 0 ? void 0 : (_context_store = context.store) === null || _context_store === void 0 ? void 0 : _context_store.getState()
-                  }
-                ];
+                renderToStaticMarkup(extractor.collectChunks(wrapRuntimeContextProvider(App, Object.assign(context, {
+                  ssr: false
+                }))));
+              } else {
+                renderToStaticMarkup(wrapRuntimeContextProvider(App, Object.assign(context, {
+                  ssr: false
+                })));
+              }
+              cost = end();
+              onTiming(SSRTimings.PRERENDER, cost);
+            } catch (e2) {
+              error = e2;
+              onError(error, SSRErrors.PRERENDER);
+              throw e2;
+            }
+          }
+          if (!context.loaderManager.hasPendingLoaders()) {
+            return [
+              2,
+              {
+                initialData: context.initialData,
+                i18nData: context.__i18nData__
+              }
+            ];
+          }
+          loadersData = {};
+          _state.label = 1;
+        case 1:
+          _state.trys.push([
+            1,
+            3,
+            ,
+            4
+          ]);
+          end1 = time();
+          return [
+            4,
+            context.loaderManager.awaitPendingLoaders()
+          ];
+        case 2:
+          loadersData = _state.sent();
+          cost1 = end1();
+          onTiming(SSRTimings.USE_LOADER, cost1);
+          return [
+            3,
+            4
+          ];
+        case 3:
+          e = _state.sent();
+          onError(e, SSRErrors.USE_LOADER);
+          throw e;
+        case 4:
+          Object.keys(loadersData).forEach(function(id) {
+            var data = loadersData[id];
+            if (data._error) {
+              onError(data._error, SSRErrors.USE_LOADER);
+              delete data._error;
             }
           });
-        }))
-      ];
+          return [
+            2,
+            {
+              loadersData,
+              initialData: context.initialData,
+              i18nData: context.__i18nData__,
+              // todo: move to plugin state
+              storeState: context === null || context === void 0 ? void 0 : (_context_store = context.store) === null || _context_store === void 0 ? void 0 : _context_store.getState()
+            }
+          ];
+      }
     });
   });
   return function prefetch2(App, request, options, ssrConfig, _) {

package/dist/esm/index.js

@@ -1,4 +1,7 @@
 import { isBrowser } from "./common";
+import { getMonitors } from "./core/context/monitors";
+import { getRequest } from "./core/context/request";
+import { setHeaders, setStatus, redirect } from "./core/context/response";
 import { createApp, useLoader, bootstrap, RuntimeReactContext, defineConfig, defineRuntimeConfig, useRuntimeContext } from "./core";
 export {
   RuntimeReactContext,
@@ -6,7 +9,12 @@ export {
   createApp,
   defineConfig,
   defineRuntimeConfig,
+  getMonitors,
+  getRequest,
   isBrowser,
+  redirect,
+  setHeaders,
+  setStatus,
   useLoader,
   useRuntimeContext
 };

package/dist/esm/react-server.js

@@ -0,0 +1,10 @@
+import { getRequest } from "./core/context/request";
+import { getMonitors } from "./core/context/monitors";
+import { setHeaders, setStatus, redirect } from "./core/context/response";
+export {
+  getMonitors,
+  getRequest,
+  redirect,
+  setHeaders,
+  setStatus
+};

package/dist/esm/router/cli/code/templates.js

@@ -433,11 +433,11 @@ function ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext) {
 }
 var runtimeGlobalContext = function() {
   var _ref = _async_to_generator(function(param) {
-    var metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp, imports, rootLayoutPath, rootLayoutFile, rootLayoutBuffer, rootLayout, _ref2, moduleExports, hasAppConfig, hasAppInit, layoutPath;
+    var entryName, metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp, imports, rootLayoutPath, rootLayoutFile, rootLayoutBuffer, rootLayout, _ref2, moduleExports, hasAppConfig, hasAppInit, layoutPath;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
-          metaName = param.metaName, srcDirectory = param.srcDirectory, nestedRoutesEntry = param.nestedRoutesEntry, internalSrcAlias = param.internalSrcAlias, globalApp = param.globalApp;
+          entryName = param.entryName, metaName = param.metaName, srcDirectory = param.srcDirectory, nestedRoutesEntry = param.nestedRoutesEntry, internalSrcAlias = param.internalSrcAlias, globalApp = param.globalApp;
           imports = [
             "import { setGlobalContext } from '@".concat(metaName, "/runtime/context';")
           ];
@@ -514,7 +514,7 @@ var runtimeGlobalContext = function() {
           }
           return [
             2,
-            "".concat(imports.join("\n"), "\n\nimport { routes } from './routes';\n\nsetGlobalContext({\n  layoutApp,\n  routes,\n  appInit,\n  appConfig,\n});")
+            "".concat(imports.join("\n"), "\n\nimport { routes } from './routes';\n\nconst entryName = '").concat(entryName, "';\nsetGlobalContext({\n  entryName,\n  layoutApp,\n  routes,\n  appInit,\n  appConfig,\n});")
           ];
       }
     });

package/dist/esm/router/cli/handler.js

@@ -67,6 +67,7 @@ function _handleGeneratorEntryCode() {
                       return [
                         4,
                         templates.runtimeGlobalContext({
+                          entryName: entrypoint.entryName,
                           metaName: appContext.metaName,
                           srcDirectory: appContext.srcDirectory,
                           nestedRoutesEntry: entrypoint.nestedRoutesEntry,

package/dist/esm/router/runtime/plugin.node.js

@@ -72,8 +72,7 @@ var routerPlugin = function() {
                   ssrMode,
                   props: {
                     nonce
-                  },
-                  reporter
+                  }
                 }));
                 routes = hooks.modifyRoutes.call(routes);
                 query = createStaticHandler(routes, {

package/dist/esm/router/runtime/utils.js

@@ -10,7 +10,7 @@ import { Route, isRouteErrorResponse } from "@modern-js/runtime-utils/router";
 import { DefaultNotFound } from "./DefaultNotFound";
 import DeferredDataScripts from "./DeferredDataScripts";
 function getRouteComponents(routes, param) {
-  var globalApp = param.globalApp, ssrMode = param.ssrMode, props = param.props, reporter = param.reporter;
+  var globalApp = param.globalApp, ssrMode = param.ssrMode, props = param.props;
   var Layout = function(_param) {
     var Component = _param.Component, props2 = _object_without_properties(_param, [
       "Component"
@@ -31,8 +31,7 @@ function getRouteComponents(routes, param) {
       if (route.type === "nested") {
         var routeElement = renderNestedRoute(route, {
           DeferredDataComponent: ssrMode === "stream" ? DeferredDataScripts : void 0,
-          props,
-          reporter
+          props
         });
         routeElements.push(routeElement);
       } else {
@@ -66,7 +65,7 @@ function getRouteComponents(routes, param) {
   return routeElements;
 }
 function renderRoutes(param) {
-  var routesConfig = param.routesConfig, props = param.props, ssrMode = param.ssrMode, reporter = param.reporter;
+  var routesConfig = param.routesConfig, props = param.props, ssrMode = param.ssrMode;
   if (!routesConfig) {
     return null;
   }
@@ -77,8 +76,7 @@ function renderRoutes(param) {
   var routeElements = getRouteComponents(routes, {
     globalApp,
     ssrMode,
-    props,
-    reporter
+    props
   });
   return routeElements;
 }

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

@@ -0,0 +1 @@
+export * from "@modern-js/runtime-utils/cache";

package/dist/esm-node/cli/code.js

@@ -99,6 +99,7 @@ const generateCode = async (entrypoints, appContext, config, hooks) => {
       let contextCode = "";
       if (!config.server.rsc) {
         contextCode = template.runtimeGlobalContext({
+          entryName,
           srcDirectory,
           internalSrcAlias,
           metaName,

package/dist/esm-node/cli/ssr/index.js

@@ -87,7 +87,7 @@ const ssrPlugin = () => ({
         source: {
           alias: {
             // ensure that all packages use the same storage in @modern-js/runtime-utils/node
-            "@modern-js/runtime-utils/node$": require.resolve("@modern-js/runtime-utils/node")
+            "@modern-js/runtime-utils/node$": require.resolve("@modern-js/runtime-utils/node").replace(`${path.sep}cjs${path.sep}`, `${path.sep}esm${path.sep}`)
           }
         },
         tools: {