@bleedingdev/modern-js-runtime 3.8.3-ultramodern.1 → 3.8.3-ultramodern.3

package/dist/esm-node/exports/head.mjs

@@ -4,247 +4,18 @@ import react from "react";
 import { Helmet, HelmetData, HelmetProvider } from "react-helmet-async";
 import { InternalRuntimeContext } from "../core/context/index.mjs";
 import { ensureHelmetContext } from "../core/context/helmetContext.mjs";
-const ATTRIBUTE_NAME_MAP = {
-    charSet: 'charset',
-    className: 'class',
-    contentEditable: 'contenteditable',
-    httpEquiv: 'http-equiv',
-    hrefLang: 'hreflang',
-    itemProp: 'itemprop',
-    tabIndex: 'tabindex'
-};
-const CONTENT_PROPERTIES = new Set([
-    'innerHTML',
-    'cssText'
-]);
-const escapeHtml = (value)=>String(value).replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
-const toHtmlAttributeName = (name)=>ATTRIBUTE_NAME_MAP[name] ?? name;
-const attributesToString = (attributes, includeHelmetAttribute = false)=>{
-    const pairs = [];
-    if (includeHelmetAttribute) pairs.push('data-rh="true"');
-    for (const [name, value] of Object.entries(attributes ?? {})){
-        if (false === value || null == value) continue;
-        if (CONTENT_PROPERTIES.has(name)) continue;
-        const htmlName = toHtmlAttributeName(name);
-        if (true === value) pairs.push(htmlName);
-        else pairs.push(`${htmlName}="${escapeHtml(value)}"`);
-    }
-    return pairs.join(' ');
-};
-const createDatum = (tagName, tags)=>({
-        toComponent: ()=>[],
-        toString: ()=>tags.map((tag)=>{
-                const attrs = attributesToString(tag, true);
-                if ("script" === tagName && 'string' == typeof tag.innerHTML) return `<script ${attrs}>${tag.innerHTML}</script>`;
-                if ('style' === tagName && 'string' == typeof tag.cssText) return `<style ${attrs}>${tag.cssText}</style>`;
-                if ("noscript" === tagName && 'string' == typeof tag.innerHTML) return `<noscript ${attrs}>${tag.innerHTML}</noscript>`;
-                return `<${tagName} ${attrs}>`;
-            }).join('')
-    });
-const createAttributeDatum = (attributes)=>({
-        toComponent: ()=>attributes,
-        toString: ()=>attributesToString(attributes)
-    });
-const createTitleDatum = (title, attributes)=>({
-        toComponent: ()=>[],
-        toString: ()=>{
-            if (void 0 === title || '' === title) return '';
-            const attrs = attributesToString(attributes, true);
-            return `<title ${attrs}>${escapeHtml(title)}</title>`;
-        }
-    });
-const normalizeHelmetTitle = (title)=>{
-    if ('string' == typeof title) return title;
-    if (Array.isArray(title)) return title.map((part)=>String(part)).join('');
-};
-const mergeAttributes = (current, next)=>({
-        ...current,
-        ...next ?? {}
-    });
-const collectChildren = (children, draft)=>{
-    react.Children.forEach(children, (child)=>{
-        if (!react.isValidElement(child)) return;
-        if (child.type === react.Fragment) return void collectChildren(child.props.children, draft);
-        if ('string' != typeof child.type) return;
-        const { children: nestedChildren, ...props } = child.props;
-        if ('title' === child.type) {
-            draft.title = react.Children.toArray(nestedChildren).join('');
-            draft.titleAttributes = mergeAttributes(draft.titleAttributes, props);
-            return;
-        }
-        if ('html' === child.type) {
-            draft.htmlAttributes = mergeAttributes(draft.htmlAttributes ?? {}, props);
-            return;
-        }
-        if ('body' === child.type) {
-            draft.bodyAttributes = mergeAttributes(draft.bodyAttributes ?? {}, props);
-            return;
-        }
-        if ('base' === child.type || 'link' === child.type || 'meta' === child.type || "noscript" === child.type || "script" === child.type || 'style' === child.type) {
-            const tag = {
-                ...props
-            };
-            if (("script" === child.type || 'style' === child.type || "noscript" === child.type) && 'string' == typeof nestedChildren) tag['style' === child.type ? 'cssText' : 'innerHTML'] = nestedChildren;
-            draft[child.type].push(tag);
-        }
-    });
-};
-const createHelmetRecord = (props)=>{
-    const draft = {
-        base: [
-            ...void 0 !== props.base ? [
-                props.base
-            ] : []
-        ],
-        bodyAttributes: props.bodyAttributes,
-        htmlAttributes: props.htmlAttributes,
-        link: [
-            ...props.link ?? []
-        ],
-        meta: [
-            ...props.meta ?? []
-        ],
-        noscript: [
-            ...props.noscript ?? []
-        ],
-        script: [
-            ...props.script ?? []
-        ],
-        style: [
-            ...props.style ?? []
-        ],
-        title: normalizeHelmetTitle(props.title),
-        titleAttributes: props.titleAttributes ?? {}
-    };
-    collectChildren(props.children, draft);
-    return {
-        ...draft,
-        titleTemplate: props.titleTemplate,
-        defaultTitle: props.defaultTitle
-    };
-};
-const getInnermostDefined = (records, pick)=>{
-    for(let i = records.length - 1; i >= 0; i -= 1){
-        const value = pick(records[i]);
-        if (void 0 !== value) return value;
-    }
-};
-const deriveTitle = (records)=>{
-    const innermostTitle = getInnermostDefined(records, (record)=>record.title);
-    const innermostTemplate = getInnermostDefined(records, (record)=>record.titleTemplate);
-    if (innermostTemplate && innermostTitle) return innermostTemplate.replaceAll('%s', innermostTitle);
-    return innermostTitle || getInnermostDefined(records, (record)=>record.defaultTitle);
-};
-const mergeRecordAttributes = (records, pick)=>records.reduce((merged, record)=>mergeAttributes(merged, pick(record)), {});
-const deriveBaseTags = (records)=>{
-    for(let i = records.length - 1; i >= 0; i -= 1){
-        const tags = records[i].base;
-        for(let j = tags.length - 1; j >= 0; j -= 1)if (tags[j].href) return [
-            tags[j]
-        ];
-    }
-    return [];
-};
-const TAG_PRIMARY_ATTRIBUTES = {
-    link: [
-        'rel',
-        'href'
-    ],
-    meta: [
-        'name',
-        'charset',
-        'http-equiv',
-        'property',
-        'itemprop'
-    ],
-    noscript: [
-        'innerHTML'
-    ],
-    script: [
-        'src',
-        'innerHTML'
-    ],
-    style: [
-        'cssText'
-    ]
-};
-const getPrimaryAttribute = (tagName, tag)=>{
-    const candidates = TAG_PRIMARY_ATTRIBUTES[tagName];
-    let selectedKey;
-    let selectedValue;
-    for (const [key, value] of Object.entries(tag)){
-        const normalizedKey = CONTENT_PROPERTIES.has(key) ? key : toHtmlAttributeName(key).toLowerCase();
-        if (candidates.includes(normalizedKey)) {
-            if ('rel' !== selectedKey || 'canonical' !== String(selectedValue).toLowerCase()) {
-                if ('rel' !== normalizedKey || 'stylesheet' !== String(value).toLowerCase()) {
-                    selectedKey = normalizedKey;
-                    selectedValue = value;
-                }
-            }
-        }
-    }
-    if (void 0 === selectedKey || !selectedValue) return;
-    return {
-        key: selectedKey,
-        value: String(selectedValue).toLowerCase()
-    };
-};
-const dedupeTags = (tagName, records)=>{
-    const approvedValues = new Map();
-    const approved = [];
-    for(let i = records.length - 1; i >= 0; i -= 1){
-        const instanceValues = new Map();
-        const kept = [];
-        for (const tag of records[i][tagName]){
-            const primary = getPrimaryAttribute(tagName, tag);
-            if (void 0 === primary) continue;
-            if (approvedValues.get(primary.key)?.has(primary.value)) continue;
-            let seen = instanceValues.get(primary.key);
-            if (void 0 === seen) {
-                seen = new Set();
-                instanceValues.set(primary.key, seen);
-            }
-            seen.add(primary.value);
-            kept.push(tag);
-        }
-        approved.unshift(...kept);
-        for (const [key, values] of instanceValues){
-            const target = approvedValues.get(key);
-            if (void 0 === target) approvedValues.set(key, values);
-            else for (const value of values)target.add(value);
-        }
-    }
-    return approved;
-};
-const deriveHelmetServerState = (records)=>({
-        base: createDatum('base', deriveBaseTags(records)),
-        bodyAttributes: createAttributeDatum(mergeRecordAttributes(records, (record)=>record.bodyAttributes)),
-        htmlAttributes: createAttributeDatum(mergeRecordAttributes(records, (record)=>record.htmlAttributes)),
-        link: createDatum('link', dedupeTags('link', records)),
-        meta: createDatum('meta', dedupeTags('meta', records)),
-        noscript: createDatum("noscript", dedupeTags("noscript", records)),
-        priority: createDatum('meta', []),
-        script: createDatum("script", dedupeTags("script", records)),
-        style: createDatum('style', dedupeTags('style', records)),
-        title: createTitleDatum(deriveTitle(records), mergeRecordAttributes(records, (record)=>record.titleAttributes))
-    });
-const serverHelmetRecords = new WeakMap();
+import * as __rspack_external__modern_js_runtime_extensions_ce611631 from "@modern-js/runtime-extensions";
 const collectServerHelmet = (runtimeContext, props)=>{
     const helmetContext = ensureHelmetContext(runtimeContext);
-    let records = serverHelmetRecords.get(helmetContext);
-    if (void 0 === records) {
-        records = [];
-        serverHelmetRecords.set(helmetContext, records);
-    }
-    records.push(createHelmetRecord(props));
-    helmetContext.helmet = deriveHelmetServerState(records);
+    const createRecord = ()=>__rspack_external__modern_js_runtime_extensions_ce611631.createHelmetRecord(react, props);
+    const deriveState = (records)=>__rspack_external__modern_js_runtime_extensions_ce611631.deriveHelmetServerState(react, records);
+    const marker = __rspack_external__modern_js_runtime_extensions_ce611631.collectHeadState(runtimeContext, createRecord, deriveState, helmetContext);
+    if (void 0 !== marker) return marker;
+    helmetContext.helmet = __rspack_external__modern_js_runtime_extensions_ce611631.collectImmediateHelmetState(react, helmetContext, createRecord());
 };
 const head_Helmet = (props)=>{
     const runtimeContext = react.useContext(InternalRuntimeContext);
-    if (null !== runtimeContext && false === runtimeContext.isBrowser) {
-        collectServerHelmet(runtimeContext, props);
-        return null;
-    }
+    if (null !== runtimeContext && false === runtimeContext.isBrowser) return __rspack_external__modern_js_runtime_extensions_ce611631.renderHeadMarker(react, collectServerHelmet(runtimeContext, props));
     return react.createElement(Helmet, props);
 };
 const head = {
@@ -254,4 +25,4 @@ const head = {
 };
 const exports_head = head;
 export default exports_head;
-export { HelmetData, HelmetProvider, head_Helmet as Helmet };
+export { head_Helmet as Helmet };

package/dist/esm-node/module-federation/last-known-good.mjs

@@ -1,4 +1,5 @@
 import "node:module";
+import { selectResolvedSurface } from "@modern-js/utils/universal";
 import { createDiscoveryError, deliveryUnitResolutionKey } from "./surface-resolution-types.mjs";
 const LAST_KNOWN_GOOD_PROVIDER_NAME = 'last-known-good';
 function createInMemoryLkgStorage() {
@@ -32,16 +33,38 @@ function staleRecordResult(ref, env, ageMs, maxStaleMs) {
         })
     };
 }
