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

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

@@ -5,11 +5,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;
@@ -37,13 +38,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, '"');
 }
@@ -189,7 +183,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);
@@ -227,12 +220,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/router/runtime/tanstack/prefetchLink.mjs

@@ -4,7 +4,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/router/runtime/tanstack/routeTree.mjs

@@ -1,11 +1,17 @@
-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;
@@ -43,6 +49,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 {
@@ -111,7 +151,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({
@@ -174,7 +214,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({
@@ -209,10 +249,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;
@@ -250,12 +298,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,
@@ -274,6 +322,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({
@@ -292,7 +341,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;
@@ -304,7 +353,6 @@ function createRouteFromModernRoute(opts) {
         component: component || void 0,
         pendingComponent: pendingComponent || void 0,
         errorComponent: errorComponent || void 0,
-        wrapInSuspense: true,
         staticData: createRouteStaticData({
             modernRouteId: modernId,
             modernRouteAction: modernAction,
@@ -326,6 +374,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({
@@ -338,7 +387,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;
@@ -351,7 +400,6 @@ function createRouteTreeFromModernRoutes(routes) {
         component: rootComponent || void 0,
         pendingComponent: pendingComponent || void 0,
         errorComponent: errorComponent || void 0,
-        wrapInSuspense: true,
         notFoundComponent: DefaultNotFound,
         staticData: createRouteStaticData({
             modernRouteId: rootModernId,
@@ -369,6 +417,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,
@@ -385,11 +434,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,
@@ -407,6 +456,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)
@@ -420,9 +470,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/rsc/server.worker.mjs

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

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

@@ -1,10 +1,10 @@
 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";
@@ -60,8 +60,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;
@@ -82,11 +82,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/esm-node/boundary-debugger/index.mjs

@@ -0,0 +1,264 @@
+import "node:module";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from "react";
+const defaultStorageKey = 'modernjs:boundary-debugger:enabled';
+const queryParamName = 'modern-boundaries';
+const boundarySelector = '[data-modern-boundary-id]';
+const defaultLabels = {
+    cs: {
+        toggle: 'zobrazit hranice týmů'
+    },
+    en: {
+        toggle: 'show team boundaries'
+    }
+};
+const palette = [
+    '#ff5a5f',
+    '#30e27a',
+    '#f6cf45',
+    '#7c8cff',
+    '#29b6f6'
+];
+const readStoredEnabled = (storageKey, fallback)=>{
+    if ("u" < typeof window) return fallback;
+    try {
+        const stored = window.localStorage.getItem(storageKey);
+        return null === stored ? fallback : 'true' === stored;
+    } catch  {
+        return fallback;
+    }
+};
+const writeStoredEnabled = (storageKey, enabled)=>{
+    if ("u" < typeof window) return;
+    try {
+        window.localStorage.setItem(storageKey, String(enabled));
+    } catch  {}
+};
+const parseEnabledOverride = (value)=>{
+    if (null === value) return;
+    const normalized = value.toLowerCase();
+    if ('1' === normalized || 'true' === normalized) return true;
+    if ('0' === normalized || 'false' === normalized) return false;
+};
+const readQueryEnabledOverride = ()=>{
+    if ("u" < typeof window) return;
+    try {
+        return parseEnabledOverride(new URLSearchParams(window.location.search).get(queryParamName));
+    } catch  {
+        return;
+    }
+};
+const detectLanguage = ()=>{
+    if ("u" < typeof document) return 'en';
+    const htmlLanguage = document.documentElement.lang;
+    if ('' !== htmlLanguage) return htmlLanguage.split('-')[0] || 'en';
+    if ("u" < typeof window) return 'en';
+    return window.location.pathname.split('/').filter(Boolean)[0] || 'en';
+};
+const hashBoundaryId = (id)=>{
+    let hash = 0;
+    for(let index = 0; index < id.length; index++)hash = 31 * hash + id.charCodeAt(index) >>> 0;
+    return hash;
+};
+const formatRectKey = (rect)=>[
+        Math.round(100 * rect.left) / 100,
+        Math.round(100 * rect.top) / 100,
+        Math.round(100 * rect.width) / 100,
+        Math.round(100 * rect.height) / 100
+    ].join(':');
+const getBoundaryId = (element)=>element.dataset.modernBoundaryId ?? element.dataset.mfRemote ?? element.getAttribute('data-mf-remote') ?? void 0;
+const collectBoundaryElements = (legacySelector)=>{
+    const elements = new Set();
+    for (const element of document.querySelectorAll(boundarySelector))elements.add(element);
+    if (void 0 === legacySelector || '' === legacySelector) return Array.from(elements);
+    try {
+        for (const element of document.querySelectorAll(legacySelector))elements.add(element);
+    } catch  {}
+    return Array.from(elements);
+};
+function BoundaryDebugger({ controlMode = 'visible', enabledByDefault = false, labels = defaultLabels, legacySelector, metadata, storageKey = defaultStorageKey }) {
+    const [mounted, setMounted] = useState(false);
+    const [enabled, setEnabled] = useState(false);
+    const [boxes, setBoxes] = useState([]);
+    const boundaries = useMemo(()=>new Map(metadata.boundaries.map((entry, index)=>[
+                entry.mfName,
+                {
+                    ...entry,
+                    color: entry.color ?? palette[index % palette.length],
+                    label: entry.label ?? entry.appId
+                }
+            ])), [
+        metadata
+    ]);
+    const language = mounted ? detectLanguage() : 'en';
+    const toggleLabel = labels[language]?.toggle ?? labels.en?.toggle ?? defaultLabels.en?.toggle ?? 'show team boundaries';
+    useEffect(()=>{
+        setMounted(true);
+        const queryOverride = readQueryEnabledOverride();
+        setEnabled(queryOverride ?? readStoredEnabled(storageKey, enabledByDefault));
+    }, [
+        enabledByDefault,
+        storageKey
+    ]);
+    useEffect(()=>{
+        if (!mounted) return;
+        writeStoredEnabled(storageKey, enabled);
+    }, [
+        enabled,
+        mounted,
+        storageKey
+    ]);
+    useEffect(()=>{
+        if (!enabled) return void setBoxes([]);
+        const readBoxes = ()=>{
+            const seenBoxes = new Set();
+            const nextBoxes = collectBoundaryElements(legacySelector).map((element)=>{
+                const boundaryId = getBoundaryId(element);
+                if (void 0 === boundaryId || '' === boundaryId) return;
+                const rect = element.getBoundingClientRect();
+                if (rect.width <= 0 || rect.height <= 0) return;
+                const rectKey = formatRectKey(rect);
+                const boxKey = `${boundaryId}:${rectKey}`;
+                if (seenBoxes.has(boxKey)) return;
+                seenBoxes.add(boxKey);
+                const boundary = boundaries.get(boundaryId);
+                const color = boundary?.color ?? palette[hashBoundaryId(boundaryId) % palette.length];
+                const label = boundary?.label ?? boundary?.appId ?? boundaryId;
+                const expose = element.dataset.modernMfExpose;
+                const detail = void 0 !== expose && '' !== expose && expose !== label && expose !== boundaryId ? expose : void 0;
+                const box = {
+                    color,
+                    height: rect.height,
+                    id: boxKey,
+                    label,
+                    left: rect.left,
+                    top: rect.top,
+                    width: rect.width
+                };
+                if (void 0 !== detail) box.detail = detail;
+                return box;
+            }).filter((box)=>void 0 !== box);
+            setBoxes(nextBoxes);
+        };
+        readBoxes();
+        const resizeObserver = "u" < typeof ResizeObserver ? void 0 : new ResizeObserver(readBoxes);
+        for (const element of collectBoundaryElements(legacySelector))resizeObserver?.observe(element);
+        const mutationObserver = new MutationObserver(readBoxes);
+        mutationObserver.observe(document.body, {
+            childList: true,
+            subtree: true
+        });
+        window.addEventListener('resize', readBoxes);
+        window.addEventListener('scroll', readBoxes, true);
+        return ()=>{
+            mutationObserver.disconnect();
+            resizeObserver?.disconnect();
+            window.removeEventListener('resize', readBoxes);
+            window.removeEventListener('scroll', readBoxes, true);
+        };
+    }, [
+        boundaries,
+        enabled,
+        legacySelector
+    ]);
+    if (!mounted) return null;
+    const shouldRenderToggle = 'visible' === controlMode || 'hidden-when-off' === controlMode && enabled;
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            shouldRenderToggle ? /*#__PURE__*/ jsxs("label", {
+                style: {
+                    alignItems: 'center',
+                    background: 'rgba(255, 255, 255, 0.96)',
+                    border: '1px solid rgba(0, 0, 0, 0.1)',
+                    borderRadius: 10,
+                    boxShadow: '0 10px 28px rgba(0, 0, 0, 0.14)',
+                    color: '#111827',
+                    display: 'flex',
+                    font: '600 13px/1.2 system-ui, sans-serif',
+                    gap: 8,
+                    left: 'max(12px, env(safe-area-inset-left))',
+                    maxWidth: 'calc(100vw - 24px)',
+                    padding: '9px 11px',
+                    position: 'fixed',
+                    top: 'max(12px, env(safe-area-inset-top))',
+                    zIndex: 2147483000
+                },
+                children: [
+                    /*#__PURE__*/ jsx("input", {
+                        checked: enabled,
+                        onChange: (event)=>setEnabled(event.currentTarget.checked),
+                        type: "checkbox"
+                    }),
+                    /*#__PURE__*/ jsx("span", {
+                        children: toggleLabel
+                    })
+                ]
+            }) : null,
+            enabled ? /*#__PURE__*/ jsx("div", {
+                "aria-hidden": "true",
+                children: boxes.map((box)=>/*#__PURE__*/ jsx("div", {
+                        style: {
+                            border: `2px solid ${box.color}`,
+                            borderRadius: 8,
+                            boxShadow: `0 0 0 1px rgba(255,255,255,.72), 0 6px 20px color-mix(in srgb, ${box.color} 20%, transparent)`,
+                            height: box.height,
+                            left: box.left,
+                            pointerEvents: 'none',
+                            position: 'fixed',
+                            top: box.top,
+                            width: box.width,
+                            zIndex: 2147482999
+                        },
+                        children: /*#__PURE__*/ jsxs("span", {
+                            style: {
+                                background: box.color,
+                                borderRadius: 999,
+                                color: '#111827',
+                                display: 'grid',
+                                font: '800 11px/1.1 system-ui, sans-serif',
+                                gap: 3,
+                                maxWidth: 'min(280px, calc(100vw - 24px))',
+                                padding: '5px 8px',
+                                position: 'absolute',
+                                right: 4,
+                                top: 4,
+                                whiteSpace: 'nowrap'
+                            },
+                            children: [
+                                /*#__PURE__*/ jsx("span", {
+                                    children: box.label
+                                }),
+                                void 0 !== box.detail && '' !== box.detail ? /*#__PURE__*/ jsx("span", {
+                                    style: {
+                                        font: '700 10px/1.1 system-ui, sans-serif',
+                                        opacity: 0.82,
+                                        overflow: 'hidden',
+                                        textOverflow: 'ellipsis'
+                                    },
+                                    children: box.detail
+                                }) : null
+                            ]
+                        })
+                    }, box.id))
+            }) : null
+        ]
+    });
+}
+const ultramodernBoundaryDebuggerPlugin = (options)=>({
+        name: '@modern-js/runtime/boundary-debugger',
+        setup: (api)=>{
+            api.wrapRoot((App)=>(props)=>/*#__PURE__*/ jsxs(Fragment, {
+                        children: [
+                            /*#__PURE__*/ jsx(App, {
+                                ...props
+                            }),
+                            /*#__PURE__*/ jsx(BoundaryDebugger, {
+                                ...options
+                            })
+                        ]
+                    }));
+        }
+    });
+const boundary_debugger = ultramodernBoundaryDebuggerPlugin;
+export default boundary_debugger;
+export { ultramodernBoundaryDebuggerPlugin };

package/dist/esm-node/cli/ssr/index.mjs

@@ -86,30 +86,20 @@ const ssrBuilderPlugin = (modernAPI, outputModule, exportLoadablePath)=>({
                 const hasServerRendering = hasServerRenderingConfig(userConfig);
                 const hasModuleFederationRuntimeMarker = hasServerRendering && shouldUseModuleFederationNodeOutput(config);
                 const hasExplicitMfSsrFlag = isModuleFederationAppSSREnabled(userConfig);
+                const isCloudflareWorkerSSR = 'workerSSR' === name && userConfig.deploy?.target === 'cloudflare';
                 const requireExplicitMfSsrFlag = 'true' === process.env.MODERN_MF_APP_SSR_REQUIRE_EXPLICIT;
                 if (hasServerRendering && hasModuleFederationRuntimeMarker && !hasExplicitMfSsrFlag) {
                     const warningMessage = '[modernjs][mf-ssr] Module Federation SSR was auto-detected from runtime markers. Set server.ssr.moduleFederationAppSSR=true explicitly in host and remotes to avoid heuristic drift.';
                     if (requireExplicitMfSsrFlag) throw new Error(`${warningMessage} (enforced by MODERN_MF_APP_SSR_REQUIRE_EXPLICIT=true)`);
                     console.warn(warningMessage);
                 }
-                const isModuleFederationAppSSR = hasServerRendering && hasExplicitMfSsrFlag;
-                const useModuleFederationNodeOutput = hasServerRendering && isModuleFederationAppSSR && isNodeEnvironmentTarget(config.output.target);
+                const isModuleFederationAppSSR = hasServerRendering && hasExplicitMfSsrFlag && !isCloudflareWorkerSSR;
                 const ssrEnv = userConfig.deploy?.worker?.ssr || userConfig.server?.rsc ? 'edge' : 'node';
                 const appContext = modernAPI.getAppContext();
                 const { appDirectory, entrypoints } = appContext;
-                const serverBundlerChain = useModuleFederationNodeOutput ? (chain)=>{
-                    chain.target('async-node');
-                    chain.output.module(false);
-                    chain.output.chunkFormat('commonjs');
-                    chain.output.chunkLoading('async-node');
-                    chain.output.library({
-                        ...chain.output.get('library') || {},
-                        type: 'commonjs-module'
-                    });
-                } : void 0;
                 const useLoadablePlugin = isUseSSRBundle(userConfig) && !isServerEnvironment && checkUseStringSSR(userConfig, appDirectory, entrypoints);
                 const outputConfig = {
-                    module: isServerEnvironment && !useModuleFederationNodeOutput && outputModule
+                    module: isServerEnvironment && (outputModule || 'workerSSR' === name && userConfig.deploy?.target === 'cloudflare')
                 };
                 const useLoadableComponents = isUseSSRBundle(userConfig) && checkUseStringSSR(userConfig, appDirectory, entrypoints);
                 return mergeEnvironmentConfig(config, {
@@ -122,13 +112,13 @@ const ssrBuilderPlugin = (modernAPI, outputModule, exportLoadablePath)=>({
                     },
                     output: outputConfig,
                     tools: {
-                        bundlerChain: serverBundlerChain || (useLoadablePlugin ? (chain)=>{
+                        bundlerChain: useLoadablePlugin ? (chain)=>{
                             chain.plugin('loadable').use(loadable_bundler_plugin, [
                                 {
                                     filename: LOADABLE_STATS_FILE
                                 }
                             ]);
-                        } : void 0),
+                        } : void 0,
                         swc: useLoadableComponents ? {
                             jsc: {
                                 experimental: {

package/dist/esm-node/cli/template.server.mjs

@@ -36,6 +36,7 @@ const handleRequest = async (request, ServerRoot, options) => {
     </ServerRoot>,
     {
       ...options,
+      rscManifest: __rspack_rsc_manifest__,
       rscRoot: options.rscRoot,
     },
   );

package/dist/esm-node/core/react/wrapper.mjs

@@ -1,8 +1,11 @@
 import "node:module";
 import { jsx } from "react/jsx-runtime";
+import { HelmetProvider } from "react-helmet-async";
 import { InternalRuntimeContext, RuntimeContext } from "../context/index.mjs";
 function wrapRuntimeContextProvider(App, contextValue) {
-    const { isBrowser, initialData, routes, routerFramework, context, routeManifest, routerRuntime, routerInstance, routerHydrationScript, routerMatchedRouteIds, routerServerSnapshot, routerContext, unstable_getBlockNavState, ssrContext, _internalContext, _internalRouterBaseName, ...rest } = contextValue;
+    const { isBrowser, initialData, routes, routerFramework, context, routeManifest, routerRuntime, routerInstance, routerHydrationScript, routerMatchedRouteIds, routerServerSnapshot, routerContext, unstable_getBlockNavState, ssrContext, _internalContext, _internalRouterBaseName, _helmetContext, ...rest } = contextValue;
+    const internalContextValue = contextValue;
+    internalContextValue._helmetContext ??= {};
     const runtimeContextValue = {
         isBrowser,
         initialData,
@@ -12,10 +15,13 @@ function wrapRuntimeContextProvider(App, contextValue) {
         ...rest
     };
     return /*#__PURE__*/ jsx(InternalRuntimeContext.Provider, {
-        value: contextValue,
+        value: internalContextValue,
         children: /*#__PURE__*/ jsx(RuntimeContext.Provider, {
             value: runtimeContextValue,
-            children: App
+            children: /*#__PURE__*/ jsx(HelmetProvider, {
+                context: internalContextValue._helmetContext,
+                children: App
+            })
         })
     });
 }