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

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

@@ -1,13 +1,12 @@
 import "node:module";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { InternalRuntimeContext, getGlobalEnableRsc, getGlobalIsRscClient, getGlobalLayoutApp, getGlobalRoutes } from "@modern-js/runtime/context";
 import { merge } from "@modern-js/runtime-utils/merge";
 import { RouterProvider, createBrowserRouter, createHashRouter, createRoutesFromElements, useHref, useInRouterContext, useLocation, useMatches, useNavigate, useParams } from "@modern-js/runtime-utils/router";
 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 = {
@@ -68,7 +67,6 @@ const routerPlugin = (userConfig = {})=>({
                     const match = serverBase.find((baseUrl)=>isSegmentPrefix(pathname, baseUrl));
                     return match || '/';
                 };
-                let cachedRouter = null;
                 const RouterWrapper = (props)=>{
                     const routerResult = useRouterCreation(("u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ : true === getGlobalEnableRsc()) ? {
                         ...props,
@@ -80,12 +78,7 @@ const routerPlugin = (userConfig = {})=>({
                         selectBasePath,
                         basename
                     });
-                    const router = (0, __rspack_external_react.useMemo)(()=>{
-                        if (cachedRouter) return cachedRouter;
-                        cachedRouter = routerResult.router;
-                        return cachedRouter;
-                    }, []);
-                    const { routes } = routerResult;
+                    const { router, routes } = routerResult;
                     routesContainer.current = routes;
                     beforeCreateRouter = false;
                     const routerContent = /*#__PURE__*/ jsxs(Fragment, {
@@ -129,7 +122,8 @@ function useRouterCreation(props, options) {
     const { unstable_getBlockNavState: getBlockNavState } = runtimeContext;
     const rscPayload = ("u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ : true === getGlobalEnableRsc()) && props?.rscPayload ? safeUse(props.rscPayload) : null;
     let hydrationData = "u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ ? window._ROUTER_DATA || rscPayload : window._ROUTER_DATA : true === getGlobalEnableRsc() ? window._ROUTER_DATA || rscPayload : window._ROUTER_DATA;
-    return (0, __rspack_external_react.useMemo)(()=>{
+    const result = (0, __rspack_external_react.useRef)(null);
+    if (null === result.current) {
         if (hydrationData?.errors) hydrationData = {
             ...hydrationData,
             errors: deserializeErrors(hydrationData.errors)
@@ -145,10 +139,11 @@ function useRouterCreation(props, options) {
         const hooks = api.getHooks();
         if (("u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ : true === getGlobalEnableRsc()) && rscPayload) try {
             const router = createClientRouterFromPayload(rscPayload, routes, _basename);
-            return {
+            result.current = {
                 router,
                 routes: router.routes || []
             };
+            return result.current;
         } catch (e) {
             console.error('Failed to create router from RSC payload:', e);
         }
@@ -169,11 +164,6 @@ function useRouterCreation(props, options) {
             basename: _basename,
             hydrationData
         });
-        applyRouterRuntimeState(runtimeContext, {
-            framework: 'react-router',
-            basename: _basename,
-            instance: router
-        });
         hooks.onAfterCreateRouter.call({
             ...routerLifecycleContext,
             router,
@@ -202,16 +192,11 @@ function useRouterCreation(props, options) {
             };
             return originSubscribe(wrappedListener);
         };
-        return {
+        result.current = {
             router,
             routes: modifiedRoutes
         };
-    }, [
-        finalRouteConfig,
-        props,
-        _basename,
-        hydrationData,
-        getBlockNavState
-    ]);
+    }
+    return result.current;
 }
 export { beforeCreateRouter, finalRouteConfig, modifyRoutes, routerPlugin };

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

@@ -1,17 +1,16 @@
 import "node:module";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { InternalRuntimeContext, getGlobalEnableRsc, getGlobalLayoutApp, getGlobalRoutes } from "@modern-js/runtime/context";
 import { merge } from "@modern-js/runtime-utils/merge";
 import { createRequestContext } from "@modern-js/runtime-utils/node";
 import { StaticRouterProvider, createRoutesFromElements, createStaticHandler, createStaticRouter, useInRouterContext, useLocation, useNavigate, useParams } from "@modern-js/runtime-utils/router";
 import { time } from "@modern-js/runtime-utils/time";
 import { LOADER_REPORTER_NAME } from "@modern-js/utils/universal/constants";
 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;
@@ -152,7 +124,7 @@ const routerPlugin = (userConfig = {})=>({
                         }) : /*#__PURE__*/ jsx(RSCStaticRouter, {
                             basename: basename
                         });
-                        {
+                        else {
                             const { nonce, mode, useJsonScript } = context.ssrContext;
                             const remixRouter = createStaticRouter(routes, routerContext);
                             const routerWrapper = /*#__PURE__*/ jsxs(Fragment, {

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, ReactRuntimeContext, type RequestContext, RuntimeComponentResolverContext, RuntimeContext, type TInternalRuntimeContext, type TRuntimeContext, useRuntimeContext, } 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 './index.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/index.d.ts

@@ -1,5 +1,5 @@
+export { RuntimeContext, useRuntimeContext, } from './context/index.js';
 export { defineRuntimeConfig } from './config.js';
 export type { TRuntimeContext } from './context/runtime.js';
-export { RuntimeContext, useRuntimeContext, } from './context/runtime.js';
 export type { RuntimePlugin } from './plugin/index.js';
 export type { SSRContainer, SSRData } from './types.js';

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

@@ -1,3 +1,9 @@
-import type React from 'react';
+import type { ResolveComponentFn } from '@modern-js/plugin/runtime';
 import { type TRuntimeContext } from '../context/index.js';
+import type React from 'react';
+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 React from 'react';
 import { type TInternalRuntimeContext } from '../context/index.js';
-export type { RequestHandlerConfig as HandleRequestConfig } from '@modern-js/app-tools';
+import type { RequestHandler, RequestHandlerOptions } from '@modern-js/server-core';
+import React from 'react';
+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>;

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

@@ -1,4 +1,4 @@
-import type { OnError } from '@modern-js/app-tools';
+import type { OnError } from '@modern-js/types';
 import type { ClientManifest as RscClientManifest, ServerManifest as RscServerManifest, SSRManifest as RscSSRManifest } from '@modern-js/types/server';
 import type React from 'react';
 import type { TInternalRuntimeContext } from '../../context/index.js';
@@ -16,7 +16,7 @@ export type CreateReadableStreamFromElementOptions = {
     ssrConfig: SSRConfig;
     htmlTemplate: string;
     entryName: string;
-    moduleFederationCssAssets?: string[];
+    resource?: object;
     rscClientManifest?: RscClientManifest;
     rscSSRManifest?: RscSSRManifest;
     rscServerManifest?: RscServerManifest;
@@ -32,6 +32,20 @@ export declare enum ShellChunkStatus {
     START = 0,
     FINISH = 1
 }
+/**
+ * The document head is sealed when the shell end mark is written, so only head
+ * tags emitted before it reach `<head>`. React writes a completed Suspense
+ * boundary after the shell once the flushed bytes exceed `progressiveChunkSize`,
+ * which drops the head of every large route and keeps its content hidden until
+ * the inline `$RC` script runs. Completed boundaries therefore stay inline in
+ * the shell; pending boundaries still stream when they resolve. Buffering
+ * paths (`onAllReady`) thereby seal the head after all content.
+ *
+ * Measured on a ~1 MB route completed at shell time (React 19.3, Node): the
+ * default chunk size reaches the shell end mark in 0.7 ms, this one in 1.2 ms,
+ * so the head fix costs no measurable time to first byte.
+ */
+export declare const SHELL_PROGRESSIVE_CHUNK_SIZE: number;
 export declare function resolveStreamingMode(request: Request, forceStreamToString: boolean): {
     onReady: 'onAllReady' | 'onShellReady';
     waitForAllReady: boolean;

package/dist/types/core/server/string/loadable.d.ts

@@ -1,5 +1,5 @@
 import type { ReactElement } from 'react';
-import type { TInternalRuntimeContext } from '../../context/index.js';
+import type { createSSRRenderLifecycle } from '../shared.js';
 import type { ChunkSet, Collector } from './types.js';
 declare module '@loadable/server' {
     interface ChunkExtractor {
@@ -11,10 +11,9 @@ export interface LoadableCollectorOptions {
     nonce?: string;
     stats?: Record<string, any>;
     routeManifest?: Record<string, any>;
-    runtimeContext: TInternalRuntimeContext;
     template: string;
     entryName: string;
-    moduleFederationCssAssets?: string[];
+    lifecycle?: ReturnType<typeof createSSRRenderLifecycle>;
     chunkSet: ChunkSet;
     config: LoadableCollectorConfig;
 }
@@ -28,6 +27,10 @@ export interface LoadableCollectorConfig {
 export declare class LoadableCollector implements Collector {
     private options;
     private extractor?;
+    readonly stylesheetInfo: {
+        emittedAssets: string[];
+        attributes: Record<string, unknown>;
+    };
     constructor(options: LoadableCollectorOptions);
     private get existsAssets();
     collect(comopnent: ReactElement): ReactElement;

package/dist/types/core/server/string/ssrData.d.ts

@@ -1,7 +1,7 @@
 import type { StaticHandlerContext } from '@modern-js/runtime-utils/router';
 import type { TInternalRuntimeContext } from '../../context/index.js';
 import type { SSRServerContext } from '../../types.js';
-import type { SSRConfig } from '../shared.js';
+import type { createSSRRenderLifecycle, SSRConfig } from '../shared.js';
 import type { ChunkSet, Collector } from './types.js';
 export interface SSRDataCreatorOptions {
     runtimeContext: TInternalRuntimeContext;
@@ -10,6 +10,7 @@ export interface SSRDataCreatorOptions {
     ssrContext: SSRServerContext;
     ssrConfig?: SSRConfig;
     routerContext?: StaticHandlerContext;
+    lifecycle?: ReturnType<typeof createSSRRenderLifecycle>;
     nonce?: string;
     useJsonScript?: boolean;
 }

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

@@ -1,9 +1,5 @@
-import type { ReactElement } from 'react';
 import type { RenderLevel } from '../../constants.js';
-export interface Collector {
-    collect?: (comopnent: ReactElement) => ReactElement;
-    effect: () => void | Promise<void>;
-}
+export type { Collector } from '@modern-js/plugin/runtime';
 export type ChunkSet = {
     renderLevel: RenderLevel;
     ssrScripts: string;

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

@@ -1,4 +1,4 @@
-import type { OnError, OnTiming } from '@modern-js/app-tools';
+import type { OnError, OnTiming } from '@modern-js/types';
 export declare enum SSRTimings {
     PRERENDER = "ssr-prerender",
     RENDER_HTML = "ssr-render-html",

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

@@ -1,5 +1,5 @@
-import type { ServerUserConfig } from '@modern-js/app-tools';
 import type { StaticHandlerContext } from '@modern-js/runtime-utils/router';
+import type { ServerUserConfig } from '@modern-js/server-core';
 import type { SSRConfig } from './shared.js';
 export declare function attributesToString(attributes: Record<string, any>): string;
 /**

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

@@ -1,5 +1,4 @@
-import type { OnError, OnTiming } from '@modern-js/app-tools';
-import type { BaseSSRServerContext } from '@modern-js/types';
+import type { BaseSSRServerContext, OnError, OnTiming } from '@modern-js/types';
 import type { RenderLevel } from './constants.js';
 declare global {
     interface Window {

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

@@ -2,5 +2,6 @@ import type { AppTools, CliPlugin } from '@modern-js/app-tools';
 import type { Entrypoint } from '@modern-js/types/cli';
 export declare const processScriptPlaceholders: (html: string, nonce?: string) => string;
 export declare const getDocumentByEntryName: (entrypoints: Entrypoint[], entryName: string, fallbackDir?: string) => string | undefined;
+export declare const getDocumentTempEntry: (internalDirectory: string, compilerName: string | undefined, entryName: string) => string;
 export declare const documentPlugin: () => CliPlugin<AppTools>;
 export default documentPlugin;

package/dist/types/exports/head.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
-import { Helmet as AsyncHelmet, HelmetData as AsyncHelmetData, type HelmetDatum, type HelmetHTMLBodyDatum, type HelmetHTMLElementDatum, type HelmetProps, HelmetProvider, type HelmetServerState, type HelmetTags } from 'react-helmet-async';
-export declare const Helmet: (props: React.PropsWithChildren<HelmetProps>) => React.CElement<React.PropsWithChildren<HelmetProps>, AsyncHelmet> | React.ReactElement<{}, string | React.JSXElementConstructor<any>> | null;
+import { HelmetData as AsyncHelmetData, type HelmetDatum, type HelmetHTMLBodyDatum, type HelmetHTMLElementDatum, type HelmetProps, HelmetProvider, type HelmetServerState, type HelmetTags } from 'react-helmet-async';
+export declare const Helmet: (props: React.PropsWithChildren<HelmetProps>) => React.ReactElement<any, string | React.JSXElementConstructor<any>>;
 declare const head: {
     Helmet: typeof Helmet;
     HelmetData: typeof AsyncHelmetData;

package/dist/types/internal.d.ts

@@ -1 +1 @@
-export { InternalRuntimeContext, type TInternalRuntimeContext, } from './core/context/runtime.js';
+export { InternalRuntimeContext, type TInternalRuntimeContext, } from './core/context/index.js';

package/dist/types/router/runtime/PrefetchLink.d.ts

@@ -1,4 +1,4 @@
-import { type LinkProps as RouterLinkProps, type NavLinkProps as RouterNavLinkProps } from '@modern-js/runtime-utils/router';
+import { type RouteObject, type LinkProps as RouterLinkProps, type NavLinkProps as RouterNavLinkProps } from '@modern-js/runtime-utils/router';
 import React from 'react';
 /**
  * Modified from https://github.com/remix-run/remix/blob/9a0601bd704d2f3ee622e0ddacab9b611eb0c5bc/packages/remix-react/components.tsx#L218
@@ -16,7 +16,7 @@ import React from 'react';
  * - "viewport": Fetched when the link enters the viewport
  * - "none": Never fetched
  */
-type PrefetchBehavior = 'intent' | 'render' | 'viewport' | 'none';
+type PrefetchBehavior = NonNullable<RouterLinkProps['prefetch']>;
 type PreloadBehavior = PrefetchBehavior | false;
 export interface LinkProps extends RouterLinkProps {
     prefetch?: PrefetchBehavior;
@@ -26,6 +26,31 @@ export interface NavLinkProps extends RouterNavLinkProps {
     prefetch?: PrefetchBehavior;
     preload?: PreloadBehavior;
 }
+/** Optional scheduling capability supplied by a runtime integration. */
+export interface LinkPrefetchPolicy {
+    observe(options: {
+        element: HTMLAnchorElement | null;
+        prefetch?: PrefetchBehavior;
+        preload?: PreloadBehavior;
+        notify: (state: {
+            code: boolean;
+            data: boolean;
+        }) => void;
+    }): {
+        onIntent: () => void;
+        onCancel: () => void;
+        dispose: () => void;
+    };
+    schedule(options: {
+        runtimeContext: object;
+        chunkLoader: object;
+        publicPath: string;
+        key: string;
+        run: () => Promise<unknown>;
+    }): () => void;
+    canWarmup: () => boolean;
+    allowData: (route: RouteObject) => boolean;
+}
 declare const Link: React.ForwardRefExoticComponent<LinkProps & React.RefAttributes<HTMLAnchorElement>>;
 declare const NavLink: React.ForwardRefExoticComponent<NavLinkProps & React.RefAttributes<HTMLAnchorElement>>;
 export { Link, NavLink };