@bleedingdev/modern-js-runtime 3.9.0-ultramodern.2 → 3.9.0-ultramodern.20

package/dist/cjs/cli/code.js

@@ -115,7 +115,9 @@ const generateCode = async (entrypoints, appContext, config, hooks)=>{
                 const bootstrapFile = external_path_default().resolve(internalDirectory, `./${entryName}/${external_constants_js_namespaceObject.ENTRY_BOOTSTRAP_FILE_NAME}`);
                 await utils_namespaceObject.fs.outputFile(bootstrapFile, `import(/* webpackChunkName: "async-${entryName}" */ './${external_constants_js_namespaceObject.INDEX_FILE_NAME}');`, 'utf8');
                 const bootstrapServerFile = external_path_default().resolve(internalDirectory, `./${entryName}/${external_constants_js_namespaceObject.ENTRY_SERVER_BOOTSTRAP_FILE_NAME}`);
-                if (ssrMode) await utils_namespaceObject.fs.outputFile(bootstrapServerFile, `export const requestHandler = import('./${external_constants_js_namespaceObject.SERVER_ENTRY_POINT_FILE_NAME}').then((m) => m.requestHandler)`, 'utf8');
+                if (ssrMode) await utils_namespaceObject.fs.outputFile(bootstrapServerFile, `export const requestHandler = import('./${external_constants_js_namespaceObject.SERVER_ENTRY_POINT_FILE_NAME}').then((m) => m.requestHandler);
+// The renderer awaits this promise later; retain its rejection without an early unhandled rejection.
+requestHandler.catch(() => {});`, 'utf8');
             }
             if (ssrMode) {
                 const indexServerCode = external_template_server_js_namespaceObject.serverIndex({

package/dist/cjs/cli/ssr/index.js

@@ -38,7 +38,6 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     default: ()=>cli_ssr,
-    shouldUseModuleFederationNodeOutput: ()=>shouldUseModuleFederationNodeOutput,
     ssrPlugin: ()=>ssrPlugin
 });
 const utils_namespaceObject = require("@modern-js/utils");
@@ -47,51 +46,6 @@ var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_na
 const external_loadable_bundler_plugin_js_namespaceObject = require("./loadable-bundler-plugin.js");
 var external_loadable_bundler_plugin_js_default = /*#__PURE__*/ __webpack_require__.n(external_loadable_bundler_plugin_js_namespaceObject);
 const external_mode_js_namespaceObject = require("./mode.js");
-const getRspackPlugins = (rspackConfig)=>{
-    if (!rspackConfig) return [];
-    const rspackEntries = Array.isArray(rspackConfig) ? rspackConfig : [
-        rspackConfig
-    ];
-    const plugins = [];
-    for (const entry of rspackEntries){
-        if (!entry || 'function' == typeof entry || 'object' != typeof entry) continue;
-        const maybePlugins = entry.plugins;
-        if (Array.isArray(maybePlugins)) {
-            for (const plugin of maybePlugins)if (plugin) plugins.push(plugin);
-        }
-    }
-    return plugins;
-};
-const getRspackPluginName = (plugin)=>{
-    if ('string' == typeof plugin) return plugin;
-    if ('function' == typeof plugin) return plugin.name;
-    if (Array.isArray(plugin)) {
-        const [first] = plugin;
-        if (!first) return;
-        if ('string' == typeof first) return first;
-        if ('function' == typeof first) return first.name;
-        if ('object' == typeof first) return first.name || first.constructor?.name;
-        return;
-    }
-    return plugin.name || plugin.constructor?.name;
-};
-const hasServerRenderingConfig = (userConfig)=>{
-    const { output, server } = userConfig;
-    if (output?.ssg) return true;
-    if (output?.ssgByEntries && Object.keys(output.ssgByEntries).length > 0) return true;
-    if (server?.ssr) return true;
-    if (server?.ssrByEntries && Object.keys(server.ssrByEntries).length > 0) return true;
-    return false;
-};
-const isModuleFederationAppSSREnabledInConfig = (ssr)=>{
-    if (!ssr || 'object' != typeof ssr) return false;
-    return true === ssr.moduleFederationAppSSR;
-};
-const isModuleFederationAppSSREnabled = (userConfig)=>{
-    if (isModuleFederationAppSSREnabledInConfig(userConfig.server?.ssr)) return true;
-    if (userConfig.server?.ssrByEntries && 'object' == typeof userConfig.server.ssrByEntries) return Object.values(userConfig.server.ssrByEntries).some(isModuleFederationAppSSREnabledInConfig);
-    return false;
-};
 const checkUseStringSSR = (config, appDirectory, entrypoints)=>{
     if (entrypoints && entrypoints.length > 0) {
         for (const entrypoint of entrypoints){
@@ -107,41 +61,19 @@ const checkUseStringSSR = (config, appDirectory, entrypoints)=>{
     }
     return true;
 };
-const isModuleFederationRspackPlugin = (plugin)=>{
-    const candidate = getRspackPluginName(plugin);
-    return 'string' == typeof candidate && /modulefederation/i.test(candidate);
-};
-const hasModuleFederationMarker = (config)=>{
-    if ('true' === process.env.MF_SSR_PRJ) return true;
-    const define = config.source?.define || {};
-    if ('REMOTE_IP_STRATEGY' in define || 'FEDERATION_IPV4' in define) return true;
-    const plugins = getRspackPlugins(config.tools?.rspack);
-    return plugins.some(isModuleFederationRspackPlugin);
-};
 const isNodeEnvironmentTarget = (target)=>'string' == typeof target && ('node' === target || 'async-node' === target || target.startsWith('node'));
-const shouldUseModuleFederationNodeOutput = (config)=>isNodeEnvironmentTarget(config.output?.target) && hasModuleFederationMarker(config);
 const ssrBuilderPlugin = (modernAPI, outputModule, exportLoadablePath)=>({
         name: '@modern-js/builder-plugin-ssr',
         setup (api) {
             api.modifyEnvironmentConfig((config, { name, mergeEnvironmentConfig })=>{
                 const isServerEnvironment = isNodeEnvironmentTarget(config.output.target) || 'workerSSR' === name;
                 const userConfig = modernAPI.getNormalizedConfig();
-                const hasServerRendering = hasServerRenderingConfig(userConfig);
-                const hasModuleFederationRuntimeMarker = hasServerRendering && shouldUseModuleFederationNodeOutput(config);
-                const hasExplicitMfSsrFlag = isModuleFederationAppSSREnabled(userConfig);
-                const requireExplicitMfSsrFlag = 'true' === process.env.MODERN_MF_APP_SSR_REQUIRE_EXPLICIT;
-                if (hasServerRendering && hasModuleFederationRuntimeMarker && !hasExplicitMfSsrFlag) {
-                    const warningMessage = '[modernjs][mf-ssr] Module Federation SSR was auto-detected from runtime markers. Set server.ssr.moduleFederationAppSSR=true explicitly in host and remotes to avoid heuristic drift.';
-                    if (requireExplicitMfSsrFlag) throw new Error(`${warningMessage} (enforced by MODERN_MF_APP_SSR_REQUIRE_EXPLICIT=true)`);
-                    console.warn(warningMessage);
-                }
-                const isModuleFederationAppSSR = hasServerRendering && hasExplicitMfSsrFlag;
                 const ssrEnv = userConfig.deploy?.worker?.ssr || userConfig.server?.rsc ? 'edge' : 'node';
                 const appContext = modernAPI.getAppContext();
                 const { appDirectory, entrypoints } = appContext;
                 const useLoadablePlugin = (0, utils_namespaceObject.isUseSSRBundle)(userConfig) && !isServerEnvironment && checkUseStringSSR(userConfig, appDirectory, entrypoints);
                 const outputConfig = {
-                    module: isServerEnvironment && (outputModule || 'workerSSR' === name && userConfig.deploy?.target === 'cloudflare')
+                    module: isServerEnvironment && outputModule
                 };
                 const useLoadableComponents = (0, utils_namespaceObject.isUseSSRBundle)(userConfig) && checkUseStringSSR(userConfig, appDirectory, entrypoints);
                 return mergeEnvironmentConfig(config, {
@@ -151,12 +83,10 @@ const ssrBuilderPlugin = (modernAPI, outputModule, exportLoadablePath)=>({
                             'process.env.MODERN_SSR_ENV': JSON.stringify(ssrEnv),
                             'process.env.MODERN_ENABLE_HYDRATION': JSON.stringify((0, utils_namespaceObject.isUseSSRBundle)(userConfig)),
                             'process.env.MODERN_ENABLE_RSC': JSON.stringify(Boolean(userConfig.server?.rsc)),
-                            __MODERN_ENABLE_RSC__: JSON.stringify(Boolean(userConfig.server?.rsc)),
-                            'process.env.MODERN_MF_APP_SSR': JSON.stringify(String(isModuleFederationAppSSR))
+                            __MODERN_ENABLE_RSC__: JSON.stringify(Boolean(userConfig.server?.rsc))
                         }
                     },
                     output: outputConfig,
-                    splitChunks: isServerEnvironment && (hasModuleFederationRuntimeMarker || hasExplicitMfSsrFlag) ? false : void 0,
                     tools: {
                         bundlerChain: useLoadablePlugin ? (chain)=>{
                             chain.plugin('loadable').use(external_loadable_bundler_plugin_js_default(), [
@@ -225,11 +155,9 @@ const ssrPlugin = ()=>({
     });
 const cli_ssr = ssrPlugin;
 exports["default"] = __webpack_exports__["default"];
-exports.shouldUseModuleFederationNodeOutput = __webpack_exports__.shouldUseModuleFederationNodeOutput;
 exports.ssrPlugin = __webpack_exports__.ssrPlugin;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "default",
-    "shouldUseModuleFederationNodeOutput",
     "ssrPlugin"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/cjs/cli/ssr/loadable-bundler-plugin.js

@@ -44,6 +44,7 @@ const external_path_namespaceObject = require("path");
 var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
 const normalizeChunkId = (id)=>'string' == typeof id && /^\d+$/.test(id) ? Number(id) : id;
 const DEFAULT_CHUNK_LOADING_GLOBAL = '__LOADABLE_LOADED_CHUNKS__';
+const normalizeStatsPublicPath = (publicPath)=>'auto' === publicPath || 'auto/' === publicPath ? '/' : publicPath;
 const normalizeChunkGroup = (group)=>({
         ...group,
         chunks: (group.chunks || []).map(normalizeChunkId)
@@ -86,6 +87,7 @@ class LoadablePlugin {
         for (const [name, ep] of Object.entries(stats.entrypoints || {}))entrypoints[name] = normalizeChunkGroup(ep);
         const output = {
             ...stats,
+            publicPath: normalizeStatsPublicPath(stats.publicPath),
             namedChunkGroups,
             entrypoints,
             generator: 'loadable-components',

package/dist/cjs/cli/template.server.js

@@ -153,8 +153,7 @@ function genHandlerCode({ mode, metaName, customServerEntry, srcDirectory, inter
         return `
       export * from '${realEntryPath}';
       export { default as requestHandler } from '${realEntryPath}'`;
-    }
-    {
+    } else {
         const entrySource = enableRsc ? SERVER_ENTRY_RSC : SERVER_ENTRY;
         const serverEntry = transformServerEntry(entrySource, {
             metaName: metaName || 'modern-js',

package/dist/cjs/core/browser/hydrate.js

@@ -62,18 +62,23 @@ function hydrateRoot(App, context, ModernRender, ModernHydrate) {
     if ('stream' === renderMode) return streamSSRHydrate();
     function streamSSRHydrate() {
         if (renderLevel !== external_constants_js_namespaceObject.RenderLevel.SERVER_RENDER) return ModernRender((0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(App, context));
-        {
+        else {
             const SSRApp = ()=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_withCallback_js_namespaceObject.WithCallback, {
                     callback: callback,
                     children: App
                 });
-            return ModernHydrate((0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(SSRApp, {}), hydrateContext));
+            return ModernHydrate(/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
+                children: [
+                    (0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(SSRApp, {}), hydrateContext),
+                    null
+                ]
+            }));
         }
     }
     return stringSSRHydrate();
     function stringSSRHydrate() {
         if (renderLevel === external_constants_js_namespaceObject.RenderLevel.CLIENT_RENDER) return ModernRender((0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(App, context));
-        {
+        else {
             if (renderLevel === external_constants_js_namespaceObject.RenderLevel.SERVER_RENDER) return (0, component_namespaceObject.loadableReady)(()=>void 0, loadableReadyOptions).then(()=>{
                 const SSRApp = ()=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_withCallback_js_namespaceObject.WithCallback, {
                         callback: callback,
@@ -81,13 +86,7 @@ function hydrateRoot(App, context, ModernRender, ModernHydrate) {
                     });
                 return ModernHydrate((0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(SSRApp, {}), hydrateContext));
             });
-            const runtimeConsole = Reflect.get(globalThis, 'console');
-            if (null !== runtimeConsole && 'object' == typeof runtimeConsole) {
-                const warn = Reflect.get(runtimeConsole, 'warn');
-                if ('function' == typeof warn) Reflect.apply(warn, runtimeConsole, [
-                    `unknow render level: ${renderLevel}, execute render()`
-                ]);
-            }
+            console.warn(`unknow render level: ${renderLevel}, execute render()`);
             return ModernRender((0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(App, context));
         }
     }

package/dist/cjs/core/browser/index.js

@@ -35,10 +35,9 @@ __webpack_require__.d(__webpack_exports__, {
     renderWithReact17: ()=>renderWithReact17,
     renderWithReact18: ()=>renderWithReact18
 });
+const context_namespaceObject = require("@modern-js/runtime/context");
 const external_cookie_namespaceObject = require("cookie");
 const client_namespaceObject = require("react-dom/client");
-const index_js_namespaceObject = require("../context/index.js");
-const runtime_js_namespaceObject = require("../context/runtime.js");
 const wrapper_js_namespaceObject = require("../react/wrapper.js");
 const external_hydrate_js_namespaceObject = require("./hydrate.js");
 const IS_REACT18 = 'true' === process.env.IS_REACT18;
@@ -85,7 +84,7 @@ function isClientArgs(id) {
     return void 0 === id || 'string' == typeof id || "u" > typeof HTMLElement && id instanceof HTMLElement;
 }
 async function renderApp(App, id, hydrateFromSsrData, internalRuntimeContext) {
-    const context = (0, runtime_js_namespaceObject.getInitialContext)();
+    const context = (0, context_namespaceObject.getInitialContext)();
     const runBeforeRender = async (context)=>{
         const api = internalRuntimeContext.pluginAPI;
         api.updateRuntimeContext(context);
@@ -115,10 +114,10 @@ async function renderApp(App, id, hydrateFromSsrData, internalRuntimeContext) {
     throw Error('`render` function needs id in browser environment, it needs to be string or element');
 }
 async function render(App, id) {
-    return renderApp(App, id, true, (0, index_js_namespaceObject.getGlobalInternalRuntimeContext)());
+    return renderApp(App, id, true, (0, context_namespaceObject.getGlobalInternalRuntimeContext)());
 }
 function createNestedAppRenderer() {
-    const internalRuntimeContext = (0, index_js_namespaceObject.getGlobalInternalRuntimeContext)();
+    const internalRuntimeContext = (0, context_namespaceObject.getGlobalInternalRuntimeContext)();
     return (App, id)=>renderApp(App, id, false, internalRuntimeContext);
 }
 async function renderWithReact18(App, rootElement) {

package/dist/cjs/core/context/index.js

@@ -30,14 +30,9 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     DefaultNotFound: ()=>DefaultNotFound_js_namespaceObject.DefaultNotFound,
     InternalRuntimeContext: ()=>external_runtime_js_namespaceObject.InternalRuntimeContext,
+    ReactRuntimeContext: ()=>external_runtime_js_namespaceObject.ReactRuntimeContext,
+    RuntimeComponentResolverContext: ()=>external_runtime_js_namespaceObject.RuntimeComponentResolverContext,
     RuntimeContext: ()=>external_runtime_js_namespaceObject.RuntimeContext,
-    applyRouterRuntimeState: ()=>lifecycle_js_namespaceObject.applyRouterRuntimeState,
-    applyRouterServerPrepareResult: ()=>lifecycle_js_namespaceObject.applyRouterServerPrepareResult,
-    cleanupRouterRuntimeState: ()=>lifecycle_js_namespaceObject.cleanupRouterRuntimeState,
-    createRouterProviderRealm: ()=>provider_js_namespaceObject.createRouterProviderRealm,
-    createRouterRuntimeState: ()=>lifecycle_js_namespaceObject.createRouterRuntimeState,
-    createRouterServerSnapshot: ()=>lifecycle_js_namespaceObject.createRouterServerSnapshot,
-    createRuntimeContextExtension: ()=>external_extensions_js_namespaceObject.createRuntimeContextExtension,
     getCurrentEntryName: ()=>getCurrentEntryName,
     getGlobalApp: ()=>getGlobalApp,
     getGlobalBasename: ()=>getGlobalBasename,
@@ -48,10 +43,6 @@ __webpack_require__.d(__webpack_exports__, {
     getGlobalRSCRoot: ()=>getGlobalRSCRoot,
     getGlobalRoutes: ()=>getGlobalRoutes,
     getInitialContext: ()=>external_runtime_js_namespaceObject.getInitialContext,
-    getRouterHydrationScripts: ()=>lifecycle_js_namespaceObject.getRouterHydrationScripts,
-    getRouterMatchedRouteIds: ()=>lifecycle_js_namespaceObject.getRouterMatchedRouteIds,
-    getRouterRuntimeState: ()=>lifecycle_js_namespaceObject.getRouterRuntimeState,
-    getRouterServerSnapshot: ()=>lifecycle_js_namespaceObject.getRouterServerSnapshot,
     getServerPayload: ()=>index_js_namespaceObject.getServerPayload,
     modifyRoutes: ()=>hooks_js_namespaceObject.modifyRoutes,
     onAfterCreateRouter: ()=>hooks_js_namespaceObject.onAfterCreateRouter,
@@ -59,18 +50,14 @@ __webpack_require__.d(__webpack_exports__, {
     onBeforeCreateRouter: ()=>hooks_js_namespaceObject.onBeforeCreateRouter,
     onBeforeCreateRoutes: ()=>hooks_js_namespaceObject.onBeforeCreateRoutes,
     onBeforeHydrateRouter: ()=>hooks_js_namespaceObject.onBeforeHydrateRouter,
-    registerRouterProvider: ()=>provider_js_namespaceObject.registerRouterProvider,
-    resolveRouterProvider: ()=>provider_js_namespaceObject.resolveRouterProvider,
-    routerProviderRegistryHooks: ()=>provider_js_namespaceObject.routerProviderRegistryHooks,
+    routerProviderRegistryHooks: ()=>hooks_js_namespaceObject.routerProviderRegistryHooks,
     setGlobalContext: ()=>setGlobalContext,
     setGlobalInternalRuntimeContext: ()=>setGlobalInternalRuntimeContext,
-    setServerPayload: ()=>index_js_namespaceObject.setServerPayload
+    setServerPayload: ()=>index_js_namespaceObject.setServerPayload,
+    useRuntimeContext: ()=>external_runtime_js_namespaceObject.useRuntimeContext
 });
 const DefaultNotFound_js_namespaceObject = require("../../router/runtime/DefaultNotFound.js");
 const hooks_js_namespaceObject = require("../../router/runtime/hooks.js");
-const lifecycle_js_namespaceObject = require("../../router/runtime/lifecycle.js");
-const provider_js_namespaceObject = require("../../router/runtime/provider.js");
-const external_extensions_js_namespaceObject = require("./extensions.js");
 const external_runtime_js_namespaceObject = require("./runtime.js");
 const index_js_namespaceObject = require("./serverPayload/index.js");
 const globalContext = {};
@@ -117,14 +104,9 @@ function getGlobalBasename() {
 }
 exports.DefaultNotFound = __webpack_exports__.DefaultNotFound;
 exports.InternalRuntimeContext = __webpack_exports__.InternalRuntimeContext;
+exports.ReactRuntimeContext = __webpack_exports__.ReactRuntimeContext;
+exports.RuntimeComponentResolverContext = __webpack_exports__.RuntimeComponentResolverContext;
 exports.RuntimeContext = __webpack_exports__.RuntimeContext;
-exports.applyRouterRuntimeState = __webpack_exports__.applyRouterRuntimeState;
-exports.applyRouterServerPrepareResult = __webpack_exports__.applyRouterServerPrepareResult;
-exports.cleanupRouterRuntimeState = __webpack_exports__.cleanupRouterRuntimeState;
-exports.createRouterProviderRealm = __webpack_exports__.createRouterProviderRealm;
-exports.createRouterRuntimeState = __webpack_exports__.createRouterRuntimeState;
-exports.createRouterServerSnapshot = __webpack_exports__.createRouterServerSnapshot;
-exports.createRuntimeContextExtension = __webpack_exports__.createRuntimeContextExtension;
 exports.getCurrentEntryName = __webpack_exports__.getCurrentEntryName;
 exports.getGlobalApp = __webpack_exports__.getGlobalApp;
 exports.getGlobalBasename = __webpack_exports__.getGlobalBasename;
@@ -135,10 +117,6 @@ exports.getGlobalLayoutApp = __webpack_exports__.getGlobalLayoutApp;
 exports.getGlobalRSCRoot = __webpack_exports__.getGlobalRSCRoot;
 exports.getGlobalRoutes = __webpack_exports__.getGlobalRoutes;
 exports.getInitialContext = __webpack_exports__.getInitialContext;
-exports.getRouterHydrationScripts = __webpack_exports__.getRouterHydrationScripts;
-exports.getRouterMatchedRouteIds = __webpack_exports__.getRouterMatchedRouteIds;
-exports.getRouterRuntimeState = __webpack_exports__.getRouterRuntimeState;
-exports.getRouterServerSnapshot = __webpack_exports__.getRouterServerSnapshot;
 exports.getServerPayload = __webpack_exports__.getServerPayload;
 exports.modifyRoutes = __webpack_exports__.modifyRoutes;
 exports.onAfterCreateRouter = __webpack_exports__.onAfterCreateRouter;
@@ -146,23 +124,17 @@ exports.onAfterHydrateRouter = __webpack_exports__.onAfterHydrateRouter;
 exports.onBeforeCreateRouter = __webpack_exports__.onBeforeCreateRouter;
 exports.onBeforeCreateRoutes = __webpack_exports__.onBeforeCreateRoutes;
 exports.onBeforeHydrateRouter = __webpack_exports__.onBeforeHydrateRouter;
-exports.registerRouterProvider = __webpack_exports__.registerRouterProvider;
-exports.resolveRouterProvider = __webpack_exports__.resolveRouterProvider;
 exports.routerProviderRegistryHooks = __webpack_exports__.routerProviderRegistryHooks;
 exports.setGlobalContext = __webpack_exports__.setGlobalContext;
 exports.setGlobalInternalRuntimeContext = __webpack_exports__.setGlobalInternalRuntimeContext;
 exports.setServerPayload = __webpack_exports__.setServerPayload;
+exports.useRuntimeContext = __webpack_exports__.useRuntimeContext;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "DefaultNotFound",
     "InternalRuntimeContext",
+    "ReactRuntimeContext",
+    "RuntimeComponentResolverContext",
     "RuntimeContext",
-    "applyRouterRuntimeState",
-    "applyRouterServerPrepareResult",
-    "cleanupRouterRuntimeState",
-    "createRouterProviderRealm",
-    "createRouterRuntimeState",
-    "createRouterServerSnapshot",
-    "createRuntimeContextExtension",
     "getCurrentEntryName",
     "getGlobalApp",
     "getGlobalBasename",
@@ -173,10 +145,6 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "getGlobalRSCRoot",
     "getGlobalRoutes",
     "getInitialContext",
-    "getRouterHydrationScripts",
-    "getRouterMatchedRouteIds",
-    "getRouterRuntimeState",
-    "getRouterServerSnapshot",
     "getServerPayload",
     "modifyRoutes",
     "onAfterCreateRouter",
@@ -184,12 +152,11 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "onBeforeCreateRouter",
     "onBeforeCreateRoutes",
     "onBeforeHydrateRouter",
-    "registerRouterProvider",
-    "resolveRouterProvider",
     "routerProviderRegistryHooks",
     "setGlobalContext",
     "setGlobalInternalRuntimeContext",
-    "setServerPayload"
+    "setServerPayload",
+    "useRuntimeContext"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/core/context/public.js

@@ -28,14 +28,11 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    ReactRuntimeContext: ()=>ReactRuntimeContext,
-    RuntimeContext: ()=>RuntimeContext,
-    useRuntimeContext: ()=>useRuntimeContext
+    ReactRuntimeContext: ()=>context_namespaceObject.ReactRuntimeContext,
+    RuntimeContext: ()=>context_namespaceObject.RuntimeContext,
+    useRuntimeContext: ()=>context_namespaceObject.useRuntimeContext
 });
-const external_react_namespaceObject = require("react");
-const RuntimeContext = (0, external_react_namespaceObject.createContext)({});
-const ReactRuntimeContext = RuntimeContext;
-const useRuntimeContext = ()=>(0, external_react_namespaceObject.useContext)(RuntimeContext);
+const context_namespaceObject = require("@modern-js/runtime/context");
 exports.ReactRuntimeContext = __webpack_exports__.ReactRuntimeContext;
 exports.RuntimeContext = __webpack_exports__.RuntimeContext;
 exports.useRuntimeContext = __webpack_exports__.useRuntimeContext;

package/dist/cjs/core/context/runtime.js

@@ -29,15 +29,19 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     InternalRuntimeContext: ()=>InternalRuntimeContext,
-    ReactRuntimeContext: ()=>external_public_js_namespaceObject.ReactRuntimeContext,
-    RuntimeContext: ()=>external_public_js_namespaceObject.RuntimeContext,
+    ReactRuntimeContext: ()=>ReactRuntimeContext,
+    RuntimeComponentResolverContext: ()=>RuntimeComponentResolverContext,
+    RuntimeContext: ()=>RuntimeContext,
     getInitialContext: ()=>getInitialContext,
-    useRuntimeContext: ()=>external_public_js_namespaceObject.useRuntimeContext
+    useRuntimeContext: ()=>useRuntimeContext
 });
 const external_react_namespaceObject = require("react");
-const external_public_js_namespaceObject = require("./public.js");
 const ROUTE_MANIFEST = '_MODERNJS_ROUTE_MANIFEST';
 const InternalRuntimeContext = (0, external_react_namespaceObject.createContext)({});
+const RuntimeContext = (0, external_react_namespaceObject.createContext)({});
+const RuntimeComponentResolverContext = (0, external_react_namespaceObject.createContext)(void 0);
+const ReactRuntimeContext = RuntimeContext;
+const useRuntimeContext = ()=>(0, external_react_namespaceObject.useContext)(RuntimeContext);
 const getInitialContext = (isBrowser = true, routeManifest)=>{
     const requestContext = {
         request: {
@@ -63,12 +67,14 @@ const getInitialContext = (isBrowser = true, routeManifest)=>{
 };
 exports.InternalRuntimeContext = __webpack_exports__.InternalRuntimeContext;
 exports.ReactRuntimeContext = __webpack_exports__.ReactRuntimeContext;
+exports.RuntimeComponentResolverContext = __webpack_exports__.RuntimeComponentResolverContext;
 exports.RuntimeContext = __webpack_exports__.RuntimeContext;
 exports.getInitialContext = __webpack_exports__.getInitialContext;
 exports.useRuntimeContext = __webpack_exports__.useRuntimeContext;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "InternalRuntimeContext",
     "ReactRuntimeContext",
+    "RuntimeComponentResolverContext",
     "RuntimeContext",
     "getInitialContext",
     "useRuntimeContext"

package/dist/cjs/core/index.js

@@ -28,12 +28,12 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    RuntimeContext: ()=>runtime_js_namespaceObject.RuntimeContext,
+    RuntimeContext: ()=>context_namespaceObject.RuntimeContext,
     defineRuntimeConfig: ()=>external_config_js_namespaceObject.defineRuntimeConfig,
-    useRuntimeContext: ()=>runtime_js_namespaceObject.useRuntimeContext
+    useRuntimeContext: ()=>context_namespaceObject.useRuntimeContext
 });
+const context_namespaceObject = require("@modern-js/runtime/context");
 const external_config_js_namespaceObject = require("./config.js");
-const runtime_js_namespaceObject = require("./context/runtime.js");
 exports.RuntimeContext = __webpack_exports__.RuntimeContext;
 exports.defineRuntimeConfig = __webpack_exports__.defineRuntimeConfig;
 exports.useRuntimeContext = __webpack_exports__.useRuntimeContext;

package/dist/cjs/core/plugin/index.js

@@ -32,11 +32,11 @@ __webpack_require__.d(__webpack_exports__, {
     registerPlugin: ()=>registerPlugin
 });
 const runtime_namespaceObject = require("@modern-js/plugin/runtime");
+const context_namespaceObject = require("@modern-js/runtime/context");
 const merge_namespaceObject = require("@modern-js/runtime-utils/merge");
 const index_js_namespaceObject = require("../compat/index.js");
 const hooks_js_namespaceObject = require("../compat/hooks.js");
 const requestContext_js_namespaceObject = require("../compat/requestContext.js");
-const external_context_index_js_namespaceObject = require("../context/index.js");
 function registerPlugin(internalPlugins, runtimeConfig) {
     const { plugins = [] } = runtimeConfig || {};
     const { runtimeContext } = runtime_namespaceObject.runtime.run({
@@ -50,7 +50,7 @@ function registerPlugin(internalPlugins, runtimeConfig) {
         handleSetupResult: hooks_js_namespaceObject.handleSetupResult
     });
     const internalRuntimeContext = runtimeContext;
-    (0, external_context_index_js_namespaceObject.setGlobalInternalRuntimeContext)(internalRuntimeContext);
+    (0, context_namespaceObject.setGlobalInternalRuntimeContext)(internalRuntimeContext);
     return internalRuntimeContext;
 }
 function mergeConfig(config, ...otherConfig) {

package/dist/cjs/core/react/index.js

@@ -30,17 +30,17 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     createRoot: ()=>createRoot
 });
+const context_namespaceObject = require("@modern-js/runtime/context");
 const parsed_namespaceObject = require("@modern-js/runtime-utils/parsed");
 const external_common_js_namespaceObject = require("../../common.js");
 const external_constants_js_namespaceObject = require("../constants.js");
-const index_js_namespaceObject = require("../context/index.js");
 function createRoot(UserApp) {
-    const App = UserApp || (0, index_js_namespaceObject.getGlobalApp)();
+    const App = UserApp || (0, context_namespaceObject.getGlobalApp)();
     if ((0, external_common_js_namespaceObject.isBrowser)()) {
         window._SSR_DATA = window._SSR_DATA || (0, parsed_namespaceObject.parsedJSONFromElement)(external_constants_js_namespaceObject.SSR_DATA_JSON_ID);
         window._ROUTER_DATA = window._ROUTER_DATA || (0, parsed_namespaceObject.parsedJSONFromElement)(external_constants_js_namespaceObject.ROUTER_DATA_JSON_ID);
     }
-    const internalRuntimeContext = (0, index_js_namespaceObject.getGlobalInternalRuntimeContext)();
+    const internalRuntimeContext = (0, context_namespaceObject.getGlobalInternalRuntimeContext)();
     const hooks = internalRuntimeContext.hooks;
     const WrapperApp = hooks.wrapRoot.call(App);
     return WrapperApp;

package/dist/cjs/core/react/wrapper.js

@@ -28,50 +28,19 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    wrapRuntimeComponentResolver: ()=>wrapRuntimeComponentResolver,
     wrapRuntimeContextProvider: ()=>wrapRuntimeContextProvider
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
-const external_react_helmet_async_namespaceObject = require("react-helmet-async");
-const index_js_namespaceObject = require("../context/index.js");
-const extensions_js_namespaceObject = require("../context/extensions.js");
-const helmetContext_js_namespaceObject = require("../context/helmetContext.js");
-function createRscSafeRequestContext(ssrContext) {
-    const requestContext = (0, index_js_namespaceObject.getInitialContext)().requestContext;
-    Object.defineProperty(requestContext.response, 'setHeader', {
-        enumerable: false
+const context_namespaceObject = require("@modern-js/runtime/context");
+function wrapRuntimeComponentResolver(root, hooks = (0, context_namespaceObject.getGlobalInternalRuntimeContext)()?.hooks) {
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(context_namespaceObject.RuntimeComponentResolverContext.Provider, {
+        value: hooks?.resolveComponent?.call,
+        children: root
     });
-    Object.defineProperty(requestContext.response, 'status', {
-        enumerable: false
-    });
-    if (void 0 === ssrContext) return requestContext;
-    const { request, response } = ssrContext;
-    return {
-        request: {
-            url: request.url,
-            userAgent: request.userAgent,
-            cookie: request.cookie,
-            pathname: request.pathname,
-            query: {
-                ...request.query
-            },
-            params: {
-                ...request.params
-            },
-            headers: {
-                ...request.headers
-            },
-            host: request.host,
-            referer: request.referer
-        },
-        response: Object.assign(requestContext.response, {
-            locals: response.locals ?? {}
-        })
-    };
 }
 function wrapRuntimeContextProvider(App, contextValue) {
     const { isBrowser, initialData, routes, context, routeManifest, routerContext, unstable_getBlockNavState, ssrContext, _internalContext, _internalRouterBaseName, ...rest } = contextValue;
-    const internalContextValue = contextValue;
-    const helmetContext = (0, helmetContext_js_namespaceObject.ensureHelmetContext)(internalContextValue);
     const runtimeContextValue = {
         isBrowser,
         initialData,
@@ -79,41 +48,28 @@ function wrapRuntimeContextProvider(App, contextValue) {
         context,
         ...rest
     };
-    (0, extensions_js_namespaceObject.stripRuntimeContextExtensions)(runtimeContextValue);
-    if (true === (0, index_js_namespaceObject.getGlobalEnableRsc)() && false === isBrowser) {
-        const rscSafeRequestContext = createRscSafeRequestContext(ssrContext);
-        const rscInternalContextValue = {
-            ...internalContextValue,
-            context: rscSafeRequestContext,
-            requestContext: rscSafeRequestContext
-        };
-        delete rscInternalContextValue.ssrContext;
-        const rscRuntimeContextValue = {
-            ...runtimeContextValue,
-            context: rscSafeRequestContext,
-            requestContext: rscSafeRequestContext
-        };
-        return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(index_js_namespaceObject.InternalRuntimeContext.Provider, {
-            value: rscInternalContextValue,
-            children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(index_js_namespaceObject.RuntimeContext.Provider, {
-                value: rscRuntimeContextValue,
-                children: App
-            })
-        });
-    }
-    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(index_js_namespaceObject.InternalRuntimeContext.Provider, {
-        value: internalContextValue,
-        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(index_js_namespaceObject.RuntimeContext.Provider, {
-            value: runtimeContextValue,
-            children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_react_helmet_async_namespaceObject.HelmetProvider, {
-                context: helmetContext,
-                children: App
-            })
+    const isRsc = true === (0, context_namespaceObject.getGlobalEnableRsc)();
+    const projection = {
+        internalContext: contextValue,
+        publicContext: runtimeContextValue
+    };
+    const values = (0, context_namespaceObject.getGlobalInternalRuntimeContext)()?.hooks.transformRuntimeContext?.call(projection, {
+        context: contextValue,
+        isRsc
+    }) ?? projection;
+    const root = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(context_namespaceObject.InternalRuntimeContext.Provider, {
+        value: values.internalContext,
+        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(context_namespaceObject.RuntimeContext.Provider, {
+            value: values.publicContext,
+            children: App
         })
     });
+    return isRsc && false === isBrowser ? root : wrapRuntimeComponentResolver(root);
 }
+exports.wrapRuntimeComponentResolver = __webpack_exports__.wrapRuntimeComponentResolver;
 exports.wrapRuntimeContextProvider = __webpack_exports__.wrapRuntimeContextProvider;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "wrapRuntimeComponentResolver",
     "wrapRuntimeContextProvider"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

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

@@ -32,7 +32,6 @@ __webpack_require__.d(__webpack_exports__, {
     getHelmetData: ()=>getHelmetData,
     helmetReplace: ()=>helmetReplace
 });
-const helmetContext_js_namespaceObject = require("../context/helmetContext.js");
 const external_utils_js_namespaceObject = require("./utils.js");
 const EOL = '\n';
 const RE_HTML_ATTR = /<html[^>]*>/;
@@ -40,8 +39,10 @@ const RE_BODY_ATTR = /<body[^>]*>/;
 const RE_LAST_IN_HEAD = /<\/head>/;
 const RE_TITLE = /<title[^>]*>([\s\S\n\r]*?)<\/title>/;
 const TEST_TITLE_CONTENT = /(?<=<title[^>]*>)([\s\S\n\r]*?)([.|\S])([\s\S\n\r]*?)(?=<\/title>)/;
-function getHelmetData(runtimeContext) {
-    return (0, helmetContext_js_namespaceObject.getHelmetContext)(runtimeContext)?.helmet ?? void 0;
+function getHelmetData(providers) {
+    let result;
+    for (const provider of providers)result = provider.getHeadData?.() ?? result;
+    return result;
 }
 function createReplaceHelemt(helmetData) {
     return helmetData ? (template)=>helmetReplace(template, helmetData) : (tempalte)=>tempalte;
@@ -53,7 +54,7 @@ function helmetReplace(content, helmetData) {
     const htmlAttributes = helmetData.htmlAttributes.toString();
     if (htmlAttributes) result = (0, external_utils_js_namespaceObject.safeReplace)(result, RE_HTML_ATTR, `<html ${htmlAttributes}>`);
     const base = helmetData.base.toString();
-    const priority = helmetData.priority.toString();
+    const priority = helmetData.priority?.toString() ?? '';
     const link = helmetData.link.toString();
     const meta = helmetData.meta.toString();
     const noscript = helmetData.noscript.toString();