@modern-js/runtime 2.65.1 → 2.65.3

package/dist/cjs/core/server/requestHandler.js

@@ -21,6 +21,7 @@ __export(requestHandler_exports, {
   createRequestHandler: () => createRequestHandler
 });
 module.exports = __toCommonJS(requestHandler_exports);
+var import_node = require("@modern-js/runtime-utils/node");
 var import_request = require("@modern-js/runtime-utils/universal/request");
 var import_context = require("../context");
 var import_runtime = require("../context/runtime");
@@ -67,6 +68,7 @@ function createSSRContext(request, options) {
       params,
       headers: headersData,
       host,
+      referer: headers.get("referer"),
       raw: request
     },
     response: {
@@ -74,7 +76,7 @@ function createSSRContext(request, options) {
         responseProxy.headers[key] = value;
       },
       status(code) {
-        responseProxy.code = code;
+        responseProxy.status = code;
       },
       locals: locals || {}
     },
@@ -87,85 +89,93 @@ function createSSRContext(request, options) {
 }
 const createRequestHandler = async (handleRequest, createRequestOptions) => {
   const requestHandler = async (request, options) => {
-    var _context_routerContext, _context_routerContext1, _context_routerContext2;
-    const Root = (0, import_react.createRoot)();
-    const internalRuntimeContext = (0, import_context.getGlobalInternalRuntimeContext)();
-    const hooks = internalRuntimeContext.hooks;
-    const { routeManifest } = options.resource;
-    const context = (0, import_runtime.getInitialContext)(false, routeManifest);
-    const runBeforeRender = async (context2) => {
-      const result = await hooks.onBeforeRender.call(context2);
-      if (typeof Response !== "undefined" && result instanceof Response) {
-        return result;
-      }
-      const init = (0, import_context.getGlobalAppInit)();
-      return init === null || init === void 0 ? void 0 : init(context2);
-    };
+    const headersData = (0, import_request.parseHeaders)(request);
     const responseProxy = {
       headers: {},
-      code: -1
+      status: -1
     };
-    const ssrContext = createSSRContext(request, {
-      ...options,
+    return import_node.storage.run({
+      headers: headersData,
+      request,
+      monitors: options.monitors,
       responseProxy
-    });
-    Object.assign(context, {
-      ssrContext,
-      isBrowser: false,
-      loaderManager: (0, import_loaderManager.createLoaderManager)({}, {
-        skipNonStatic: options.staticGenerate,
-        // if not static generate, only non-static loader can exec on prod env
-        skipStatic: process.env.NODE_ENV === "production" && !options.staticGenerate
-      })
-    });
-    const getRedirectResponse = (result) => {
-      if (typeof Response !== "undefined" && // fix: ssg workflow doesn't inject Web Response
-      result instanceof Response && result.status >= 300 && result.status <= 399) {
-        const { status } = result;
-        const redirectUrl = result.headers.get("Location") || "/";
-        const { ssrContext: ssrContext2 } = context;
-        if (ssrContext2) {
-          return new Response(null, {
-            status,
-            headers: {
-              Location: redirectUrl
-            }
-          });
+    }, async () => {
+      var _context_routerContext, _context_routerContext1, _context_routerContext2;
+      const Root = (0, import_react.createRoot)();
+      const internalRuntimeContext = (0, import_context.getGlobalInternalRuntimeContext)();
+      const hooks = internalRuntimeContext.hooks;
+      const { routeManifest } = options.resource;
+      const context = (0, import_runtime.getInitialContext)(false, routeManifest);
+      const runBeforeRender = async (context2) => {
+        const result = await hooks.onBeforeRender.call(context2);
+        if (typeof Response !== "undefined" && result instanceof Response) {
+          return result;
+        }
+        const init = (0, import_context.getGlobalAppInit)();
+        return init === null || init === void 0 ? void 0 : init(context2);
+      };
+      const ssrContext = createSSRContext(request, {
+        ...options,
+        responseProxy
+      });
+      Object.assign(context, {
+        ssrContext,
+        isBrowser: false,
+        loaderManager: (0, import_loaderManager.createLoaderManager)({}, {
+          skipNonStatic: options.staticGenerate,
+          // if not static generate, only non-static loader can exec on prod env
+          skipStatic: process.env.NODE_ENV === "production" && !options.staticGenerate
+        })
+      });
+      const getRedirectResponse = (result) => {
+        if (typeof Response !== "undefined" && // fix: ssg workflow doesn't inject Web Response
+        result instanceof Response && result.status >= 300 && result.status <= 399) {
+          const { status } = result;
+          const redirectUrl = result.headers.get("Location") || "/";
+          const { ssrContext: ssrContext2 } = context;
+          if (ssrContext2) {
+            return new Response(null, {
+              status,
+              headers: {
+                Location: redirectUrl
+              }
+            });
+          }
         }
+        return void 0;
+      };
+      const initialData = await runBeforeRender(context);
+      if (((_context_routerContext = context.routerContext) === null || _context_routerContext === void 0 ? void 0 : _context_routerContext.statusCode) && ((_context_routerContext1 = context.routerContext) === null || _context_routerContext1 === void 0 ? void 0 : _context_routerContext1.statusCode) !== 200) {
+        var _context_routerContext3, _context_ssrContext;
+        (_context_ssrContext = context.ssrContext) === null || _context_ssrContext === void 0 ? void 0 : _context_ssrContext.response.status((_context_routerContext3 = context.routerContext) === null || _context_routerContext3 === void 0 ? void 0 : _context_routerContext3.statusCode);
       }
-      return void 0;
-    };
-    const initialData = await runBeforeRender(context);
-    if (((_context_routerContext = context.routerContext) === null || _context_routerContext === void 0 ? void 0 : _context_routerContext.statusCode) && ((_context_routerContext1 = context.routerContext) === null || _context_routerContext1 === void 0 ? void 0 : _context_routerContext1.statusCode) !== 200) {
-      var _context_routerContext3, _context_ssrContext;
-      (_context_ssrContext = context.ssrContext) === null || _context_ssrContext === void 0 ? void 0 : _context_ssrContext.response.status((_context_routerContext3 = context.routerContext) === null || _context_routerContext3 === void 0 ? void 0 : _context_routerContext3.statusCode);
-    }
-    const errors = Object.values(((_context_routerContext2 = context.routerContext) === null || _context_routerContext2 === void 0 ? void 0 : _context_routerContext2.errors) || {});
-    if (errors.length > 0) {
-      options.onError(errors[0], import_tracer.SSRErrors.LOADER_ERROR);
-    }
-    context.initialData = initialData;
-    const redirectResponse = getRedirectResponse(initialData);
-    if (redirectResponse) {
-      return redirectResponse;
-    }
-    const { htmlTemplate } = options.resource;
-    options.resource.htmlTemplate = htmlTemplate.replace("</head>", `${import_constants.CHUNK_CSS_PLACEHOLDER}</head>`);
-    const response = await handleRequest(request, Root, {
-      ...options,
-      runtimeContext: context,
-      RSCRoot: (createRequestOptions === null || createRequestOptions === void 0 ? void 0 : createRequestOptions.enableRsc) && (0, import_context.getGlobalRSCRoot)()
-    });
-    Object.entries(responseProxy.headers).forEach(([key, value]) => {
-      response.headers.set(key, value);
-    });
-    if (responseProxy.code !== -1) {
-      return new Response(response.body, {
-        status: responseProxy.code,
-        headers: response.headers
+      const errors = Object.values(((_context_routerContext2 = context.routerContext) === null || _context_routerContext2 === void 0 ? void 0 : _context_routerContext2.errors) || {});
+      if (errors.length > 0) {
+        options.onError(errors[0], import_tracer.SSRErrors.LOADER_ERROR);
+      }
+      context.initialData = initialData;
+      const redirectResponse = getRedirectResponse(initialData);
+      if (redirectResponse) {
+        return redirectResponse;
+      }
+      const { htmlTemplate } = options.resource;
+      options.resource.htmlTemplate = htmlTemplate.replace("</head>", `${import_constants.CHUNK_CSS_PLACEHOLDER}</head>`);
+      const response = await handleRequest(request, Root, {
+        ...options,
+        runtimeContext: context,
+        RSCRoot: (createRequestOptions === null || createRequestOptions === void 0 ? void 0 : createRequestOptions.enableRsc) && (0, import_context.getGlobalRSCRoot)()
+      });
+      Object.entries(responseProxy.headers).forEach(([key, value]) => {
+        response.headers.set(key, value);
       });
-    }
-    return response;
+      if (responseProxy.status !== -1) {
+        return new Response(response.body, {
+          status: responseProxy.status,
+          headers: response.headers
+        });
+      }
+      return response;
+    });
   };
   return requestHandler;
 };

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

@@ -25,9 +25,7 @@ __export(shared_exports, {
 });
 module.exports = __toCommonJS(shared_exports);
 var import_jsx_runtime = require("react/jsx-runtime");
-var import_node = require("@modern-js/runtime-utils/node");
 var import_time = require("@modern-js/runtime-utils/time");
-var import_request = require("@modern-js/runtime-utils/universal/request");
 var import_wrapper = require("../../react/wrapper");
 var import_tracer = require("../tracer");
 var import_utils = require("../utils");
@@ -58,51 +56,48 @@ function getReadableStreamFromString(content) {
 function createRenderStreaming(createReadableStreamPromise) {
   return async (request, serverRoot, options) => {
     const createReadableStreamFromElement = await createReadableStreamPromise;
-    const headersData = (0, import_request.parseHeaders)(request);
-    return (0, import_node.run)(headersData, async () => {
-      const end = (0, import_time.time)();
-      const { runtimeContext, config, resource } = options;
-      const { onError, onTiming } = options;
-      const { htmlTemplate, entryName } = resource;
-      const ssrConfig = (0, import_utils.getSSRConfigByEntry)(entryName, config.ssr, config.ssrByEntries);
-      const RSCServerRoot = ({ children }) => {
-        return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, {
-          children
-        });
-      };
-      let rootElement = (0, import_wrapper.wrapRuntimeContextProvider)(serverRoot, Object.assign(runtimeContext, {
-        ssr: true
-      }));
-      rootElement = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RSCServerRoot, {
-        children: rootElement
+    const end = (0, import_time.time)();
+    const { runtimeContext, config, resource } = options;
+    const { onError, onTiming } = options;
+    const { htmlTemplate, entryName } = resource;
+    const ssrConfig = (0, import_utils.getSSRConfigByEntry)(entryName, config.ssr, config.ssrByEntries);
+    const RSCServerRoot = ({ children }) => {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, {
+        children
       });
-      const stream = await createReadableStreamFromElement(request, rootElement, {
-        config,
-        htmlTemplate,
-        runtimeContext,
-        ssrConfig,
-        entryName,
-        rscClientManifest: options.rscClientManifest,
-        rscSSRManifest: options.rscSSRManifest,
-        rscServerManifest: options.rscServerManifest,
-        rscRoot: options.rscRoot,
-        onShellReady() {
-          const cost = end();
-          onTiming(import_tracer.SSRTimings.RENDER_SHELL, cost);
-        },
-        onAllReady() {
-          const cost = end();
-          onTiming(import_tracer.SSRTimings.RENDER_HTML, cost);
-        },
-        onShellError(error) {
-          onError(error, import_tracer.SSRErrors.RENDER_SHELL);
-        },
-        onError(error) {
-          onError(error, import_tracer.SSRErrors.RENDER_STREAM);
-        }
-      });
-      return stream;
+    };
+    let rootElement = (0, import_wrapper.wrapRuntimeContextProvider)(serverRoot, Object.assign(runtimeContext, {
+      ssr: true
+    }));
+    rootElement = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RSCServerRoot, {
+      children: rootElement
+    });
+    const stream = await createReadableStreamFromElement(request, rootElement, {
+      config,
+      htmlTemplate,
+      runtimeContext,
+      ssrConfig,
+      entryName,
+      rscClientManifest: options.rscClientManifest,
+      rscSSRManifest: options.rscSSRManifest,
+      rscServerManifest: options.rscServerManifest,
+      rscRoot: options.rscRoot,
+      onShellReady() {
+        const cost = end();
+        onTiming(import_tracer.SSRTimings.RENDER_SHELL, cost);
+      },
+      onAllReady() {
+        const cost = end();
+        onTiming(import_tracer.SSRTimings.RENDER_HTML, cost);
+      },
+      onShellError(error) {
+        onError(error, import_tracer.SSRErrors.RENDER_SHELL);
+      },
+      onError(error) {
+        onError(error, import_tracer.SSRErrors.RENDER_STREAM);
+      }
     });
+    return stream;
   };
 }
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -31,9 +31,7 @@ __export(string_exports, {
   renderString: () => renderString
 });
 module.exports = __toCommonJS(string_exports);
-var import_node = require("@modern-js/runtime-utils/node");
 var import_time = require("@modern-js/runtime-utils/time");
-var import_request = require("@modern-js/runtime-utils/universal/request");
 var import_server = __toESM(require("react-dom/server"));
 var import_react_helmet = __toESM(require("react-helmet"));
 var import_constants = require("../../constants");
@@ -48,59 +46,56 @@ var import_prefetch = require("./prefetch");
 var import_ssrData = require("./ssrData");
 var import_styledComponent = require("./styledComponent");
 const renderString = async (request, serverRoot, options) => {
-  const headersData = (0, import_request.parseHeaders)(request);
-  return (0, import_node.run)(headersData, async () => {
-    var _runtimeContext_ssrContext;
-    const { resource, runtimeContext, config, onError, onTiming } = options;
-    const tracer = {
-      onError,
-      onTiming
-    };
-    const routerContext = runtimeContext.routerContext;
-    const { htmlTemplate, entryName, loadableStats, routeManifest } = resource;
-    const ssrConfig = (0, import_utils.getSSRConfigByEntry)(entryName, config.ssr, config.ssrByEntries);
-    const chunkSet = {
-      renderLevel: import_constants.RenderLevel.CLIENT_RENDER,
-      ssrScripts: "",
-      jsChunk: "",
-      cssChunk: ""
-    };
-    let prefetchData = {};
-    try {
-      prefetchData = await (0, import_prefetch.prefetch)(serverRoot, request, options, ssrConfig, tracer);
-      chunkSet.renderLevel = import_constants.RenderLevel.SERVER_PREFETCH;
-    } catch (e) {
-      chunkSet.renderLevel = import_constants.RenderLevel.CLIENT_RENDER;
-      tracer.onError(e, import_tracer.SSRErrors.PRERENDER);
-    }
-    const collectors = [
-      new import_styledComponent.StyledCollector(chunkSet),
-      new import_loadable.LoadableCollector({
-        stats: loadableStats,
-        nonce: config.nonce,
-        routeManifest,
-        template: htmlTemplate,
-        entryName,
-        chunkSet,
-        config
-      }),
-      new import_ssrData.SSRDataCollector({
-        request,
-        prefetchData,
-        ssrConfig,
-        ssrContext: runtimeContext.ssrContext,
-        chunkSet,
-        routerContext,
-        nonce: config.nonce,
-        useJsonScript: config.useJsonScript
-      })
-    ];
-    const rootElement = (0, import_wrapper.wrapRuntimeContextProvider)(serverRoot, Object.assign(runtimeContext, {
-      ssr: true
-    }));
-    const html = await generateHtml(rootElement, htmlTemplate, chunkSet, collectors, ((_runtimeContext_ssrContext = runtimeContext.ssrContext) === null || _runtimeContext_ssrContext === void 0 ? void 0 : _runtimeContext_ssrContext.htmlModifiers) || [], tracer);
-    return html;
-  });
+  var _runtimeContext_ssrContext;
+  const { resource, runtimeContext, config, onError, onTiming } = options;
+  const tracer = {
+    onError,
+    onTiming
+  };
+  const routerContext = runtimeContext.routerContext;
+  const { htmlTemplate, entryName, loadableStats, routeManifest } = resource;
+  const ssrConfig = (0, import_utils.getSSRConfigByEntry)(entryName, config.ssr, config.ssrByEntries);
+  const chunkSet = {
+    renderLevel: import_constants.RenderLevel.CLIENT_RENDER,
+    ssrScripts: "",
+    jsChunk: "",
+    cssChunk: ""
+  };
+  let prefetchData = {};
+  try {
+    prefetchData = await (0, import_prefetch.prefetch)(serverRoot, request, options, ssrConfig, tracer);
+    chunkSet.renderLevel = import_constants.RenderLevel.SERVER_PREFETCH;
+  } catch (e) {
+    chunkSet.renderLevel = import_constants.RenderLevel.CLIENT_RENDER;
+    tracer.onError(e, import_tracer.SSRErrors.PRERENDER);
+  }
+  const collectors = [
+    new import_styledComponent.StyledCollector(chunkSet),
+    new import_loadable.LoadableCollector({
+      stats: loadableStats,
+      nonce: config.nonce,
+      routeManifest,
+      template: htmlTemplate,
+      entryName,
+      chunkSet,
+      config
+    }),
+    new import_ssrData.SSRDataCollector({
+      request,
+      prefetchData,
+      ssrConfig,
+      ssrContext: runtimeContext.ssrContext,
+      chunkSet,
+      routerContext,
+      nonce: config.nonce,
+      useJsonScript: config.useJsonScript
+    })
+  ];
+  const rootElement = (0, import_wrapper.wrapRuntimeContextProvider)(serverRoot, Object.assign(runtimeContext, {
+    ssr: true
+  }));
+  const html = await generateHtml(rootElement, htmlTemplate, chunkSet, collectors, ((_runtimeContext_ssrContext = runtimeContext.ssrContext) === null || _runtimeContext_ssrContext === void 0 ? void 0 : _runtimeContext_ssrContext.htmlModifiers) || [], tracer);
+  return html;
 };
 async function generateHtml(App, htmlTemplate, chunkSet, collectors, htmlModifiers, { onError, onTiming }) {
   let html = "";

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

@@ -22,75 +22,70 @@ __export(prefetch_exports, {
 });
 module.exports = __toCommonJS(prefetch_exports);
 var import_server = require("@loadable/server");
-var import_node = require("@modern-js/runtime-utils/node");
 var import_time = require("@modern-js/runtime-utils/time");
-var import_request = require("@modern-js/runtime-utils/universal/request");
 var import_server2 = require("react-dom/server");
 var import_wrapper = require("../../react/wrapper");
 var import_tracer = require("../tracer");
 const prefetch = async (App, request, options, ssrConfig, { onError, onTiming }) => {
-  const headersData = (0, import_request.parseHeaders)(request);
+  var _context_store;
   const { runtimeContext: context, resource } = options;
   const { entryName, loadableStats } = resource;
-  return (0, import_node.run)(headersData, async () => {
-    var _context_store;
-    if (typeof ssrConfig === "boolean" || !ssrConfig.disablePrerender) {
-      try {
-        const end = (0, import_time.time)();
-        if (loadableStats) {
-          const extractor = new import_server.ChunkExtractor({
-            stats: loadableStats,
-            entrypoints: [
-              entryName
-            ].filter(Boolean)
-          });
-          (0, import_server2.renderToStaticMarkup)(extractor.collectChunks((0, import_wrapper.wrapRuntimeContextProvider)(App, Object.assign(context, {
-            ssr: false
-          }))));
-        } else {
-          (0, import_server2.renderToStaticMarkup)((0, import_wrapper.wrapRuntimeContextProvider)(App, Object.assign(context, {
-            ssr: false
-          })));
-        }
-        const cost = end();
-        onTiming(import_tracer.SSRTimings.PRERENDER, cost);
-      } catch (e) {
-        const error = e;
-        onError(error, import_tracer.SSRErrors.PRERENDER);
-        throw e;
-      }
-    }
-    if (!context.loaderManager.hasPendingLoaders()) {
-      return {
-        initialData: context.initialData,
-        i18nData: context.__i18nData__
-      };
-    }
-    let loadersData = {};
+  if (typeof ssrConfig === "boolean" || !ssrConfig.disablePrerender) {
     try {
       const end = (0, import_time.time)();
-      loadersData = await context.loaderManager.awaitPendingLoaders();
+      if (loadableStats) {
+        const extractor = new import_server.ChunkExtractor({
+          stats: loadableStats,
+          entrypoints: [
+            entryName
+          ].filter(Boolean)
+        });
+        (0, import_server2.renderToStaticMarkup)(extractor.collectChunks((0, import_wrapper.wrapRuntimeContextProvider)(App, Object.assign(context, {
+          ssr: false
+        }))));
+      } else {
+        (0, import_server2.renderToStaticMarkup)((0, import_wrapper.wrapRuntimeContextProvider)(App, Object.assign(context, {
+          ssr: false
+        })));
+      }
       const cost = end();
-      onTiming(import_tracer.SSRTimings.USE_LOADER, cost);
+      onTiming(import_tracer.SSRTimings.PRERENDER, cost);
     } catch (e) {
-      onError(e, import_tracer.SSRErrors.USE_LOADER);
+      const error = e;
+      onError(error, import_tracer.SSRErrors.PRERENDER);
       throw e;
     }
-    Object.keys(loadersData).forEach((id) => {
-      const data = loadersData[id];
-      if (data._error) {
-        onError(data._error, import_tracer.SSRErrors.USE_LOADER);
-        delete data._error;
-      }
-    });
+  }
+  if (!context.loaderManager.hasPendingLoaders()) {
     return {
-      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()
+      i18nData: context.__i18nData__
     };
+  }
+  let loadersData = {};
+  try {
+    const end = (0, import_time.time)();
+    loadersData = await context.loaderManager.awaitPendingLoaders();
+    const cost = end();
+    onTiming(import_tracer.SSRTimings.USE_LOADER, cost);
+  } catch (e) {
+    onError(e, import_tracer.SSRErrors.USE_LOADER);
+    throw e;
+  }
+  Object.keys(loadersData).forEach((id) => {
+    const data = loadersData[id];
+    if (data._error) {
+      onError(data._error, import_tracer.SSRErrors.USE_LOADER);
+      delete data._error;
+    }
   });
+  return {
+    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()
+  };
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/index.js

@@ -23,12 +23,20 @@ __export(src_exports, {
   createApp: () => import_core.createApp,
   defineConfig: () => import_core.defineConfig,
   defineRuntimeConfig: () => import_core.defineRuntimeConfig,
+  getMonitors: () => import_monitors.getMonitors,
+  getRequest: () => import_request.getRequest,
   isBrowser: () => import_common.isBrowser,
+  redirect: () => import_response.redirect,
+  setHeaders: () => import_response.setHeaders,
+  setStatus: () => import_response.setStatus,
   useLoader: () => import_core.useLoader,
   useRuntimeContext: () => import_core.useRuntimeContext
 });
 module.exports = __toCommonJS(src_exports);
 var import_common = require("./common");
+var import_monitors = require("./core/context/monitors");
+var import_request = require("./core/context/request");
+var import_response = require("./core/context/response");
 var import_core = require("./core");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -37,7 +45,12 @@ var import_core = require("./core");
   createApp,
   defineConfig,
   defineRuntimeConfig,
+  getMonitors,
+  getRequest,
   isBrowser,
+  redirect,
+  setHeaders,
+  setStatus,
   useLoader,
   useRuntimeContext
 });

package/dist/cjs/react-server.js

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var react_server_exports = {};
+__export(react_server_exports, {
+  getMonitors: () => import_monitors.getMonitors,
+  getRequest: () => import_request.getRequest,
+  redirect: () => import_response.redirect,
+  setHeaders: () => import_response.setHeaders,
+  setStatus: () => import_response.setStatus
+});
+module.exports = __toCommonJS(react_server_exports);
+var import_request = require("./core/context/request");
+var import_monitors = require("./core/context/monitors");
+var import_response = require("./core/context/response");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getMonitors,
+  getRequest,
+  redirect,
+  setHeaders,
+  setStatus
+});

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

@@ -398,7 +398,7 @@ function ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext) {
   }
   return null;
 }
-const runtimeGlobalContext = async ({ metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp }) => {
+const runtimeGlobalContext = async ({ entryName, metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp }) => {
   const imports = [
     `import { setGlobalContext } from '@${metaName}/runtime/context';`
   ];
@@ -444,7 +444,9 @@ const runtimeGlobalContext = async ({ metaName, srcDirectory, nestedRoutesEntry,
 
 import { routes } from './routes';
 
+const entryName = '${entryName}';
 setGlobalContext({
+  entryName,
   layoutApp,
   routes,
   appInit,

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

@@ -54,6 +54,7 @@ async function handleGeneratorEntryCode(api, entrypoints) {
     if (entrypoint.nestedRoutesEntry || entrypoint.pageRoutesEntry) {
       var _entrypoint_fileSystemRoutes;
       generatorRegisterCode(internalDirectory, entrypoint.entryName, await templates.runtimeGlobalContext({
+        entryName: entrypoint.entryName,
         metaName: appContext.metaName,
         srcDirectory: appContext.srcDirectory,
         nestedRoutesEntry: entrypoint.nestedRoutesEntry,

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

@@ -91,8 +91,7 @@ const routerPlugin = (userConfig = {}) => {
           ssrMode,
           props: {
             nonce
-          },
-          reporter
+          }
         }));
         routes = hooks.modifyRoutes.call(routes);
         const { query } = (0, import_remix_router.createStaticHandler)(routes, {