@bleedingdev/modern-js-runtime 3.9.0-ultramodern.1 → 3.9.0-ultramodern.11

package/dist/esm-node/router/runtime/PrefetchLink.mjs

@@ -1,7 +1,6 @@
 import "node:module";
 "use client";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-import { getNavigationWarmupCacheKey } from "@modern-js/runtime-extensions";
 import { Link as router_Link, NavLink, matchRoutes, useHref, useMatches, useResolvedPath } from "@modern-js/runtime-utils/router";
 import react, { useContext, useMemo } from "react";
 import { InternalRuntimeContext } from "../../core/context/index.mjs";
@@ -21,62 +20,6 @@ function composeEventHandlers(theirHandler, ourHandler) {
     };
 }
 const ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
-const DEFAULT_PREFETCH_BEHAVIOR = 'render';
-const INTENT_DELAY = 100;
-const VIEWPORT_ROOT_MARGIN = '200px';
-const MAX_CONCURRENT_WARMUPS = 4;
-const WARMUP_TTL = 30000;
-const SLOW_EFFECTIVE_TYPES = new Set([
-    'slow-2g',
-    '2g'
-]);
-const warmupCache = new Map();
-const warmupQueue = [];
-let activeWarmups = 0;
-const getWarmupTimestamp = ()=>performance.now();
-const getConnection = ()=>{
-    const nav = globalThis.navigator;
-    return nav?.connection || nav?.mozConnection || nav?.webkitConnection;
-};
-const shouldWarmupOnCurrentNetwork = ()=>{
-    const connection = getConnection();
-    if (connection?.saveData) return false;
-    if ('string' == typeof connection?.effectiveType && SLOW_EFFECTIVE_TYPES.has(connection.effectiveType)) return false;
-    return true;
-};
-const pruneWarmupCache = (now = getWarmupTimestamp())=>{
-    for (const [key, timestamp] of warmupCache)if (now - timestamp > WARMUP_TTL) warmupCache.delete(key);
-};
-const runNextWarmup = ()=>{
-    while(activeWarmups < MAX_CONCURRENT_WARMUPS && warmupQueue.length > 0){
-        const task = warmupQueue.shift();
-        if (task.cancelled) continue;
-        activeWarmups += 1;
-        task.run().catch(()=>{
-            warmupCache.delete(task.key);
-        }).finally(()=>{
-            activeWarmups -= 1;
-            runNextWarmup();
-        });
-    }
-};
-const scheduleWarmup = (key, run)=>{
-    if (!shouldWarmupOnCurrentNetwork()) return ()=>{};
-    pruneWarmupCache();
-    if (warmupCache.has(key)) return ()=>{};
-    warmupCache.set(key, getWarmupTimestamp());
-    const task = {
-        key,
-        run,
-        cancelled: false
-    };
-    warmupQueue.push(task);
-    runNextWarmup();
-    return ()=>{
-        task.cancelled = true;
-        if (warmupQueue.includes(task)) warmupCache.delete(task.key);
-    };
-};
 const setRef = (ref, value)=>{
     if (!ref) return;
     if ('function' == typeof ref) return void ref(value);
@@ -84,70 +27,65 @@ const setRef = (ref, value)=>{
         ref.current = value;
     } catch  {}
 };