+function resolutionAnswersRef(resolved, ref) {
+    const selected = selectResolvedSurface(resolved, ref);
+    return selected.ok && selected.surface.servedMajor === ref.major;
+}
 function createLastKnownGoodProvider(options) {
     const storage = options.storage ?? createInMemoryLkgStorage();
     const now = options.now ?? (()=>Math.floor(performance.timeOrigin + performance.now()));
     const maxStaleMs = options.freshness?.maxStaleMs;
+    let nextResolutionGeneration = 0;
+    const latestCacheableGenerationByKey = new Map();
+    const writeTailByKey = new Map();
+    async function cacheCompatibleResolution(key, generation, record) {
+        latestCacheableGenerationByKey.set(key, Math.max(latestCacheableGenerationByKey.get(key) ?? 0, generation));
+        const previous = writeTailByKey.get(key) ?? Promise.resolve();
+        const write = previous.catch(()=>void 0).then(async ()=>{
+            if (latestCacheableGenerationByKey.get(key) !== generation) return;
+            await storage.write(key, record);
+        });
+        writeTailByKey.set(key, write);
+        try {
+            await write;
+        } finally{
+            if (writeTailByKey.get(key) === write) writeTailByKey.delete(key);
+        }
+    }
     async function serveFromCache(ref, env, fallback) {
         const key = deliveryUnitResolutionKey(ref.unitId, env);
         const cached = await storage.read(key);
         if (!cached) return fallback();
         if (cached.major !== ref.major) return fallback();
-        if ('incompatible' === cached.resolved.compatibility.status) return fallback();
+        if (!resolutionAnswersRef(cached.resolved, ref)) return fallback();
+        if ('compatible' !== cached.resolved.compatibility.status) return fallback();
         const ageMs = now() - cached.storedAt;
         if (void 0 !== maxStaleMs && ageMs > maxStaleMs) return staleRecordResult(ref, env, ageMs, maxStaleMs);
         return {
@@ -53,6 +76,7 @@ function createLastKnownGoodProvider(options) {
         name: LAST_KNOWN_GOOD_PROVIDER_NAME,
         async resolve (ref, env) {
             const key = deliveryUnitResolutionKey(ref.unitId, env);
+            const generation = ++nextResolutionGeneration;
             let resolution;
             try {
                 resolution = await options.provider.resolve(ref, env);
@@ -69,7 +93,16 @@ function createLastKnownGoodProvider(options) {
                 const failure = resolution;
                 return serveFromCache(ref, env, ()=>failure);
             }
-            if ('incompatible' !== resolution.unit.compatibility.status) await storage.write(key, {
+            if (!resolutionAnswersRef(resolution.unit, ref)) return serveFromCache(ref, env, ()=>({
+                    ok: false,
+                    error: createDiscoveryError('identity-mismatch', ref, `Provider ${options.provider.name} returned a delivery unit that does not answer the requested surface.`, {
+                        env,
+                        provider: options.provider.name,
+                        recordUnitId: resolution.unit.unitId,
+                        availableSurfaces: resolution.unit.surfaces.map((surface)=>surface.surfaceId)
+                    })
+                }));
+            if ('compatible' === resolution.unit.compatibility.status) await cacheCompatibleResolution(key, generation, {
                 resolved: resolution.unit,
                 storedAt: now(),
                 major: ref.major

package/dist/esm-node/router/cli/nestedRoutesSpec.mjs

@@ -1,39 +1,12 @@
 import "node:module";
 import node_path from "node:path";
-import { setTimeout as promises_setTimeout } from "node:timers/promises";
 import { fs } from "@modern-js/utils";
 import { cloneDeep } from "@modern-js/utils/lodash";
-const lockPollIntervalMs = 25;
-const staleLockAgeMs = 120000;
 const pendingUpdates = new Map();
 let tempFileCounter = 0;
-async function acquireSpecLock(specPath) {
-    const lockDir = `${specPath}.lock`;
-    await fs.ensureDir(node_path.dirname(specPath));
-    while(true){
-        try {
-            await fs.mkdir(lockDir);
-            return async ()=>{
-                await fs.remove(lockDir);
-            };
-        } catch (error) {
-            if ('EEXIST' !== error.code) throw error;
-        }
-        try {
-            const stat = await fs.stat(lockDir);
-            if (performance.timeOrigin + performance.now() - stat.mtimeMs > staleLockAgeMs) {
-                await fs.remove(lockDir);
-                continue;
-            }
-        } catch (error) {
-            if ('ENOENT' !== error.code) throw error;
-            continue;
-        }
-        await promises_setTimeout(lockPollIntervalMs);
-    }
-}
 async function writeJSONAtomically(filePath, value) {
     const directory = node_path.dirname(filePath);
+    await fs.ensureDir(directory);
     const tempPath = node_path.join(directory, `.${node_path.basename(filePath)}.${process.pid}.${tempFileCounter += 1}.tmp`);
     try {
         await fs.writeFile(tempPath, `${JSON.stringify(value)}\n`);
@@ -48,16 +21,12 @@ async function updateNestedRoutesSpec(specPath, nextRoutes) {
     const nextRoutesSnapshot = cloneDeep(nextRoutes);
     const previousUpdate = pendingUpdates.get(resolvedSpecPath) ?? Promise.resolve();
     const currentUpdate = previousUpdate.catch(()=>void 0).then(async ()=>{
-        const releaseLock = await acquireSpecLock(resolvedSpecPath);
-        try {
-            const existingRoutes = await fs.pathExists(resolvedSpecPath) ? await fs.readJSON(resolvedSpecPath) : {};
-            await writeJSONAtomically(resolvedSpecPath, {
-                ...existingRoutes,
-                ...nextRoutesSnapshot
-            });
-        } finally{
-            await releaseLock();
-        }
+        const existingRoutes = await fs.pathExists(resolvedSpecPath) ? await fs.readJSON(resolvedSpecPath) : {};
+        const mergedRoutes = {
+            ...existingRoutes,
+            ...nextRoutesSnapshot
+        };
+        await writeJSONAtomically(resolvedSpecPath, mergedRoutes);
     });
     pendingUpdates.set(resolvedSpecPath, currentUpdate);
     try {

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

@@ -1,9 +1,19 @@
 import "node:module";
 "use client";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { getNavigationWarmupCacheKey } from "@modern-js/runtime-extensions";
 import { Link as router_Link, NavLink, matchRoutes, useHref, useMatches, useResolvedPath } from "@modern-js/runtime-utils/router";
 import react, { useContext, useMemo } from "react";
 import { InternalRuntimeContext } from "../../core/context/index.mjs";
+import { __webpack_require__ } from "../../rslib-runtime.mjs";
+const getWebpackChunkLoader = ()=>__webpack_chunk_load__;
+const getWebpackPublicPath = ()=>{
+    try {
+        return __webpack_require__.p || '';
+    } catch  {
+        return '';
+    }
+};
 function composeEventHandlers(theirHandler, ourHandler) {
     return (event)=>{
         theirHandler?.(event);
@@ -42,8 +52,7 @@ const runNextWarmup = ()=>{
         const task = warmupQueue.shift();
         if (task.cancelled) continue;
         activeWarmups += 1;
-        task.run().catch((error)=>{
-            console.error(error);
+        task.run().catch(()=>{
             warmupCache.delete(task.key);
         }).finally(()=>{
             activeWarmups -= 1;
@@ -65,6 +74,7 @@ const scheduleWarmup = (key, run)=>{
     runNextWarmup();
     return ()=>{
         task.cancelled = true;
+        if (warmupQueue.includes(task)) warmupCache.delete(task.key);
     };
 };
 const setRef = (ref, value)=>{
@@ -148,16 +158,17 @@ function usePrefetchBehavior(prefetch, preload, theirElementProps) {
         setViewportElement
     ];
 }
-async function loadRouteModule(route, routeAssets) {
+async function loadRouteModule(route, routeAssets, chunkLoader) {
     const routeId = route.id;
     if (!routeId) return;
     if (!routeAssets[routeId]) return;
     const { chunkIds } = routeAssets[routeId];
     if (!chunkIds) return;
     try {
-        await Promise.all(chunkIds.map((chunkId)=>__webpack_chunk_load__?.(chunkId)));
+        await Promise.all(chunkIds.map((chunkId)=>chunkLoader(chunkId)));
     } catch (error) {
         console.error(error);
+        throw error;
     }
 }
 const getRequestUrl = (pathname, routeId)=>{
@@ -190,22 +201,31 @@ const PrefetchPageLinks = ({ path, includeData })=>{
         pathname,
         routes
     ]);
+    const chunkLoader = getWebpackChunkLoader();
+    const routeAssetGeneration = JSON.stringify([
+        getWebpackPublicPath(),
+        matches?.map(({ route: { id } })=>[
+                id,
+                routeAssets?.[id]?.chunkIds
+            ])
+    ]);
     react.useEffect(()=>{
-        if (!allowNetworkWarmup || !Array.isArray(matches) || !routeAssets || !__webpack_chunk_load__) return;
+        if (!allowNetworkWarmup || !Array.isArray(matches) || !routeAssets || !chunkLoader) return;
         const cancellations = matches.map((match)=>{
             const routeId = match.route.id;
             const routeAsset = routeId ? routeAssets[routeId] : void 0;
             const chunkIds = routeAsset?.chunkIds;
             if (!routeId || !Array.isArray(chunkIds) || 0 === chunkIds.length) return ()=>{};
-            return scheduleWarmup(`route-module:${routeId}:${chunkIds.join(',')}`, ()=>loadRouteModule(match.route, routeAssets));
+            return scheduleWarmup(getNavigationWarmupCacheKey(context, chunkLoader, getWebpackPublicPath(), `route-module:${routeId}:${chunkIds.join(',')}`), ()=>loadRouteModule(match.route, routeAssets, chunkLoader));
         });
         return ()=>{
             cancellations.forEach((cancel)=>cancel());
         };
     }, [
         allowNetworkWarmup,
-        matches,
-        routeAssets
+        chunkLoader,
+        context,
+        routeAssetGeneration
     ]);
     if (!allowNetworkWarmup || !includeData || !window._SSR_DATA) return null;
     return /*#__PURE__*/ jsx(PrefetchDataLinks, {

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

@@ -2,7 +2,17 @@ import "node:module";
 const handleRSCRedirect = (headers, basename, status)=>{
     const newHeaders = new Headers(headers);
     let redirectUrl = headers.get('Location');
-    if ('/' !== basename) redirectUrl = redirectUrl.replace(basename, '');
+    if (!redirectUrl || ![
+        301,
+        302,
+        303,
+        307,
+        308
+    ].includes(status) || !URL.canParse(redirectUrl, 'http://localhost')) return new Response(null, {
+        status,
+        headers: newHeaders
+    });
+    if ('/' !== basename && redirectUrl.startsWith(basename)) redirectUrl = redirectUrl.slice(basename.length) || '/';
     newHeaders.set('X-Modernjs-Redirect', redirectUrl);
     newHeaders.set('X-Modernjs-BaseUrl', basename);
     newHeaders.delete('Location');

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

@@ -177,12 +177,14 @@ function serializeRouteErrorResponse(error) {
         status: error.status,
         statusText: 'Internal Server Error',
         data: 'Unexpected Server Error',
+        internal: error.internal,
         __type: 'RouteErrorResponse'
     };
     return {
         status: error.status,
         statusText: error.statusText,
         data: error.data,
+        internal: error.internal,
         __type: 'RouteErrorResponse'
     };
 }

package/dist/esm-node/rslib-runtime.mjs

@@ -0,0 +1,10 @@
+import "node:module";
+var __webpack_require__ = {};
+(()=>{
+    var scriptUrl;
+    if ("string" == typeof import.meta.url) scriptUrl = import.meta.url;
+    if (!scriptUrl) throw new Error("Automatic publicPath is not supported in this browser");
+    scriptUrl = scriptUrl.replace(/^blob:/, "").replace(/#.*$/, "").replace(/\?.*$/, "").replace(/\/[^\/]+$/, "/");
+    __webpack_require__.p = scriptUrl;
+})();
+export { __webpack_require__ };

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

@@ -22,10 +22,8 @@ export interface RuntimeContextExtension<T> {
 /**
  * Removes the extension slot from a context object.
  *
- * The slot is an enumerable symbol-keyed property, so object spreads copy it
- * onto derived objects. Call this on *copies* that form the public
- * `RuntimeContext` value to keep internal state (router instances, helmet
- * state, ...) unreachable from the public context object.
+ * The symbol slot crosses object spreads while remaining absent from string-key
+ * enumeration and JSON. Callers can still explicitly clear the original context.
  */
 export declare function stripRuntimeContextExtensions(context: object): void;
 /**

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

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

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

@@ -12,4 +12,4 @@ export type RedirectContext = {
 };
 export declare const applyRouterSnapshotResult: (context: TInternalRuntimeContext, onError: OnError) => void;
 export declare const createLoaderRedirectResponse: (beforeRenderResult: Response | undefined, redirectCtx: RedirectContext) => Response | undefined;
-export declare const finalizeRenderResponse: (response: Response, responseProxy: ResponseProxy, redirectCtx: RedirectContext, routerCleanup: RouterCleanup) => Response;
+export declare const finalizeRenderResponse: (response: Response, responseProxy: ResponseProxy, redirectCtx: RedirectContext, routerCleanup: RouterCleanup) => Promise<Response>;

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

@@ -23,6 +23,8 @@ export type RouterCleanup = {
      * returned as-is and the caller is expected to invoke `run()` itself.
      */
     deferUntilBodyDone: (response: Response) => Response;
+    /** Cancels a discarded body before running router cleanup. */
+    discardBody: (response: Response) => Promise<void>;
 };
 export declare function runWithRouterCleanupOnError<T>(routerCleanup: RouterCleanup, callback: () => Promise<T> | T): Promise<T>;
 export declare function finishWithRouterCleanup<T>(routerCleanup: RouterCleanup, callback: () => Promise<T> | T): Promise<T>;

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

@@ -29,6 +29,7 @@ export declare class LoadableCollector implements Collector {
     private options;
     private extractor?;
     constructor(options: LoadableCollectorOptions);
+    private get existsAssets();
     collect(comopnent: ReactElement): ReactElement;
     effect(): Promise<void>;
     private emitLoadableScripts;

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

@@ -15,6 +15,7 @@ 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 shouldRedactServerError(): boolean;
 export declare function getSSRConfigByEntry(entryName: string, ssr?: ServerUserConfig['ssr'], ssrByEntries?: ServerUserConfig['ssrByEntries']): true | {
     forceCSR?: boolean;
     mode?: import("@modern-js/types").SSRMode;

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> | null;
+export declare const Helmet: (props: React.PropsWithChildren<HelmetProps>) => React.CElement<React.PropsWithChildren<HelmetProps>, AsyncHelmet> | React.ReactElement<{}, string | React.JSXElementConstructor<any>> | null;
 declare const head: {
     Helmet: typeof Helmet;
     HelmetData: typeof AsyncHelmetData;
@@ -8,4 +8,3 @@ declare const head: {
 };
 export default head;
 export type { HelmetDatum, HelmetHTMLBodyDatum, HelmetHTMLElementDatum, HelmetProps, HelmetServerState, HelmetTags, };
-export { AsyncHelmetData as HelmetData, HelmetProvider };

package/dist/types/module-federation/last-known-good.d.ts

@@ -1,23 +1,3 @@
-/**
- * G24a/b — last-known-good (LKG) provider wrapper.
- *
- * RESOLUTION-0001 §2.2: the LKG cache "wraps any provider; serves the last
- * complete record on provider failure, marked `compatibility: 'degraded'`". It
- * is universal — no DOM/fetch/framework coupling — so the same wrapper works in
- * the browser, Node, and Cloudflare.
- *
- * Rollback semantics (ADR-0019 / CONTEXT.md Rollback): the delivery UNIT is
- * the unit of rollback. The cache stores exactly ONE whole
- * {@link ResolvedDeliveryUnit} per (unitId, env) key — never per (ref, env) —
- * so every surface of a unit shares one snapshot and a fresh success swaps that
- * snapshot atomically for all of them (two surfaces can never be served from
- * different cached build markers). It never stores or serves a partial record,
- * and it never mixes locations across build markers — a served degraded record
- * is a byte-for-byte prior success with only its compatibility verdict flipped
- * to `degraded`. An `incompatible` record is never good: it is neither cached
- * as the last-known-good snapshot nor ever served. The ref's external-major
- * participates in lookup validation but not in the storage key.
- */
 import { type ResolvedDeliveryUnit, type SurfaceResolutionProvider } from './surface-resolution-types';
 export declare const LAST_KNOWN_GOOD_PROVIDER_NAME = "last-known-good";
 /** One cached complete record plus the time it was stored. */