@bleedingdev/modern-js-runtime 3.2.0-ultramodern.99 → 3.4.0-ultramodern.1

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

@@ -3,14 +3,20 @@ import "node:module";
 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)=>{
@@ -18,6 +24,7 @@ const attributesToString = (attributes, includeHelmetAttribute = false)=>{
     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)}"`);
@@ -41,23 +48,15 @@ const createAttributeDatum = (attributes)=>({
 const createTitleDatum = (title, attributes)=>({
         toComponent: ()=>[],
         toString: ()=>{
-            if (!title) return '';
+            if (void 0 === title || '' === title) return '';
             const attrs = attributesToString(attributes, true);
             return `<title ${attrs}>${escapeHtml(title)}</title>`;
         }
     });
-const createEmptyHelmetState = ()=>({
-        base: createDatum('base', []),
-        bodyAttributes: createAttributeDatum({}),
-        htmlAttributes: createAttributeDatum({}),
-        link: createDatum('link', []),
-        meta: createDatum('meta', []),
-        noscript: createDatum("noscript", []),
-        priority: createDatum('meta', []),
-        script: createDatum("script", []),
-        style: createDatum('style', []),
-        title: createTitleDatum(void 0, {})
-    });
+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 ?? {}
@@ -73,7 +72,14 @@ const collectChildren = (children, draft)=>{
             draft.titleAttributes = mergeAttributes(draft.titleAttributes, props);
             return;
         }
-        if ('html' === child.type || 'body' === child.type) 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
@@ -83,11 +89,10 @@ const collectChildren = (children, draft)=>{
         }
     });
 };
