@bleedingdev/modern-js-runtime 3.2.0-ultramodern.11 → 3.2.0-ultramodern.111

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

@@ -6,11 +6,12 @@ import { time } from "@modern-js/runtime-utils/time";
 import { LOADER_REPORTER_NAME } from "@modern-js/utils/universal/constants";
 import { RouterProvider, createMemoryHistory, createRouter } from "@tanstack/react-router";
 import { attachRouterServerSsrUtils } from "@tanstack/react-router/ssr/server";
-import { Suspense, useContext } from "react";
+import { useContext } from "react";
 import { InternalRuntimeContext, getGlobalEnableRsc, getGlobalLayoutApp, getGlobalRoutes } from "../../../core/context/index.mjs";
 import { applyRouterServerPrepareResult, createRouterServerSnapshot } from "../lifecycle.mjs";
 import { createRouteObjectsFromConfig, urlJoin } from "../utils.mjs";
 import { createModernBasepathRewrite } from "./basepathRewrite.mjs";
+import { wrapTanstackSsrHydrationBoundary } from "./hydrationBoundary.mjs";
 import { createRouteTreeFromRouteObjects, getModernRouteIdsFromMatches } from "./routeTree.mjs";
 function isPreloadableRouteComponent(component) {
     if (!component || 'function' != typeof component) return false;
@@ -38,13 +39,6 @@ async function preloadMatchedRouteComponents(tanstackRouter) {
         ]);
     }));
 }