-const isDataWarmupEnabled = (route)=>{
-    const handle = route.handle;
-    return handle?.navigationWarmup?.data !== false;
-};
-function usePrefetchBehavior(prefetch, preload, theirElementProps) {
-    const [maybeWarmup, setMaybeWarmup] = react.useState(false);
-    const [shouldPrefetch, setShouldPrefetch] = react.useState(false);
-    const [shouldPreload, setShouldPreload] = react.useState(false);
-    const [viewportElement, setViewportElement] = react.useState(null);
+function usePrefetchBehavior(prefetch, preload, theirElementProps, policy) {
+    const [maybePrefetch, setMaybePrefetch] = react.useState(false);
+    const [state, setState] = react.useState({
+        code: false,
+        data: false
+    });
+    const [element, setElement] = react.useState(null);
+    const observerRef = react.useRef(void 0);
     const { onFocus, onBlur, onMouseEnter, onMouseLeave, onTouchStart } = theirElementProps;
     react.useEffect(()=>{
-        if ('render' === prefetch) setShouldPrefetch(true);
-        if ('render' === preload) setShouldPreload(true);
+        if (!policy) return void setState({
+            code: 'render' === prefetch,
+            data: 'render' === prefetch
+        });
+        const observer = policy.observe({
+            element,
+            prefetch,
+            preload,
+            notify: (next)=>setState((previous)=>previous.code === next.code && previous.data === next.data ? previous : next)
+        });
+        observerRef.current = observer;
+        return ()=>{
+            observerRef.current = void 0;
+            observer.dispose();
+        };
     }, [
+        policy,
         prefetch,
-        preload
+        preload,
+        element
+    ]);
+    react.useEffect(()=>{
+        if (policy || !maybePrefetch) return;
+        const timer = setTimeout(()=>setState({
+                code: true,
+                data: true
+            }), 100);
+        return ()=>clearTimeout(timer);
+    }, [
+        policy,
+        maybePrefetch
     ]);
     const setIntent = ()=>{
-        if ('intent' === prefetch || 'intent' === preload) setMaybeWarmup(true);
+        if (policy) observerRef.current?.onIntent();
+        else if ('intent' === prefetch) setMaybePrefetch(true);
     };
     const cancelIntent = ()=>{
-        if ('intent' === prefetch || 'intent' === preload) {
-            setMaybeWarmup(false);
-            setShouldPrefetch(false);
-            setShouldPreload(false);
+        if (policy) observerRef.current?.onCancel();
+        else if ('intent' === prefetch) {
+            setMaybePrefetch(false);
+            setState({
+                code: false,
+                data: false
+            });
         }
     };
-    react.useEffect(()=>{
-        if (maybeWarmup) {
-            const id = setTimeout(()=>{
-                if ('intent' === prefetch) setShouldPrefetch(true);
-                if ('intent' === preload) setShouldPreload(true);
-            }, INTENT_DELAY);
-            return ()=>{
-                clearTimeout(id);
-            };
-        }
-    }, [
-        maybeWarmup,
-        prefetch,
-        preload
-    ]);
-    react.useEffect(()=>{
-        if (!viewportElement || 'viewport' !== prefetch && 'viewport' !== preload || "u" < typeof IntersectionObserver) return;
-        const observer = new IntersectionObserver((entries)=>{
-            if (!entries.some((entry)=>entry.isIntersecting)) return;
-            if ('viewport' === prefetch) setShouldPrefetch(true);
-            if ('viewport' === preload) setShouldPreload(true);
-            observer.disconnect();
-        }, {
-            rootMargin: VIEWPORT_ROOT_MARGIN
-        });
-        observer.observe(viewportElement);
-        return ()=>{
-            observer.disconnect();
-        };
-    }, [
-        prefetch,
-        preload,
-        viewportElement
-    ]);
     return [
-        shouldPrefetch,
-        shouldPreload,
+        state.data,
+        state.code,
         {
             onFocus: composeEventHandlers(onFocus, setIntent),
             onBlur: composeEventHandlers(onBlur, cancelIntent),
@@ -155,7 +93,7 @@ function usePrefetchBehavior(prefetch, preload, theirElementProps) {
             onMouseLeave: composeEventHandlers(onMouseLeave, cancelIntent),
             onTouchStart: composeEventHandlers(onTouchStart, setIntent)
         },
-        setViewportElement
+        setElement
     ];
 }
 async function loadRouteModule(route, routeAssets, chunkLoader) {
@@ -196,7 +134,8 @@ const PrefetchPageLinks = ({ path, includeData })=>{
     const context = useContext(InternalRuntimeContext);
     const { routeManifest, routes } = context;
     const { routeAssets } = routeManifest || {};
-    const allowNetworkWarmup = shouldWarmupOnCurrentNetwork();
+    const policy = context.linkPrefetchPolicy;
+    const allowNetworkWarmup = policy?.canWarmup() ?? true;
     const matches = useMemo(()=>Array.isArray(routes) ? matchRoutes(routes, pathname) : [], [
         pathname,
         routes
@@ -216,7 +155,16 @@ const PrefetchPageLinks = ({ path, includeData })=>{
             const routeAsset = routeId ? routeAssets[routeId] : void 0;
             const chunkIds = routeAsset?.chunkIds;
             if (!routeId || !Array.isArray(chunkIds) || 0 === chunkIds.length) return ()=>{};
-            return scheduleWarmup(getNavigationWarmupCacheKey(context, chunkLoader, getWebpackPublicPath(), `route-module:${routeId}:${chunkIds.join(',')}`), ()=>loadRouteModule(match.route, routeAssets, chunkLoader));
+            const run = ()=>loadRouteModule(match.route, routeAssets, chunkLoader);
+            if (policy) return policy.schedule({
+                runtimeContext: context,
+                chunkLoader,
+                publicPath: getWebpackPublicPath(),
+                key: `route-module:${routeId}:${chunkIds.join(',')}`,
+                run
+            });
+            run().catch(()=>{});
+            return ()=>{};
         });
         return ()=>{
             cancellations.forEach((cancel)=>cancel());
@@ -225,6 +173,7 @@ const PrefetchPageLinks = ({ path, includeData })=>{
         allowNetworkWarmup,
         chunkLoader,
         context,
+        policy,
         routeAssetGeneration
     ]);
     if (!allowNetworkWarmup || !includeData || !window._SSR_DATA) return null;
@@ -236,10 +185,11 @@ const PrefetchPageLinks = ({ path, includeData })=>{
 };
 const PrefetchDataLinks = ({ matches, path, routeManifest })=>{
     const { pathname, search, hash } = path;
+    const policy = useContext(InternalRuntimeContext).linkPrefetchPolicy;
     const currentMatches = useMatches();
     const basename = useHref('/');
     const dataHrefs = useMemo(()=>matches?.filter((match, index)=>{
-            if (!isDataWarmupEnabled(match.route) || !match.route.loader || 'function' != typeof match.route.loader || 0 === match.route.loader.length) return false;
+            if (policy?.allowData(match.route) === false || !match.route.loader || 'function' != typeof match.route.loader || 0 === match.route.loader.length) return false;
             if (match.route.shouldRevalidate) {
                 const currentUrl = new URL(location.pathname + location.search + location.hash, window.origin);
                 const nextUrl = new URL(pathname + search + hash, window.origin);
@@ -266,16 +216,10 @@ const PrefetchDataLinks = ({ matches, path, routeManifest })=>{
         children: dataHrefs
     });
 };
-const normalizePreloadBehavior = (preload, prefetch)=>{
-    if (false === preload || 'none' === preload) return 'none';
-    if (void 0 !== preload) return preload;
-    if ('none' === prefetch) return 'none';
-    return prefetch;
-};
-const createPrefetchLink = (Link)=>/*#__PURE__*/ react.forwardRef(({ to, prefetch = DEFAULT_PREFETCH_BEHAVIOR, preload, ...props }, forwardedRef)=>{
+const createPrefetchLink = (Link)=>/*#__PURE__*/ react.forwardRef(({ to, prefetch, preload, ...props }, forwardedRef)=>{
         const isAbsolute = 'string' == typeof to && ABSOLUTE_URL_REGEX.test(to);
-        const resolvedPreload = normalizePreloadBehavior(preload, prefetch);
-        const [shouldPrefetch, shouldPreload, prefetchHandlers, setViewportElement] = usePrefetchBehavior(prefetch, resolvedPreload, props);
+        const policy = useContext(InternalRuntimeContext).linkPrefetchPolicy;
+        const [shouldPrefetch, shouldPreload, prefetchHandlers, setViewportElement] = usePrefetchBehavior(prefetch, preload, props, policy);
         const setAnchorRef = react.useCallback((element)=>{
             setViewportElement(element);
             setRef(forwardedRef, element);

package/dist/esm-node/router/runtime/hooks.mjs

@@ -7,4 +7,12 @@ const onBeforeCreateRouter = createRouterSyncHook();
 const onAfterCreateRouter = createRouterSyncHook();
 const onBeforeHydrateRouter = createRouterSyncHook();
 const onAfterHydrateRouter = createRouterSyncHook();
-export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter };
+const routerProviderRegistryHooks = {
+    modifyRoutes: modifyRoutes,
+    onBeforeCreateRoutes: onBeforeCreateRoutes,
+    onBeforeCreateRouter: onBeforeCreateRouter,
+    onAfterCreateRouter: onAfterCreateRouter,
+    onBeforeHydrateRouter: onBeforeHydrateRouter,
+    onAfterHydrateRouter: onAfterHydrateRouter
+};
+export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter, routerProviderRegistryHooks };

package/dist/esm-node/router/runtime/internal.mjs

@@ -1,35 +1,4 @@
 import "node:module";
-import { merge } from "@modern-js/runtime-utils/merge";
-import { modifyRoutes, routerPlugin } from "./plugin.mjs";
-import { createRouterProviderRealm, registerRouterProvider, reportUnsupportedProviderRegistryHooks, resolveRouterProvider, routerProviderRegistryHooks } from "./provider.mjs";
-registerRouterProvider('react-router', routerPlugin, {
-    isDefault: true
-});
-const createRouterPlugin = (localProviders = [])=>{
-    const providerRealm = createRouterProviderRealm([
-        {
-            name: 'react-router',
-            factory: routerPlugin,
-            isDefault: true
-        },
-        ...localProviders
-    ]);
-    return (userConfig = {})=>({
-            name: '@modern-js/plugin-router',
-            registryHooks: routerProviderRegistryHooks,
-            setup: (api)=>{
-                const mergedConfig = merge(api.getRuntimeConfig().router || {}, userConfig);
-                const pluginFactory = resolveRouterProvider(mergedConfig.framework, {
-                    realm: providerRealm
-                });
-                const providerPlugin = pluginFactory(userConfig);
-                reportUnsupportedProviderRegistryHooks(providerPlugin);
-                providerPlugin.setup?.(api);
-            }
-        });
-};
-const internal_routerPlugin = createRouterPlugin();
-const internal = internal_routerPlugin;
+export { routerProviderRegistryHooks } from "./hooks.mjs";
+export { modifyRoutes, routerPlugin as default, routerPlugin } from "./plugin.mjs";
 export { renderRoutes } from "./utils.mjs";
-export default internal;
-export { createRouterPlugin, createRouterProviderRealm, internal_routerPlugin as routerPlugin, modifyRoutes, registerRouterProvider, resolveRouterProvider };

package/dist/esm-node/router/runtime/plugin.mjs

@@ -5,9 +5,8 @@ import { RouterProvider, createBrowserRouter, createHashRouter, createRoutesFrom
 import { normalizePathname } from "@modern-js/runtime-utils/url";
 import * as __rspack_external_react from "react";
 import { InternalRuntimeContext, getGlobalEnableRsc, getGlobalIsRscClient, getGlobalLayoutApp, getGlobalRoutes } from "../../core/context/index.mjs";
-import { applyRouterRuntimeState } from "./lifecycle.mjs";
+import { routerProviderRegistryHooks } from "./hooks.mjs";
 import { Link } from "./PrefetchLink.mjs";
-import { routerProviderRegistryHooks } from "./provider.mjs";
 import { createClientRouterFromPayload } from "./rsc-router.mjs";
 import { createRouteObjectsFromConfig, deserializeErrors, renderRoutes, urlJoin } from "./utils.mjs";
 let finalRouteConfig = {
@@ -169,11 +168,6 @@ function useRouterCreation(props, options) {
             basename: _basename,
             hydrationData
         });
-        applyRouterRuntimeState(runtimeContext, {
-            framework: 'react-router',
-            basename: _basename,
-            instance: router
-        });
         hooks.onAfterCreateRouter.call({
             ...routerLifecycleContext,
             router,

package/dist/esm-node/router/runtime/plugin.node.mjs

@@ -9,9 +9,8 @@ import { useContext } from "react";
 import { InternalRuntimeContext, getGlobalEnableRsc, getGlobalLayoutApp, getGlobalRoutes } from "../../core/context/index.mjs";
 import { setServerPayload } from "../../core/context/serverPayload/index.server.mjs";
 import DeferredDataScripts_node from "./DeferredDataScripts.node.mjs";
-import { applyRouterRuntimeState, createRouterServerSnapshot } from "./lifecycle.mjs";
+import { routerProviderRegistryHooks } from "./hooks.mjs";
 import { Link } from "./PrefetchLink.mjs";
-import { routerProviderRegistryHooks } from "./provider.mjs";
 import { RSCStaticRouter, createServerPayload, handleRSCRedirect, prepareRSCRoutes } from "./rsc-router.mjs";
 import { createRouteObjectsFromConfig, renderRoutes, urlJoin } from "./utils.mjs";
 function createRemixRequest(request) {
@@ -24,24 +23,6 @@ function createRemixRequest(request) {
         signal: controller.signal
     });
 }
-function createReactRouterServerSnapshot(routerContext, basename) {
-    return createRouterServerSnapshot({
-        framework: 'react-router',
-        basename,
-        statusCode: routerContext.statusCode,
-        errors: routerContext.errors,
-        routerData: {
-            loaderData: routerContext.loaderData,
-            errors: routerContext.errors
-        },
-        matches: routerContext.matches.map((match)=>{
-            const routeId = match.route.id;
-            return 'string' == typeof routeId ? {
-                routeId
-            } : void 0;
-        }).filter((match)=>void 0 !== match)
-    });
-}
 const routerPlugin = (userConfig = {})=>({
         name: '@modern-js/plugin-router',
         registryHooks: routerProviderRegistryHooks,
@@ -108,18 +89,9 @@ const routerPlugin = (userConfig = {})=>({
                     throw errors[0];
                 }
                 context.routerContext = routerContext;
-                const routerServerSnapshot = createReactRouterServerSnapshot(routerContext, _basename);
-                applyRouterRuntimeState(context, {
-                    framework: 'react-router',
-                    basename: _basename,
-                    instance: routerContext,
-                    matchedRouteIds: routerServerSnapshot.matchedRouteIds,
-                    serverSnapshot: routerServerSnapshot
-                });
                 hooks.onAfterCreateRouter.call({
                     ...routerLifecycleContext,
                     router: routerContext,
-                    serverSnapshot: routerServerSnapshot,
                     runtimeContext: context
                 });
                 let payload;

package/dist/esm-node/router/runtime/redirect.mjs

@@ -2,7 +2,7 @@ import "node:module";
 const handleRSCRedirect = (headers, basename, status)=>{
     const newHeaders = new Headers(headers);
     let redirectUrl = headers.get('Location');
-    if (!redirectUrl || ![
+    if (null === redirectUrl || '' === redirectUrl || ![
         301,
         302,
         303,

package/dist/types/cli/ssr/index.d.ts

@@ -1,6 +1,3 @@
 import type { AppTools, CliPlugin } from '@modern-js/app-tools';
-import type { MergedEnvironmentConfig } from '@rsbuild/core';
-type EnvironmentConfigLike = Partial<Pick<MergedEnvironmentConfig, 'output' | 'source' | 'tools'>>;
-export declare const shouldUseModuleFederationNodeOutput: (config: EnvironmentConfigLike) => boolean;
 export declare const ssrPlugin: () => CliPlugin<AppTools>;
 export default ssrPlugin;

package/dist/types/core/context/index.d.ts

@@ -20,12 +20,10 @@ type InternalRuntimeContextLike = {
     [key: string]: any;
 };
 export { DefaultNotFound } from '../../router/runtime/DefaultNotFound.js';
-export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter, type RouterExtendsHooks, } from '../../router/runtime/hooks.js';
-export { applyRouterRuntimeState, applyRouterServerPrepareResult, cleanupRouterRuntimeState, createRouterRuntimeState, createRouterServerSnapshot, getRouterHydrationScripts, getRouterMatchedRouteIds, getRouterRuntimeState, getRouterServerSnapshot, type RouterLifecycleContext, type RouterLifecyclePhase, } from '../../router/runtime/lifecycle.js';
-export { createRouterProviderRealm, type RouterProviderFactory, type RouterProviderPlugin, type RouterProviderRealm, type RouterProviderRegistration, registerRouterProvider, resolveRouterProvider, routerProviderRegistryHooks, } from '../../router/runtime/provider.js';
-export type { BuiltInRouterFramework, InternalRouterRuntimeState, InternalRouterServerSnapshot, LoaderFunction, LoaderFunctionArgs, ModernRoute, RouterFramework, RouterRouteMatchSnapshot, RouterServerPrepareResult, } from '../../router/runtime/types.js';
-export { createRuntimeContextExtension, type RuntimeContextExtension, } from './extensions.js';
-export { getInitialContext, InternalRuntimeContext, RuntimeContext, type TInternalRuntimeContext, type TRuntimeContext, } from './runtime.js';
+export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter, type RouterExtendsHooks, type RouterLifecycleContext, routerProviderRegistryHooks, } from '../../router/runtime/hooks.js';
+export type { LinkPrefetchPolicy } from '../../router/runtime/PrefetchLink.js';
+export type { LoaderFunction, LoaderFunctionArgs, ModernRoute, } from '../../router/runtime/types.js';
+export { getInitialContext, InternalRuntimeContext, RuntimeComponentResolverContext, RuntimeContext, type TInternalRuntimeContext, type TRuntimeContext, } from './runtime.js';
 export type { PayloadRoute, ServerPayload } from './serverPayload/index.js';
 interface GlobalContext {
     entryName?: string;

package/dist/types/core/context/public.d.ts

@@ -1,23 +1 @@
-import type { RouteObject } from '@modern-js/runtime-utils/router';
-import type { RequestContext } from '../types.js';
-export type { RequestContext };
-export interface TRuntimeContext {
-    initialData?: Record<string, unknown>;
-    isBrowser: boolean;
-    routes?: RouteObject[];
-    requestContext: RequestContext;
-    /**
-     * @deprecated Use `requestContext` instead
-     */
-    context: RequestContext;
-    [key: string]: unknown;
-}
-export declare const RuntimeContext: import("react").Context<TRuntimeContext>;
-/**
- * deprecated, use RuntimeContext instead
- */
-export declare const ReactRuntimeContext: import("react").Context<TRuntimeContext>;
-/**
- * @deprecated use use(RuntimeContext) instead
- */
-export declare const useRuntimeContext: () => TRuntimeContext;
+export { ReactRuntimeContext, type RequestContext, RuntimeContext, type TRuntimeContext, useRuntimeContext, } from './runtime.js';

package/dist/types/core/context/runtime.d.ts

@@ -1,7 +1,10 @@
+import type { ResolveComponentFn } from '@modern-js/plugin/runtime';
 import type { RouteObject, StaticHandlerContext } from '@modern-js/runtime-utils/router';
 import type { BaseSSRServerContext } from '@modern-js/types';
+import type { LinkPrefetchPolicy } from '../../router/runtime/PrefetchLink.js';
 import type { RouteManifest } from '../../router/runtime/types.js';
-import { type TRuntimeContext } from './public.js';
+import type { RequestContext } from '../types.js';
+export type { RequestContext };
 export type InternalSSRContext = {
     request: BaseSSRServerContext['request'] & {
         raw?: Request;
@@ -9,12 +12,23 @@ export type InternalSSRContext = {
     response: BaseSSRServerContext['response'];
     [key: string]: any;
 };
-export { ReactRuntimeContext, RuntimeContext, type TRuntimeContext, useRuntimeContext, } from './public.js';
+export interface TRuntimeContext {
+    initialData?: Record<string, unknown>;
+    isBrowser: boolean;
+    routes?: RouteObject[];
+    requestContext: RequestContext;
+    /**
+     * @deprecated Use `requestContext` instead
+     */
+    context: RequestContext;
+    [key: string]: unknown;
+}
 /**
  * InternalRuntimeContext used internally and by plugins
  */
 export interface TInternalRuntimeContext extends TRuntimeContext {
     routeManifest?: RouteManifest;
+    linkPrefetchPolicy?: LinkPrefetchPolicy;
     routes?: RouteObject[];
     routerContext?: StaticHandlerContext;
     unstable_getBlockNavState?: () => boolean;
@@ -23,4 +37,14 @@ export interface TInternalRuntimeContext extends TRuntimeContext {
     _internalRouterBaseName?: any;
 }
 export declare const InternalRuntimeContext: import("react").Context<TInternalRuntimeContext>;
+export declare const RuntimeContext: import("react").Context<TRuntimeContext>;
+export declare const RuntimeComponentResolverContext: import("react").Context<ResolveComponentFn | undefined>;
+/**
+ * deprecated, use RuntimeContext instead
+ */
+export declare const ReactRuntimeContext: import("react").Context<TRuntimeContext>;
+/**
+ * @deprecated use use(RuntimeContext) instead
+ */
+export declare const useRuntimeContext: () => TRuntimeContext;
 export declare const getInitialContext: (isBrowser?: boolean, routeManifest?: RouteManifest) => TInternalRuntimeContext;

package/dist/types/core/react/wrapper.d.ts

@@ -1,3 +1,9 @@
+import type { ResolveComponentFn } from '@modern-js/plugin/runtime';
 import type React from 'react';
 import { type TRuntimeContext } from '../context/index.js';
+export declare function wrapRuntimeComponentResolver(root: React.ReactNode, hooks?: {
+    resolveComponent?: {
+        call: ResolveComponentFn;
+    };
+} | undefined): React.ReactElement;
 export declare function wrapRuntimeContextProvider(App: React.ReactElement, contextValue: TRuntimeContext): React.JSX.Element;

package/dist/types/core/server/helmet.d.ts

@@ -1,5 +1,4 @@
-import type { HelmetServerState } from 'react-helmet-async';
-import type { TInternalRuntimeContext } from '../context/index.js';
-export declare function getHelmetData(runtimeContext: TInternalRuntimeContext): HelmetServerState | undefined;
-export declare function createReplaceHelemt(helmetData?: HelmetServerState): (template: string) => string;
-export declare function helmetReplace(content: string, helmetData: HelmetServerState): string;
+import type { SSRHeadData, SSRRenderLifecycle } from '@modern-js/plugin/runtime';
+export declare function getHelmetData(providers: readonly SSRRenderLifecycle[]): SSRHeadData | undefined;
+export declare function createReplaceHelemt(helmetData?: SSRHeadData): (template: string) => string;
+export declare function helmetReplace(content: string, helmetData: SSRHeadData): string;

package/dist/types/core/server/requestHandler.d.ts

@@ -1,7 +1,7 @@
-import type { RequestHandler, RequestHandlerOptions } from '@modern-js/app-tools';
+import type { RequestHandler, RequestHandlerOptions } from '@modern-js/server-core';
 import React from 'react';
 import { type TInternalRuntimeContext } from '../context/index.js';
-export type { RequestHandlerConfig as HandleRequestConfig } from '@modern-js/app-tools';
+export type { RequestHandlerConfig as HandleRequestConfig } from '@modern-js/server-core';
 export type HandleRequestOptions = Exclude<RequestHandlerOptions, 'staticGenerate'> & {
     runtimeContext: TInternalRuntimeContext;
 };

package/dist/types/core/server/requestResponse.d.ts

@@ -1,4 +1,4 @@
-import type { OnError } from '@modern-js/app-tools';
+import type { OnError } from '@modern-js/types';
 import type { TInternalRuntimeContext } from '../context/index.js';
 import type { RouterCleanup } from './routerCleanup.js';
 export type ResponseProxy = {

package/dist/types/core/server/routerCleanup.d.ts

@@ -9,7 +9,7 @@
  * failures are reported through the request's `onError` instead of being
  * swallowed.
  */
-import type { OnError } from '@modern-js/app-tools';
+import type { OnError } from '@modern-js/types';
 import type { TInternalRuntimeContext } from '../context/index.js';
 export declare const ROUTER_CLEANUP_ERROR = "An error occurs during router runtime cleanup";
 export type RouterCleanup = {

package/dist/types/core/server/shared.d.ts

@@ -1,4 +1,5 @@
-import type { ServerUserConfig } from '@modern-js/app-tools';
+import type { SSRAssetGroup, SSRAssetTransformInfo, SSRRenderAsset, SSRRenderLifecycle, SSRRenderTerminal, SSRRouterData, SSRTemplateChunk, StreamSSRExtender } from '@modern-js/plugin/runtime';
+import type { ServerUserConfig } from '@modern-js/server-core';
 import type { HandleRequestOptions } from './requestHandler.js';
 export type RenderOptions = HandleRequestOptions;
 export type SSRConfig = NonNullable<ServerUserConfig['ssr']>;
@@ -6,3 +7,25 @@ export type RenderStreaming = (request: Request, serverRoot: React.ReactElement,
 export type RenderString = (request: Request, serverRoot: React.ReactElement, optinos: RenderOptions) => Promise<string>;
 export type BuildHtmlCb = (template: string) => string | Promise<string>;
 export declare function buildHtml(template: string, callbacks: BuildHtmlCb[]): Promise<string>;
+export declare function createSSRRenderLifecycle(observers: SSRRenderLifecycle[]): {
+    transformAssets<T extends SSRRenderAsset>(groups: readonly SSRAssetGroup<T>[], info: Omit<SSRAssetTransformInfo<T>, 'groups'>): readonly T[];
+    transformTemplateChunk(chunk: SSRTemplateChunk): SSRTemplateChunk;
+    getRouterData(): SSRRouterData | undefined;
+    readonly terminal: SSRRenderTerminal | undefined;
+    beforeReact(): void;
+    completedBody(html: string, phase: 'complete' | 'shell'): string;
+    finish(result: SSRRenderTerminal): void;
+};
+export declare function replaceSSRTemplateChunk(chunk: SSRTemplateChunk, lifecycle?: ReturnType<typeof createSSRRenderLifecycle>, options?: {
+    preserveEmpty?: boolean;
+}): string;
+export declare function orderSSRStreamTransforms(extenders: StreamSSRExtender[]): StreamSSRExtender[];
+export declare function createSSRStreamErrorReporter(onError: (error: unknown) => void): (error: unknown) => void;
+/** Observe the delivered body, rather than declaring completion at allReady. */
+export declare function observeSSRStream(source: ReadableStream<Uint8Array>, options: {
+    lifecycle: ReturnType<typeof createSSRRenderLifecycle>;
+    onError: (error: unknown) => void | Promise<void>;
+    signal: AbortSignal;
+    onCancel?: (reason: unknown) => void | Promise<void>;
+    onComplete?: () => void | Promise<void>;
+}): ReadableStream<Uint8Array>;

package/dist/types/core/server/stream/afterTemplate.d.ts

@@ -1,7 +1,7 @@
 import { type RenderLevel } from '../../constants.js';
 import type { TInternalRuntimeContext } from '../../context/index.js';
 import type { HandleRequestConfig } from '../requestHandler.js';
-import { type SSRConfig } from '../shared.js';
+import { type createSSRRenderLifecycle, type SSRConfig } from '../shared.js';
 export type BuildShellAfterTemplateOptions = {
     runtimeContext: TInternalRuntimeContext;
     renderLevel: RenderLevel;
@@ -9,5 +9,6 @@ export type BuildShellAfterTemplateOptions = {
     request: Request;
     entryName: string;
     config: HandleRequestConfig;
+    lifecycle?: ReturnType<typeof createSSRRenderLifecycle>;
 };
 export declare function buildShellAfterTemplate(afterAppTemplate: string, options: BuildShellAfterTemplateOptions): Promise<string>;

package/dist/types/core/server/stream/beforeTemplate.d.ts

@@ -1,10 +1,13 @@
+import type { SSRHeadData } from '@modern-js/plugin/runtime';
 import type { TInternalRuntimeContext } from '../../context/index.js';
 import type { HandleRequestConfig } from '../requestHandler.js';
+import { type createSSRRenderLifecycle } from '../shared.js';
 export interface BuildShellBeforeTemplateOptions {
     runtimeContext: TInternalRuntimeContext;
     entryName: string;
     config: HandleRequestConfig;
     styledComponentsStyleTags?: string;
-    moduleFederationCssAssets?: string[];
+    lifecycle?: ReturnType<typeof createSSRRenderLifecycle>;
+    helmetData?: SSRHeadData;
 }
 export declare function buildShellBeforeTemplate(beforeAppTemplate: string, options: BuildShellBeforeTemplateOptions): Promise<string>;

package/dist/types/core/server/stream/beforeTemplate.worker.d.ts

@@ -1,10 +1,13 @@
+import type { SSRHeadData } from '@modern-js/plugin/runtime';
 import type { TInternalRuntimeContext } from '../../context/index.js';
 import type { HandleRequestConfig } from '../requestHandler.js';
+import { type createSSRRenderLifecycle } from '../shared.js';
 export interface BuildShellBeforeTemplateOptions {
     runtimeContext: TInternalRuntimeContext;
     entryName: string;
     config: HandleRequestConfig;
     styledComponentsStyleTags?: string;
-    moduleFederationCssAssets?: string[];
+    lifecycle?: ReturnType<typeof createSSRRenderLifecycle>;
+    helmetData?: SSRHeadData;
 }
 export declare function buildShellBeforeTemplate(beforeAppTemplate: string, options: BuildShellBeforeTemplateOptions): Promise<string>;