-const collectHelmetProps = (current, props)=>{
-    const baseState = current ?? createEmptyHelmetState();
+const createHelmetRecord = (props)=>{
     const draft = {
         base: [
-            ...props.base ? [
+            ...void 0 !== props.base ? [
                 props.base
             ] : []
         ],
@@ -108,75 +113,136 @@ const collectHelmetProps = (current, props)=>{
         style: [
             ...props.style ?? []
         ],
-        title: 'string' == typeof props.title ? props.title : Array.isArray(props.title) ? props.title.join('') : void 0,
+        title: normalizeHelmetTitle(props.title),
         titleAttributes: props.titleAttributes ?? {}
     };
     collectChildren(props.children, draft);
-    const title = draft.title && props.titleTemplate ? props.titleTemplate.replaceAll('%s', draft.title) : draft.title ?? props.defaultTitle;
     return {
-        base: createDatum('base', [
-            ...baseState.__baseTags ?? [],
-            ...draft.base
-        ]),
-        bodyAttributes: createAttributeDatum(mergeAttributes(baseState.__bodyAttributes ?? {}, draft.bodyAttributes)),
-        htmlAttributes: createAttributeDatum(mergeAttributes(baseState.__htmlAttributes ?? {}, draft.htmlAttributes)),
-        link: createDatum('link', [
-            ...baseState.__linkTags ?? [],
-            ...draft.link
-        ]),
-        meta: createDatum('meta', [
-            ...baseState.__metaTags ?? [],
-            ...draft.meta
-        ]),
-        noscript: createDatum("noscript", [
-            ...baseState.__noscriptTags ?? [],
-            ...draft.noscript
-        ]),
-        priority: createDatum('meta', []),
-        script: createDatum("script", [
-            ...baseState.__scriptTags ?? [],
-            ...draft.script
-        ]),
-        style: createDatum('style', [
-            ...baseState.__styleTags ?? [],
-            ...draft.style
-        ]),
-        title: createTitleDatum(title ?? baseState.__title, mergeAttributes(baseState.__titleAttributes ?? {}, draft.titleAttributes)),
-        __baseTags: [
-            ...baseState.__baseTags ?? [],
-            ...draft.base
-        ],
-        __bodyAttributes: mergeAttributes(baseState.__bodyAttributes ?? {}, draft.bodyAttributes),
-        __htmlAttributes: mergeAttributes(baseState.__htmlAttributes ?? {}, draft.htmlAttributes),
-        __linkTags: [
-            ...baseState.__linkTags ?? [],
-            ...draft.link
-        ],
-        __metaTags: [
-            ...baseState.__metaTags ?? [],
-            ...draft.meta
-        ],
-        __noscriptTags: [
-            ...baseState.__noscriptTags ?? [],
-            ...draft.noscript
-        ],
-        __scriptTags: [
-            ...baseState.__scriptTags ?? [],
-            ...draft.script
-        ],
-        __styleTags: [
-            ...baseState.__styleTags ?? [],
-            ...draft.style
-        ],
-        __title: title ?? baseState.__title,
-        __titleAttributes: mergeAttributes(baseState.__titleAttributes ?? {}, draft.titleAttributes)
+        ...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();
+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 head_Helmet = (props)=>{
     const runtimeContext = react.useContext(InternalRuntimeContext);
-    if (runtimeContext && !runtimeContext.isBrowser) {
-        runtimeContext._helmetContext ??= {};
-        runtimeContext._helmetContext.helmet = collectHelmetProps(runtimeContext._helmetContext.helmet ?? void 0, props);
+    if (null !== runtimeContext && false === runtimeContext.isBrowser) {
+        collectServerHelmet(runtimeContext, props);
         return null;
     }
     return react.createElement(Helmet, props);

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

@@ -1,22 +1,28 @@
 import "node:module";
 import * as __rspack_external__loadable_component_0aaae075 from "@loadable/component";
 export * from "@loadable/component";
+function asLoadableNamespace(value) {
+    return 'object' == typeof value && null !== value ? value : {};
+}
 function resolveLoadable(module) {
-    const namespace = module;
-    const defaultExport = namespace.default;
+    const namespace = asLoadableNamespace(module);
+    const defaultExport = asLoadableNamespace(namespace.default);
     const candidates = [
         module,
         namespace.default,
         defaultExport?.default
     ];
     const loadable = candidates.find((candidate)=>'function' == typeof candidate);
-    if (!loadable) throw new TypeError('Modern.js runtime loadable export must resolve to a function');
+    if ('function' != typeof loadable) throw new TypeError('Modern.js runtime loadable export must resolve to a function');
     return loadable;
 }
 const loadable_loadable = resolveLoadable(__rspack_external__loadable_component_0aaae075);
-const lazy = __rspack_external__loadable_component_0aaae075.lazy ?? __rspack_external__loadable_component_0aaae075["default"]?.lazy ?? loadable_loadable.lazy;
-const loadableReady = __rspack_external__loadable_component_0aaae075.loadableReady ?? __rspack_external__loadable_component_0aaae075["default"]?.loadableReady ?? loadable_loadable.loadableReady;
-const __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = __rspack_external__loadable_component_0aaae075.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED ?? __rspack_external__loadable_component_0aaae075["default"]?.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED ?? loadable_loadable.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+const loadableNamespace = asLoadableNamespace(__rspack_external__loadable_component_0aaae075);
+const loadableDefaultNamespace = asLoadableNamespace(loadableNamespace.default);
+const callableLoadableNamespace = asLoadableNamespace(loadable_loadable);
+const lazy = loadableNamespace.lazy ?? loadableDefaultNamespace.lazy ?? callableLoadableNamespace.lazy;
+const loadableReady = loadableNamespace.loadableReady ?? loadableDefaultNamespace.loadableReady ?? callableLoadableNamespace.loadableReady;
+const __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = loadableNamespace.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED ?? loadableDefaultNamespace.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED ?? callableLoadableNamespace.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
 const exports_loadable = loadable_loadable;
 export default exports_loadable;
 export { __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, lazy, loadableReady };

package/dist/esm-node/exports/tanstack-router.mjs

@@ -1,4 +1,31 @@
 import "node:module";
-export * from "@tanstack/react-router";
-export { Form, RouteActionResponseError, useFetcher } from "../router/runtime/tanstack/dataMutation.mjs";
-export { Link, NavLink } from "../router/runtime/tanstack/prefetchLink.mjs";
+import { createElement } from "react";
+const COMPAT_BINDINGS_SLOT = Symbol.for('@modern-js/plugin-tanstack:runtime-compat-bindings');
+function readCompatBindings() {
+    return globalThis[COMPAT_BINDINGS_SLOT];
+}
+function resolveCompatBindings(exportName) {
+    const bindings = readCompatBindings();
+    if (void 0 === bindings) throw new Error(`[@modern-js/runtime] '${exportName}' from the deprecated '@modern-js/runtime/tanstack-router' alias is provided by @modern-js/plugin-tanstack. Install @modern-js/plugin-tanstack, add \`tanstackRouterPlugin()\` to the \`plugins\` array in modern.config.ts, and make sure '@modern-js/plugin-tanstack/runtime' is imported (e.g. in modern.runtime.ts) before '${exportName}' is used. Prefer importing '${exportName}' from '@modern-js/plugin-tanstack/runtime' directly.`);
+    return bindings;
+}
+const Link = (props)=>createElement(resolveCompatBindings('Link').Link, props);
+const NavLink = (props)=>createElement(resolveCompatBindings('NavLink').NavLink, props);
+const Outlet = ()=>createElement(resolveCompatBindings('Outlet').Outlet);
+const Form = (props)=>createElement(resolveCompatBindings('Form').Form, props);
+function useFetcher() {
+    return resolveCompatBindings('useFetcher').useFetcher();
+}
+function RouteActionResponseErrorPlaceholder() {}
+const RouteActionResponseError = new Proxy(RouteActionResponseErrorPlaceholder, {
+    construct (_target, args) {
+        const RealError = resolveCompatBindings('RouteActionResponseError').RouteActionResponseError;
+        return new RealError(...args);
+    },
+    get (target, property, receiver) {
+        const RealError = readCompatBindings()?.RouteActionResponseError;
+        if (void 0 !== RealError) return Reflect.get(RealError, property);
+        return Reflect.get(target, property, receiver);
+    }
+});
+export { Form, Link, NavLink, Outlet, RouteActionResponseError, useFetcher };

package/dist/esm-node/module-federation/index.mjs

@@ -0,0 +1,110 @@
+import "node:module";
+const MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT = 'modernjs:mf-runtime-fallback';
+const MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT = 'modernjs:mf-runtime-recovery';
+const DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT = '/_modern/contract-gates/runtime-fallback';
+const DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER = 'x-modernjs-runtime-signal-token';
+class ModuleFederationRemoteLoadTimeoutError extends Error {
+    constructor(remote, timeoutMs){
+        super(`Loading remote "${remote}" timed out after ${timeoutMs}ms`);
+        this.name = 'ModuleFederationRemoteLoadTimeoutError';
+    }
+}
+class ModuleFederationRemoteLoadError extends Error {
+    constructor(remote, attempts, causeError){
+        super(`Unable to load remote "${remote}" after ${attempts} attempt${attempts > 1 ? 's' : ''}: ${causeError.message}`);
+        this.name = 'ModuleFederationRemoteLoadError';
+        this.remote = remote;
+        this.attempts = attempts;
+        this.causeError = causeError;
+    }
+}
+class ModuleFederationRemoteComponentContractError extends Error {
+    constructor(remote, exportName){
+        super(`Remote "${remote}" export "${exportName}" is not a valid React component`);
+        this.name = 'ModuleFederationRemoteComponentContractError';
+    }
+}
+function toError(error) {
+    if (error instanceof Error) return error;
+    return new Error('string' == typeof error ? error : 'Unknown remote load error');
+}
+function classifyModuleFederationFallback(error) {
+    const normalizedError = toError(error);
+    if (normalizedError instanceof ModuleFederationRemoteLoadError) return classifyModuleFederationFallback(normalizedError.causeError);
+    if (normalizedError instanceof ModuleFederationRemoteLoadTimeoutError) return 'timeout';
+    if (normalizedError instanceof ModuleFederationRemoteComponentContractError) return 'contract';
+    const message = normalizedError.message;
+    if (/version|requiredVersion|singleton|share scope|shared module/i.test(message)) return 'version-skew';
+    if (/network|fetch|script|timeout|chunk|loading/i.test(message)) return 'network';
+    return 'remote-unavailable';
+}
+function createModuleFederationFallbackTelemetry(input) {
+    const error = void 0 !== input.error ? toError(input.error) : void 0;
+    const status = input.status ?? 'degraded';
+    const eventName = input.eventName ?? ('recovered' === status ? MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT : MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT);
+    const metadata = {
+        ...input.metadata ?? {},
+        classification: input.classification,
+        remote: input.remote,
+        status
+    };
+    if (void 0 !== input.exportName) metadata.exportName = input.exportName;
+    if (void 0 !== input.runtimeDigest) metadata.runtimeDigest = input.runtimeDigest;
+    if (void 0 !== error) {
+        metadata.errorName = error.name;
+        metadata.errorMessage = error.message;
+    }
+    const payload = {
+        appName: input.appName,
+        eventName,
+        metadata,
+        phase: input.phase,
+        reason: input.classification,
+        schemaVersion: 1
+    };
+    if (void 0 !== input.entry) payload.entry = input.entry;
+    if (void 0 !== input.runtimeDigest) payload.runtimeDigest = input.runtimeDigest;
+    return payload;
+}
+function toModuleFederationFallbackAttributes(payload) {
+    return {
+        'data-mf-fallback-app': payload.appName,
+        'data-mf-fallback-classification': payload.reason,
+        'data-mf-fallback-phase': payload.phase,
+        'data-mf-fallback-remote': String(payload.metadata.remote),
+        'data-mf-fallback-status': String(payload.metadata.status),
+        'data-mf-telemetry-event': payload.eventName
+    };
+}
+async function emitModuleFederationFallbackTelemetry(input, options = {}) {
+    const payload = createModuleFederationFallbackTelemetry(input);
+    if ("u" > typeof window && 'function' == typeof window.dispatchEvent && "u" > typeof CustomEvent) window.dispatchEvent(new CustomEvent(payload.eventName, {
+        detail: payload
+    }));
+    const shouldPost = true === options.postSignal || Boolean(options.endpoint);
+    if (!shouldPost) return {
+        dispatched: true,
+        posted: false
+    };
+    const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+    if ('function' != typeof fetchImpl) return {
+        dispatched: true,
+        posted: false
+    };
+    const headers = new Headers({
+        'content-type': 'application/json'
+    });
+    if (void 0 !== options.authToken && options.authToken.length > 0) headers.set(options.authHeaderName ?? DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER, options.authToken);
+    const response = await fetchImpl(options.endpoint ?? DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT, {
+        body: JSON.stringify(payload),
+        headers,
+        method: 'POST',
+        keepalive: true
+    });
+    return {
+        dispatched: true,
+        posted: true,
+        postStatus: response.status
+    };
+}
+export { DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER, DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT, MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT, MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT, ModuleFederationRemoteComponentContractError, ModuleFederationRemoteLoadError, ModuleFederationRemoteLoadTimeoutError, classifyModuleFederationFallback, createModuleFederationFallbackTelemetry, emitModuleFederationFallbackTelemetry, toModuleFederationFallbackAttributes };

package/dist/esm-node/router/cli/code/index.mjs

@@ -1,12 +1,11 @@
 import "node:module";
-import { filterRoutesForServer, filterRoutesLoader, fs, getEntryOptions, isUseRsc, isUseSSRBundle, logger, markRoutes } from "@modern-js/utils";
+import { collectRouteComponentFiles, filterRoutesForServer, filterRoutesLoader, fs, getEntryOptions, isUseRsc, isUseSSRBundle, logger, markRoutes } from "@modern-js/utils";
 import { cloneDeep } from "@modern-js/utils/lodash";
 import path from "path";
 import { ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME } from "../../../cli/constants.mjs";
 import { resolveSSRMode } from "../../../cli/ssr/mode.mjs";
 import { FILE_SYSTEM_ROUTES_FILE_NAME } from "../constants.mjs";
 import { walk } from "./nestedRoutes.mjs";
-import { generateTanstackRouterTypesSourceForEntry, isTanstackRouterFrameworkEnabled } from "./tanstackTypes.mjs";
 import { getServerCombinedModuleFile, getServerLoadersFile } from "./utils.mjs";
 import * as __rspack_external__templates_mjs_4da4c6c8 from "./templates.mjs";
 async function generateRoutesForEntry(entrypoint, appContext) {
@@ -41,42 +40,15 @@ async function generateRoutesForEntry(entrypoint, appContext) {
     }
     return routes;
 }
-const generateCode = async (appContext, config, entrypoints, api, options)=>{
+const generateCode = async (appContext, config, entrypoints, api)=>{
     const { internalDirectory, srcDirectory, internalSrcAlias, packageName } = appContext;
     const hooks = api.getHooks();
-    const enableTanstackTypes = options?.enableTanstackTypes ?? await isTanstackRouterFrameworkEnabled(appContext);
     const generatedRoutesByEntry = {};
+    const eagerRouteComponentFilesByEntry = new Map();
     await Promise.all(entrypoints.map(generateEntryCode));
-    if (enableTanstackTypes) {
-        const allEntries = Array.from(new Set(entrypoints.map((e)=>e.entryName).filter(Boolean)));
-        const mainEntry = entrypoints.find((e)=>e.isMainEntry)?.entryName;
-        const registerEntries = allEntries.sort((a, b)=>{
-            if (mainEntry && a === mainEntry) return -1;
-            if (mainEntry && b === mainEntry) return 1;
-            return a.localeCompare(b);
-        });
-        if (registerEntries.length > 0) {
-            const registerDtsPath = path.join(srcDirectory, 'modern-tanstack', 'register.gen.d.ts');
-            const importStatements = registerEntries.map((entryName, index)=>`import type { router as router${index} } from './${entryName}/router.gen';`).join('\n');
-            const routerUnionType = registerEntries.map((_, index)=>`typeof router${index}`).join(' | ');
-            const registerContent = `// This file is auto-generated by Modern.js. Do not edit manually.
-
-${importStatements}
-
-declare module '@modern-js/runtime/tanstack-router' {
-  interface Register {
-    router: ${routerUnionType};
-  }
-}
-`;
-            try {
-                const prev = await fs.pathExists(registerDtsPath) ? await fs.readFile(registerDtsPath, 'utf-8') : null;
-                if (prev !== registerContent) await fs.outputFile(registerDtsPath, registerContent, 'utf-8');
-            } catch  {
-                await fs.outputFile(registerDtsPath, registerContent, 'utf-8');
-            }
-        }
-    }
+    api.updateAppContext({
+        eagerRouteComponentFilesByEntry
+    });
     async function generateEntryCode(entrypoint) {
         const { entryName, isMainEntry, isAutoMount, pageRoutesEntry, nestedRoutesEntry } = entrypoint;
         const { metaName } = api.getAppContext();
@@ -107,6 +79,8 @@ declare module '@modern-js/runtime/tanstack-router' {
                     routes: markedRoutes
                 });
                 generatedRoutesByEntry[entryName] = routes;
+                const routeEagerFilesForEntry = collectRouteComponentFiles(routes, srcDirectory, internalSrcAlias);
+                eagerRouteComponentFilesByEntry.set(entryName, routeEagerFilesForEntry);
                 if ('stream' === ssrMode) {
                     const hasPageRoute = routes.some((route)=>'type' in route && 'page' === route.type);
                     if (hasPageRoute) {
@@ -158,20 +132,6 @@ declare module '@modern-js/runtime/tanstack-router' {
                     await fs.outputFile(serverLoaderFile, serverLoaderCombined);
                 }
                 await fs.outputFile(path.resolve(internalDirectory, `./${entryName}/${FILE_SYSTEM_ROUTES_FILE_NAME}`), code, 'utf8');
-                if (enableTanstackTypes) {
-                    const { routerGenTs } = await generateTanstackRouterTypesSourceForEntry({
-                        appContext,
-                        entryName,
-                        routes: routes
-                    });
-                    const outPath = path.join(srcDirectory, 'modern-tanstack', entryName, 'router.gen.ts');
-                    try {
-                        const prev = await fs.pathExists(outPath) ? await fs.readFile(outPath, 'utf-8') : null;
-                        if (prev !== routerGenTs) await fs.outputFile(outPath, routerGenTs, 'utf-8');
-                    } catch  {
-                        await fs.outputFile(outPath, routerGenTs, 'utf-8');
-                    }
-                }
             }
         }
     }

package/dist/esm-node/router/cli/code/templates.mjs

@@ -102,20 +102,7 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
     const loadersMapFile = path.join(internalDirectory, entryName, TEMP_LOADERS_DIR, 'map.json');
     const importLazyCode = `
     import { lazy } from "react";
-    import * as loadableModule from "@${metaName}/runtime/loadable"
-
-    const resolveLoadableExport = module => {
-      const candidates = [module, module.default, module.default?.default];
-      const loadable = candidates.find(candidate => typeof candidate === 'function');
-
-      if (!loadable) {
-        throw new TypeError('Modern.js runtime loadable export must resolve to a function');
-      }
-
-      return loadable;
-    };
-    const loadable = resolveLoadableExport(loadableModule);
-    const loadableLazy = loadableModule.lazy || loadableModule.default?.lazy || loadable.lazy;
+    import loadable, { lazy as loadableLazy } from "@${metaName}/runtime/loadable"
   `;
     let rootLayoutCode = "";
     const getDataLoaderPath = ({ loaderId, clientData, action, inline, routeId, inValidSSRRoute })=>{

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

@@ -21,7 +21,7 @@ async function handleGeneratorEntryCode(api, entrypoints, options = {}) {
     const { generatorRegisterCode, generateCode, generatorServerRegisterCode } = await import("./code/index.mjs");
     originEntrypointsByKey.set(entrypointsKey, cloneDeep(entrypoints));
     const enableRsc = resolvedConfig?.server?.rsc;
-    const routesByEntry = await generateCode(appContext, resolvedConfig, entrypoints, api, normalizedOptions.generateCodeOptions);
+    const routesByEntry = await generateCode(appContext, resolvedConfig, entrypoints, api);
     await Promise.all(entrypoints.map(async (entrypoint)=>{
         if (entrypoint.nestedRoutesEntry || entrypoint.pageRoutesEntry) {
             const route = appContext.serverRoutes.find((r)=>r.entryName === entrypoint.entryName);

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

@@ -1,32 +1,12 @@
 import "node:module";
 import node_path from "node:path";
-import { NESTED_ROUTE_SPEC_FILE, filterRoutesForServer, findExists, fs } from "@modern-js/utils";
+import { NESTED_ROUTE_SPEC_FILE, filterRoutesForServer, fs } from "@modern-js/utils";
 import { NESTED_ROUTES_DIR } from "./constants.mjs";
 import { BUILT_IN_ROUTES_OWNER, getEntrypointRoutesDir, getEntrypointRoutesOwner, isRouteEntry } from "./entry.mjs";
 import { handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints } from "./handler.mjs";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
 var cli_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
-const JS_OR_TS_EXTS = [
-    '.js',
-    '.jsx',
-    '.ts',
-    '.tsx',
-    '.mjs',
-    '.mts',
-    '.cjs',
-    '.cts'
-];
-function hasRouterConfigInRuntimeFile(runtimeConfigBase) {
-    const runtimeConfigFile = findExists(JS_OR_TS_EXTS.map((ext)=>`${runtimeConfigBase}${ext}`));
-    if (!runtimeConfigFile) return false;
-    try {
-        const content = fs.readFileSync(runtimeConfigFile, 'utf-8');
-        return /router\s*:/.test(content);
-    } catch  {
-        return false;
-    }
-}
 function isBuiltInRouteEntrypoint(entrypoint) {
     const entrypointRoutesOwner = getEntrypointRoutesOwner(entrypoint);
     if (entrypointRoutesOwner) return entrypointRoutesOwner === BUILT_IN_ROUTES_OWNER;
@@ -56,12 +36,11 @@ const routerPlugin = ()=>({
                 });
             });
             api._internalRuntimePlugins(({ entrypoint, plugins })=>{
-                const { serverRoutes, metaName, srcDirectory, runtimeConfigFile } = api.getAppContext();
+                const { serverRoutes, metaName } = api.getAppContext();
                 const normalizedConfig = api.getNormalizedConfig();
                 const hasUserRouterConfig = normalizedConfig.router && Object.keys(normalizedConfig.router).length > 0;
-                const hasRuntimeRouterConfig = hasRouterConfigInRuntimeFile(node_path.join(srcDirectory, runtimeConfigFile));
                 const serverBase = serverRoutes.filter((route)=>route.entryName === entrypoint.entryName).map((route)=>route.urlPath).sort((a, b)=>a.length - b.length > 0 ? -1 : 1);
-                const shouldInstallBuiltInRouter = isBuiltInRouteEntrypoint(entrypoint) || !isPluginOwnedRouteEntrypoint(entrypoint) && (hasUserRouterConfig || hasRuntimeRouterConfig);
+                const shouldInstallBuiltInRouter = isBuiltInRouteEntrypoint(entrypoint) || !isPluginOwnedRouteEntrypoint(entrypoint) && hasUserRouterConfig;
                 if (shouldInstallBuiltInRouter) plugins.push({
                     name: 'router',
                     path: `@${metaName}/runtime/router/internal`,
@@ -82,7 +61,6 @@ const routerPlugin = ()=>({
                     source: {
                         include: [
                             /[\\/]node_modules[\\/]react-router[\\/]/,
-                            /[\\/]node_modules[\\/]react-router-dom[\\/]/,
                             node_path.resolve(cli_dirname, '../runtime').replace('cjs', 'esm')
                         ]
                     }