-async function waitForRouterSerialization(tanstackRouter) {
-    const serverSsr = tanstackRouter.serverSsr;
-    if (!serverSsr || 'function' != typeof serverSsr.onSerializationFinished || serverSsr.isSerializationFinished?.()) return;
-    await new Promise((resolve)=>{
-        serverSsr.onSerializationFinished?.(resolve);
-    });
-}
 function htmlEscapeAttr(value) {
     return value.replace(/&/g, '&').replace(/"/g, '"');
 }
@@ -190,7 +184,6 @@ const tanstackRouterPlugin = (userConfig = {})=>({
                 await preloadMatchedRouteComponents(serverRouter);
                 context.ssrContext?.response.status(tanstackRouter.state.statusCode);
                 await serverRouter.serverSsr?.dehydrate?.();
-                await waitForRouterSerialization(serverRouter);
                 const ssrScriptTags = serverRouter.serverSsr?.takeBufferedScripts?.();
                 const hydrationScripts = routerManagedTagsToHtml(ssrScriptTags);
                 const matchedRouteIds = getModernRouteIdsFromMatches(serverRouter);
@@ -228,12 +221,9 @@ const tanstackRouterPlugin = (userConfig = {})=>({
                         if (!router) return App ? /*#__PURE__*/ jsx(App, {
                             ...props
                         }) : null;
-                        const routerWrapper = /*#__PURE__*/ jsx(Suspense, {
-                            fallback: null,
-                            children: /*#__PURE__*/ jsx(RouterProvider, {
-                                router: router
-                            })
-                        });
+                        const routerWrapper = wrapTanstackSsrHydrationBoundary(/*#__PURE__*/ jsx(RouterProvider, {
+                            router: router
+                        }), true);
                         return App ? /*#__PURE__*/ jsx(App, {
                             children: routerWrapper
                         }) : routerWrapper;

package/dist/esm-node/router/runtime/tanstack/prefetchLink.mjs

@@ -5,7 +5,7 @@ function resolvePreloadFromPrefetch(prefetch, preload) {
     if (void 0 !== preload) return preload;
     if ('none' === prefetch) return false;
     if ('intent' === prefetch || 'render' === prefetch || 'viewport' === prefetch) return prefetch;
-    return preload;
+    return 'viewport';
 }
 const LinkComponentImpl = (props)=>{
     const { prefetch, preload, ...rest } = props;

package/dist/esm-node/router/runtime/tanstack/routeTree.mjs

@@ -1,12 +1,18 @@
 import "node:module";
-import { createRootRoute, createRoute, notFound, redirect } from "@tanstack/react-router";
+import { createRootRoute, createRoute, notFound, redirect, rootRouteId } from "@tanstack/react-router";
+import { createElement } from "react";
 import { DefaultNotFound } from "../DefaultNotFound.mjs";
+import { withModernRouteMatchContext } from "./outlet.mjs";
 function createTanstackRoute(options) {
     return createRoute(options);
 }
 function createTanstackRootRoute(options) {
     return createRootRoute(options);
 }
+function wrapRouteComponentWithModernContext(route, component, routeId) {
+    const routeMatchId = routeId || route.id;
+    if (component && routeMatchId) route.options.component = withModernRouteMatchContext(component, routeMatchId);
+}
 function toTanstackPath(pathname) {
     return pathname.split('/').map((segment)=>{
         if (!segment) return segment;
@@ -44,6 +50,40 @@ function isModernDeferredData(value) {
 function normalizeModernLoaderResult(result) {
     return isModernDeferredData(result) ? result.data : result;
 }
+function pickRouteModuleComponent(routeModule, seen = new Set()) {
+    if ('function' == typeof routeModule || routeModule && 'object' == typeof routeModule && '$$typeof' in routeModule) return routeModule;
+    if (!routeModule || 'object' != typeof routeModule) return;
+    if (seen.has(routeModule)) return;
+    seen.add(routeModule);
+    const module = routeModule;
+    for (const candidate of [
+        module.default,
+        module.Component
+    ]){
+        const component = pickRouteModuleComponent(candidate, seen);
+        if (component) return component;
+    }
+}
+function createServerLazyImportComponent(lazyImport, fallbackComponent) {
+    if ("u" > typeof document) return fallbackComponent;
+    let resolvedComponent;
+    let pendingLoad;
+    const load = async ()=>{
+        if (resolvedComponent) return resolvedComponent;
+        const routeModule = await lazyImport();
+        const component = pickRouteModuleComponent(routeModule);
+        if (component) resolvedComponent = component;
+        return resolvedComponent;
+    };
+    const Component = (props)=>{
+        if (resolvedComponent) return createElement(resolvedComponent, props);
+        pendingLoad ||= load();
+        throw pendingLoad;
+    };
+    Component.load = load;
+    Component.preload = load;
+    return Component;
+}
 function throwTanstackRedirect(location) {
     const target = location || '/';
     try {
@@ -112,7 +152,7 @@ function wrapModernLoader(modernRoute, modernLoader, revalidationState) {
             const signal = ctx?.abortController?.signal || ctx?.signal || new AbortController().signal;
             const baseRequest = ctx?.context?.request instanceof Request ? ctx.context.request : void 0;
             const href = 'string' == typeof ctx?.location ? ctx.location : ctx?.location?.publicHref || ctx?.location?.href || ctx?.location?.url?.href || '';
-            const request = baseRequest ? new Request(baseRequest, {
+            const request = void 0 !== baseRequest ? new Request(baseRequest, {
                 signal
             }) : createModernRequest(href, signal);
             const params = mapParamsForModernLoader({
@@ -175,7 +215,7 @@ function wrapRouteObjectLoader(route, revalidationState) {
             const signal = ctx?.abortController?.signal || ctx?.signal || new AbortController().signal;
             const baseRequest = ctx?.context?.request instanceof Request ? ctx.context.request : void 0;
             const href = 'string' == typeof ctx?.location ? ctx.location : ctx?.location?.publicHref || ctx?.location?.href || ctx?.location?.url?.href || '';
-            const request = baseRequest ? new Request(baseRequest, {
+            const request = void 0 !== baseRequest ? new Request(baseRequest, {
                 signal
             }) : createModernRequest(href, signal);
             const params = mapParamsForRouteObjectLoader({
@@ -210,10 +250,18 @@ function wrapRouteObjectLoader(route, revalidationState) {
 }
 function toRouteComponent(routeObject) {
     const route = routeObject;
+    const lazyImport = 'function' == typeof route.lazyImport ? route.lazyImport : void 0;
+    const fallbackComponent = route.Component ? route.Component : route.element ? ()=>route.element : void 0;
+    if (lazyImport && fallbackComponent) return createServerLazyImportComponent(lazyImport, fallbackComponent);
     if (route.Component) return route.Component;
     const element = route.element;
     if (element) return ()=>element;
 }
+function toModernRouteComponent(route) {
+    const component = route.component || void 0;
+    if ('function' == typeof route.lazyImport && component) return createServerLazyImportComponent(route.lazyImport, component);
+    return component;
+}
 function toErrorComponent(routeObject) {
     const route = routeObject;
     if (route.ErrorBoundary) return route.ErrorBoundary;
@@ -251,12 +299,12 @@ function createRouteFromRouteObject(opts) {
     const shouldRevalidate = modernRouteObject.shouldRevalidate;
     const shouldReload = createModernShouldReload(shouldRevalidate, revalidationState);
     const stableFallbackId = routeObject.id || modernRouteObject.file || routeObject.path || 'pathless';
+    const component = toRouteComponent(routeObject);
     const base = {
         getParentRoute: ()=>parent,
-        component: toRouteComponent(routeObject),
+        component,
         pendingComponent: toPendingComponent(routeObject),
         errorComponent: toErrorComponent(routeObject),
-        wrapInSuspense: true,
         staticData: createRouteStaticData({
             modernRouteId: routeObject.id,
             modernRouteAction: modernRouteObject.action,
@@ -275,6 +323,7 @@ function createRouteFromRouteObject(opts) {
     if (isRouteObjectPathlessLayout(routeObject)) base.id = stableFallbackId;
     else base.path = routeObject.index ? '/' : toTanstackPath(routeObject.path || '');
     const route = createTanstackRoute(base);
+    wrapRouteComponentWithModernContext(route, component, routeObject.id);
     const children = routeObject.children;
     if (children && children.length > 0) {
         const childRoutes = children.map((child)=>createRouteFromRouteObject({
@@ -293,7 +342,7 @@ function createRouteFromModernRoute(opts) {
     const stableFallbackId = modernId || route._component || route.filename || route.data || ('function' == typeof route.loader ? route.id : void 0);
     const pendingComponent = route.loading || route.pendingComponent;
     const errorComponent = route.error || route.errorComponent;
-    const component = route.component;
+    const component = toModernRouteComponent(route);
     const modernLoader = route.loader;
     const modernAction = route.action;
     const modernShouldRevalidate = route.shouldRevalidate;
@@ -305,7 +354,6 @@ function createRouteFromModernRoute(opts) {
         component: component || void 0,
         pendingComponent: pendingComponent || void 0,
         errorComponent: errorComponent || void 0,
-        wrapInSuspense: true,
         staticData: createRouteStaticData({
             modernRouteId: modernId,
             modernRouteAction: modernAction,
@@ -327,6 +375,7 @@ function createRouteFromModernRoute(opts) {
         base.path = isIndexRoute ? '/' : toTanstackPath(rawPath || '');
     }
     const tanstackRoute = createTanstackRoute(base);
+    wrapRouteComponentWithModernContext(tanstackRoute, component, modernId);
     const children = route.children;
     if (children && children.length > 0) {
         const childRoutes = children.map((child)=>createRouteFromModernRoute({
@@ -339,7 +388,7 @@ function createRouteFromModernRoute(opts) {
 }
 function createRouteTreeFromModernRoutes(routes) {
     const rootModern = routes.find((r)=>r && 'nested' === r.type && r.isRoot);
-    const rootComponent = rootModern?.component;
+    const rootComponent = rootModern ? toModernRouteComponent(rootModern) : void 0;
     const pendingComponent = rootModern?.loading;
     const errorComponent = rootModern?.error;
     const rootLoader = rootModern?.loader;
@@ -352,7 +401,6 @@ function createRouteTreeFromModernRoutes(routes) {
         component: rootComponent || void 0,
         pendingComponent: pendingComponent || void 0,
         errorComponent: errorComponent || void 0,
-        wrapInSuspense: true,
         notFoundComponent: DefaultNotFound,
         staticData: createRouteStaticData({
             modernRouteId: rootModernId,
@@ -370,6 +418,7 @@ function createRouteTreeFromModernRoutes(routes) {
     if (rootShouldReload) rootRouteOptions.shouldReload = rootShouldReload;
     if (rootModern?.inValidSSRRoute) rootRouteOptions.ssr = false;
     const rootRoute = createTanstackRootRoute(rootRouteOptions);
+    if (rootComponent) rootRoute.options.component = withModernRouteMatchContext(rootComponent, rootRouteId);
     const topLevel = rootModern ? rootModern.children || [] : routes;
     const childRoutes = topLevel.map((child)=>createRouteFromModernRoute({
             parent: rootRoute,
@@ -386,11 +435,11 @@ function createRouteTreeFromRouteObjects(routes) {
     const rootRevalidationState = {};
     const rootShouldRevalidate = rootLikeRoute?.shouldRevalidate;
     const rootShouldReload = createModernShouldReload(rootShouldRevalidate, rootRevalidationState);
+    const rootComponent = rootLikeRoute ? toRouteComponent(rootLikeRoute) : void 0;
     const rootRouteOptions = {
-        component: rootLikeRoute ? toRouteComponent(rootLikeRoute) : void 0,
+        component: rootComponent,
         pendingComponent: rootLikeRoute ? toPendingComponent(rootLikeRoute) : void 0,
         errorComponent: rootLikeRoute ? toErrorComponent(rootLikeRoute) : void 0,
-        wrapInSuspense: true,
         notFoundComponent: DefaultNotFound,
         staticData: createRouteStaticData({
             modernRouteId: rootLikeRoute?.id,
@@ -408,6 +457,7 @@ function createRouteTreeFromRouteObjects(routes) {
     if (rootShouldReload) rootRouteOptions.shouldReload = rootShouldReload;
     if (rootLikeRoute?.inValidSSRRoute) rootRouteOptions.ssr = false;
     const rootRoute = createTanstackRootRoute(rootRouteOptions);
+    if (rootComponent) rootRoute.options.component = withModernRouteMatchContext(rootComponent, rootRouteId);
     const topLevel = rootLikeRoute ? [
         ...rootLikeRoute.children || [],
         ...routes.filter((route)=>route !== rootLikeRoute)
@@ -421,9 +471,11 @@ function createRouteTreeFromRouteObjects(routes) {
 }
 function getModernRouteIdsFromMatches(router) {
     const matches = router.state.matches || [];
+    const routesById = router.routesById;
     const ids = matches.map((match)=>{
-        const route = match.route;
-        return route?.options?.staticData?.modernRouteId;
+        const normalizedMatch = match;
+        const routeId = 'string' == typeof normalizedMatch.routeId ? normalizedMatch.routeId : void 0;
+        return normalizedMatch.route?.options?.staticData?.modernRouteId ?? (routeId ? routesById?.[routeId]?.options?.staticData?.modernRouteId : void 0);
     }).filter((id)=>'string' == typeof id);
     return Array.from(new Set(ids));
 }

package/dist/esm-node/rsc/server.worker.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export * from "@modern-js/render/rsc-worker";

package/dist/esm-node/ssr/serverRender/renderToString/entry.mjs

@@ -2,10 +2,10 @@ import "node:module";
 import { sanitizeSSRPayload, serializeJson } from "@modern-js/runtime-utils/node";
 import { time } from "@modern-js/runtime-utils/time";
 import react from "react";
-import react_helmet from "react-helmet";
+import { HelmetProvider } from "react-helmet-async";
+import { getHelmetData, helmetReplace } from "../../../core/server/helmet.mjs";
 import { serializeErrors } from "../../../router/runtime/utils.mjs";
 import prefetch from "../../prefetch";
-import helmet from "../helmet";
 import { SSRErrors, SSRTimings } from "../tracker";
 import { RenderLevel } from "../types.mjs";
 import { ROUTER_DATA_JSON_ID, SSR_DATA_JSON_ID, attributesToString } from "../utils";
@@ -61,8 +61,8 @@ class Entry {
             createReplaceSSRDataScript(ssrDataScripts),
             ...this.htmlModifiers
         ]);
-        const helmetData = react_helmet.renderStatic();
-        return helmetData ? helmet(html, helmetData) : html;
+        const helmetData = getHelmetData(context);
+        return helmetData ? helmetReplace(html, helmetData) : html;
     }
     async prefetch(context) {
         let prefetchData;
@@ -83,11 +83,14 @@ class Entry {
         const end = time();
         const { ssrContext } = context;
         try {
-            const App = react.createElement(this.App, {
+            const helmetContext = context._helmetContext ??= {};
+            const App = react.createElement(HelmetProvider, {
+                context: helmetContext
+            }, react.createElement(this.App, {
                 context: Object.assign(context, {
                     ssr: true
                 })
-            });
+            }));
             html = await createRender(App).addCollector(createStyledCollector(this.result)).addCollector(createLoadableCollector({
                 stats: ssrContext.loadableStats,
                 result: this.result,

package/dist/types/boundary-debugger/index.d.ts

@@ -0,0 +1,28 @@
+import type { RuntimePlugin } from '../core';
+export type BoundaryDebugEntry = {
+    appId: string;
+    color?: string;
+    label?: string;
+    mfName: string;
+    ownerTeam?: string;
+    packageName?: string;
+    role?: 'host' | 'vertical';
+};
+export type BoundaryDebugMetadata = {
+    appId: string;
+    boundaries: BoundaryDebugEntry[];
+    schemaVersion: 1;
+};
+export type BoundaryDebuggerControlMode = 'visible' | 'hidden-when-off' | 'hidden';
+export type BoundaryDebuggerPluginOptions = {
+    controlMode?: BoundaryDebuggerControlMode;
+    enabledByDefault?: boolean;
+    labels?: Record<string, {
+        toggle: string;
+    }>;
+    legacySelector?: string;
+    metadata: BoundaryDebugMetadata;
+    storageKey?: string;
+};
+export declare const ultramodernBoundaryDebuggerPlugin: (options: BoundaryDebuggerPluginOptions) => RuntimePlugin;
+export default ultramodernBoundaryDebuggerPlugin;

package/dist/types/cli/entry.d.ts

@@ -1,2 +1,2 @@
-export declare const hasApp: (dir: string) => any;
-export declare const isRuntimeEntry: (dir: string) => any;
+export declare const hasApp: (dir: string) => string | false;
+export declare const isRuntimeEntry: (dir: string) => string | false;

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

@@ -1,4 +1,7 @@
-export declare const getResponseProxy: () => any;
+export declare const getResponseProxy: () => {
+    headers: Record<string, string>;
+    status: number;
+} | undefined;
 export declare const setHeaders: (headers: Record<string, string>) => void;
 export declare const setStatus: (status: number) => void;
 export declare const redirect: (url: string, init?: number | ResponseInit) => void;

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

@@ -1,4 +1,5 @@
 import type { RouteObject, StaticHandlerContext } from '@modern-js/runtime-utils/router';
+import type { HelmetServerState } from 'react-helmet-async';
 import type { InternalRouterRuntimeState, InternalRouterServerSnapshot, RouteManifest, RouterFramework } from '../../router/runtime/types';
 import type { RequestContext, SSRServerContext } from '../types';
 export interface TRuntimeContext {
@@ -28,6 +29,9 @@ export interface TInternalRuntimeContext extends TRuntimeContext {
     ssrContext?: SSRServerContext;
     _internalContext?: any;
     _internalRouterBaseName?: any;
+    _helmetContext?: {
+        helmet?: HelmetServerState | null;
+    };
 }
 export declare const InternalRuntimeContext: import("react").Context<TInternalRuntimeContext>;
 export declare const RuntimeContext: import("react").Context<TRuntimeContext>;

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

@@ -2,4 +2,4 @@ import type { InternalRuntimeContext } from '@modern-js/plugin/runtime';
 import type { RuntimeConfig, RuntimeExtends, RuntimePlugin } from './types';
 export type { RuntimePlugin };
 export declare function registerPlugin(internalPlugins: RuntimePlugin[], runtimeConfig?: RuntimeConfig): InternalRuntimeContext<RuntimeExtends>;
-export declare function mergeConfig(config: Record<string, any>, ...otherConfig: Record<string, any>[]): any;
+export declare function mergeConfig(config: Record<string, any>, ...otherConfig: Record<string, any>[]): Record<string, any>;

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

@@ -0,0 +1,5 @@
+export declare const createFederatedCssLinks: (assets: string[] | undefined, options: {
+    template: string;
+    attributes?: Record<string, any>;
+    existingAssets?: Iterable<string>;
+}) => string;

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

@@ -1,3 +1,5 @@
-import type { HelmetData } from 'react-helmet';
-export declare function createReplaceHelemt(helmetData?: HelmetData): (template: string) => string;
-export declare function helmetReplace(content: string, helmetData: HelmetData): string;
+import type { HelmetServerState } from 'react-helmet-async';
+import type { TInternalRuntimeContext } from '../context';
+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;

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

@@ -0,0 +1 @@
+export declare function injectBeforeHydrationEntryScript(template: string, scripts: string, entryName?: string): string;

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

@@ -5,5 +5,6 @@ export interface BuildShellBeforeTemplateOptions {
     entryName: string;
     config: HandleRequestConfig;
     styledComponentsStyleTags?: string;
+    moduleFederationCssAssets?: string[];
 }
 export declare function buildShellBeforeTemplate(beforeAppTemplate: string, options: BuildShellBeforeTemplateOptions): Promise<string>;

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

@@ -0,0 +1,10 @@
+import type { TInternalRuntimeContext } from '../../context';
+import type { HandleRequestConfig } from '../requestHandler';
+export interface BuildShellBeforeTemplateOptions {
+    runtimeContext: TInternalRuntimeContext;
+    entryName: string;
+    config: HandleRequestConfig;
+    styledComponentsStyleTags?: string;
+    moduleFederationCssAssets?: string[];
+}
+export declare function buildShellBeforeTemplate(beforeAppTemplate: string, options: BuildShellBeforeTemplateOptions): Promise<string>;

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

@@ -4,15 +4,23 @@ import type React from 'react';
 import type { TRuntimeContext } from '../../context';
 import type { HandleRequestConfig } from '../requestHandler';
 import type { RenderStreaming, SSRConfig } from '../shared';
+export type RscManifest = {
+    clientManifest?: RscClientManifest;
+    serverConsumerModuleMap?: unknown;
+    serverManifest?: RscServerManifest;
+    entryCssFiles?: Record<string, string[]>;
+};
 export type CreateReadableStreamFromElementOptions = {
     runtimeContext: TRuntimeContext;
     config: HandleRequestConfig;
     ssrConfig: SSRConfig;
     htmlTemplate: string;
     entryName: string;
+    moduleFederationCssAssets?: string[];
     rscClientManifest?: RscClientManifest;
     rscSSRManifest?: RscSSRManifest;
     rscServerManifest?: RscServerManifest;
+    rscManifest?: RscManifest;
     rscRoot?: React.ReactElement;
     onShellReady?: () => void;
     onShellError?: (error: unknown) => void;

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

@@ -1,4 +1,6 @@
+import { type Chunk } from '@loadable/server';
 import type { ReactElement } from 'react';
+import type { TInternalRuntimeContext } from '../../context';
 import type { ChunkSet, Collector } from './types';
 declare module '@loadable/server' {
     interface ChunkExtractor {
@@ -6,12 +8,20 @@ declare module '@loadable/server' {
         getChunkAssets: (chunks: string[]) => Chunk[];
     }
 }
+export declare const orderHydrationScriptChunks: ({ asyncEntryChunks, collectedChunks, matchedRouteChunks, entryName, }: {
+    asyncEntryChunks: Chunk[];
+    collectedChunks: Chunk[];
+    matchedRouteChunks: Chunk[];
+    entryName: string;
+}) => Chunk[];
 export interface LoadableCollectorOptions {
     nonce?: string;
     stats?: Record<string, any>;
     routeManifest?: Record<string, any>;
+    runtimeContext: TInternalRuntimeContext;
     template: string;
     entryName: string;
+    moduleFederationCssAssets?: string[];
     chunkSet: ChunkSet;
     config: LoadableCollectorConfig;
 }
@@ -27,6 +37,7 @@ export declare class LoadableCollector implements Collector {
     private extractor?;
     constructor(options: LoadableCollectorOptions);
     private get existsAssets();
+    private getMatchedRouteChunks;
     collect(comopnent: ReactElement): ReactElement;
     effect(): Promise<void>;
     private emitLoadableScripts;

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

@@ -15,5 +15,15 @@ export declare function checkIsNode(): boolean;
  * license at https://github.com/remix-run/remix/blob/main/LICENSE.md
  */
 export declare function serializeErrors(errors: StaticHandlerContext['errors']): StaticHandlerContext['errors'];
-export declare function getSSRConfigByEntry(entryName: string, ssr?: ServerUserConfig['ssr'], ssrByEntries?: ServerUserConfig['ssrByEntries']): any;
+export declare function getSSRConfigByEntry(entryName: string, ssr?: ServerUserConfig['ssr'], ssrByEntries?: ServerUserConfig['ssrByEntries']): true | {
+    forceCSR?: boolean;
+    mode?: import("@modern-js/types").SSRMode;
+    preload?: boolean | {
+        [x: string]: unknown;
+    };
+    inlineScript?: boolean;
+    disablePrerender?: boolean;
+    unsafeHeaders?: string[];
+    moduleFederationAppSSR?: boolean;
+};
 export declare function getSSRMode(ssrConfig?: SSRConfig): 'string' | 'stream' | false;

package/dist/types/document/constants.d.ts

@@ -21,5 +21,7 @@ export declare const DOCUMENT_STYLE_PLACEHOLDER_END: string;
 export declare const DOCUMENT_COMMENT_PLACEHOLDER_START: string;
 export declare const DOCUMENT_COMMENT_PLACEHOLDER_END: string;
 export declare const PLACEHOLDER_REPLACER_MAP: {
-    [x: string]: string;
+    [DOCUMENT_SSR_PLACEHOLDER]: string;
+    [DOCUMENT_CHUNKSMAP_PLACEHOLDER]: string;
+    [DOCUMENT_SSRDATASCRIPT_PLACEHOLDER]: string;
 };

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

@@ -1,4 +1,11 @@
-import head from 'react-helmet';
+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> | null;
+declare const head: {
+    Helmet: (props: React.PropsWithChildren<HelmetProps>) => React.CElement<React.PropsWithChildren<HelmetProps>, AsyncHelmet> | null;
+    HelmetData: typeof AsyncHelmetData;
+    HelmetProvider: typeof HelmetProvider;
+};
 export default head;
-export type { HelmetData, HelmetDatum, HelmetHTMLBodyDatum, HelmetHTMLElementDatum, HelmetProps, HelmetPropsToState, HelmetTags, } from 'react-helmet';
-export { Helmet } from 'react-helmet';
+export type { HelmetDatum, HelmetHTMLBodyDatum, HelmetHTMLElementDatum, HelmetProps, HelmetServerState, HelmetTags, };
+export { AsyncHelmetData as HelmetData, HelmetProvider };

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

@@ -1,3 +1,10 @@
-import loadable from '@loadable/component';
+type LoadableDefault = typeof import('@loadable/component').default;
+type LoadableLazy = typeof import('@loadable/component').lazy;
+type LoadableReady = typeof import('@loadable/component').loadableReady;
+type LoadableInternals = unknown;
+declare const loadable: LoadableDefault;
+export declare const lazy: LoadableLazy;
+export declare const loadableReady: LoadableReady;
+export declare const __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: LoadableInternals;
 export default loadable;
 export * from '@loadable/component';

package/dist/types/exports/tanstack-router.d.ts

@@ -1,5 +1,7 @@
-export * from '@tanstack/react-router';
+export type * from '@tanstack/react-router';
+export { Asset, Await, Block, CatchBoundary, CatchNotFound, ClientOnly, cleanPath, composeRewrites, createBrowserHistory, createControlledPromise, createFileRoute, createHashHistory, createHistory, createLazyFileRoute, createLazyRoute, createLink, createMemoryHistory, createRootRoute, createRootRouteWithContext, createRoute, createRouteMask, createRouter, createRouterConfig, createSerializationAdapter, DEFAULT_PROTOCOL_ALLOWLIST, DefaultGlobalNotFound, deepEqual, defaultParseSearch, defaultStringifySearch, defer, ErrorComponent, FileRoute, FileRouteLoader, functionalUpdate, getRouteApi, HeadContent, interpolatePath, isMatch, isNotFound, isPlainArray, isPlainObject, isRedirect, joinPaths, LazyRoute, lazyFn, lazyRouteComponent, linkOptions, Match, Matches, MatchRoute, Navigate, NotFoundRoute, notFound, parseSearchWith, RootRoute, Route, RouteApi, Router, RouterContextProvider, RouterProvider, reactUse, redirect, replaceEqualDeep, resolvePath, retainSearchParams, rootRouteId, rootRouteWithContext, ScriptOnce, Scripts, ScrollRestoration, SearchParamError, stringifySearchWith, stripSearchParams, trimPath, trimPathLeft, trimPathRight, useAwaited, useBlocker, useCanGoBack, useChildMatches, useElementScrollRestoration, useHydrated, useLayoutEffect, useLinkProps, useLoaderData, useLoaderDeps, useLocation, useMatch, useMatches, useMatchRoute, useNavigate, useParams, useParentMatches, useRouteContext, useRouter, useRouterState, useSearch, useTags, } from '@tanstack/react-router';
 export type { Fetcher, FetcherState, FetcherSubmitOptions, FormProps, SubmitOptions, } from '../router/runtime/tanstack/dataMutation';
 export { Form, RouteActionResponseError, useFetcher, } from '../router/runtime/tanstack/dataMutation';
+export { Outlet } from '../router/runtime/tanstack/outlet';
 export type { LinkProps, NavLinkProps, PrefetchBehavior, } from '../router/runtime/tanstack/prefetchLink';
 export { Link, NavLink } from '../router/runtime/tanstack/prefetchLink';

package/dist/types/router/cli/code/utils.d.ts

@@ -1,6 +1,6 @@
 export declare const walkDirectory: (dir: string) => string[];
 export declare const isPageComponentFile: (filePath: string) => boolean;
-export declare const replaceWithAlias: (base: string, filePath: string, alias: string) => any;
+export declare const replaceWithAlias: (base: string, filePath: string, alias: string) => string;
 export declare const parseModule: ({ source, filename, }: {
     source: string;
     filename: string;

package/dist/types/router/cli/entry.d.ts

@@ -13,6 +13,6 @@ export declare const getEntrypointRoutesDir: (entrypoint: {
 export declare const getEntrypointRoutesOwner: (entrypoint: {
     [ROUTES_OWNER_META_KEY]?: string;
 }) => string | null;
-export declare const hasNestedRoutes: (dir: string, routesDir?: string) => any;
+export declare const hasNestedRoutes: (dir: string, routesDir?: string) => boolean;
 export declare const isRouteEntry: (dir: string, routesDir?: string) => string | false;
 export declare const modifyEntrypoints: (entrypoints: Entrypoint[], routesDir?: string, routesOwner?: string) => EntrypointWithRoutesMeta[];

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

@@ -13,14 +13,18 @@ import React from 'react';
  *
  * - "intent": Fetched when the user focuses or hovers the link
  * - "render": Fetched when the link is rendered
+ * - "viewport": Fetched when the link enters the viewport
  * - "none": Never fetched
  */
-type PrefetchBehavior = 'intent' | 'render' | 'none';
+type PrefetchBehavior = 'intent' | 'render' | 'viewport' | 'none';
+type PreloadBehavior = PrefetchBehavior | false;
 export interface LinkProps extends RouterLinkProps {
     prefetch?: PrefetchBehavior;
+    preload?: PreloadBehavior;
 }
 export interface NavLinkProps extends RouterNavLinkProps {
     prefetch?: PrefetchBehavior;
+    preload?: PreloadBehavior;
 }
 declare const Link: React.ForwardRefExoticComponent<LinkProps & React.RefAttributes<HTMLAnchorElement>>;
 declare const NavLink: React.ForwardRefExoticComponent<NavLinkProps & React.RefAttributes<HTMLAnchorElement>>;

package/dist/types/router/runtime/tanstack/hydrationBoundary.d.ts

@@ -0,0 +1,2 @@
+import { type ReactElement } from 'react';
+export declare function wrapTanstackSsrHydrationBoundary(routerContent: ReactElement, shouldWrap: boolean): import("react").JSX.Element;

package/dist/types/router/runtime/tanstack/outlet.d.ts

@@ -0,0 +1,2 @@
+export declare const Outlet: import("react").MemoExoticComponent<() => import("react").JSX.Element>;
+export declare function withModernRouteMatchContext(component: unknown, _routeId: string): unknown;

package/dist/types/rsc/server.worker.d.ts

@@ -0,0 +1 @@
+export * from '@modern-js/render/rsc-worker';