@bleedingdev/modern-js-plugin-tanstack 3.2.0-ultramodern.98 → 3.4.0-ultramodern.0

package/dist/cjs/runtime/plugin.js

@@ -1,11 +1,15 @@
 "use strict";
 var __webpack_require__ = {};
 (()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
     };
 })();
 (()=>{
@@ -29,15 +33,15 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
 const context_namespaceObject = require("@modern-js/runtime/context");
-const merge_namespaceObject = require("@modern-js/runtime-utils/merge");
 const url_namespaceObject = require("@modern-js/runtime-utils/url");
 const react_router_namespaceObject = require("@tanstack/react-router");
-const client_namespaceObject = require("@tanstack/react-router/ssr/client");
 const external_react_namespaceObject = require("react");
 const external_basepathRewrite_js_namespaceObject = require("./basepathRewrite.js");
 const external_hooks_js_namespaceObject = require("./hooks.js");
 const external_hydrationBoundary_js_namespaceObject = require("./hydrationBoundary.js");
 const external_lifecycle_js_namespaceObject = require("./lifecycle.js");
+const external_outlet_js_namespaceObject = require("./outlet.js");
+const external_pluginCore_js_namespaceObject = require("./pluginCore.js");
 const external_prefetchLink_js_namespaceObject = require("./prefetchLink.js");
 const external_routeTree_js_namespaceObject = require("./routeTree.js");
 const client_js_namespaceObject = require("./rsc/client.js");
@@ -70,35 +74,178 @@ function wrapRouterSubscribeWithBlockState(router, getBlockNavState) {
     };
     target[BLOCKING_SUBSCRIBE_SYMBOL] = true;
 }
-function stripSyntheticNotFoundRoute(routes) {
-    return routes.filter((route)=>!('*' === route.path && !route.id && !route.loader)).map((route)=>{
-        if (!route.children?.length) return route;
-        return {
-            ...route,
-            children: stripSyntheticNotFoundRoute(route.children)
-        };
+const routerHydrationRecords = new WeakMap();
+const routeModulesKey = '_routeModules';
+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 getCachedRouteModule(routeId) {
+    if ("u" < typeof window) return;
+    return window[routeModulesKey]?.[routeId];
+}
+function preloadHydratedRouteComponents(router) {
+    const preloadableRouter = router;
+    const routesById = preloadableRouter.routesById || {};
+    const matches = preloadableRouter.stores.matches.get();
+    return Promise.all(matches.map((match)=>{
+        if (void 0 === match.routeId || '' === match.routeId) return;
+        const route = routesById[match.routeId];
+        const component = route?.options?.component;
+        const preload = component?.load || component?.preload;
+        if ('function' != typeof preload) return;
+        return Promise.resolve(preload.call(component)).then((routeModule)=>{
+            const modernRouteId = route?.options?.staticData?.modernRouteId;
+            const cachedRouteModule = 'string' == typeof modernRouteId && '' !== modernRouteId ? getCachedRouteModule(modernRouteId) : void 0;
+            const resolvedComponent = pickRouteModuleComponent(cachedRouteModule ?? routeModule);
+            if (void 0 !== resolvedComponent && 'string' == typeof modernRouteId && '' !== modernRouteId) route.options.component = (0, external_outlet_js_namespaceObject.withModernRouteMatchContext)(resolvedComponent, modernRouteId);
+        });
+    })).then(()=>void 0);
+}
+function hydrateTanstackRouter(router) {
+    return import("@tanstack/react-router/ssr/client").then(({ hydrate })=>hydrate(router));
+}
+function getTanstackSsrHydrationRecord(router) {
+    const existingHydrationRecord = routerHydrationRecords.get(router);
+    if (void 0 !== existingHydrationRecord) return existingHydrationRecord;
+    const hydrationRecord = {
+        promise: Promise.resolve(),
+        status: 'pending'
+    };
+    routerHydrationRecords.set(router, hydrationRecord);
+    try {
+        hydrationRecord.promise = hydrateTanstackRouter(router).then((value)=>preloadHydratedRouteComponents(router).then(()=>value)).then((value)=>{
+            hydrationRecord.status = 'fulfilled';
+            return value;
+        }, (error)=>{
+            hydrationRecord.status = 'rejected';
+            hydrationRecord.error = error;
+            throw error;
+        });
+    } catch (error) {
+        hydrationRecord.status = 'rejected';
+        hydrationRecord.error = error;
+        hydrationRecord.promise = Promise.reject(error);
+        hydrationRecord.promise.catch(()=>{});
+    }
+    return hydrationRecord;
+}
+function getTanstackSsrHydrationPromise(router) {
+    return getTanstackSsrHydrationRecord(router).promise;
+}
+function hasTanstackSsrHydrationRecord(router) {
+    return routerHydrationRecords.has(router);
+}
+function ModernRouterClient({ router }) {
+    const hydrationRecord = getTanstackSsrHydrationRecord(router);
+    if ('rejected' === hydrationRecord.status) throw hydrationRecord.error;
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(react_router_namespaceObject.RouterProvider, {
+        router: router
     });
 }
 const tanstackRouterPlugin = (userConfig = {})=>{
     const plugin = {
         name: '@modern-js/plugin-router-tanstack',
-        registryHooks: {
-            modifyRoutes: external_hooks_js_namespaceObject.modifyRoutes,
-            onAfterCreateRouter: external_hooks_js_namespaceObject.onAfterCreateRouter,
-            onAfterHydrateRouter: external_hooks_js_namespaceObject.onAfterHydrateRouter,
-            onBeforeCreateRouter: external_hooks_js_namespaceObject.onBeforeCreateRouter,
-            onBeforeCreateRoutes: external_hooks_js_namespaceObject.onBeforeCreateRoutes,
-            onBeforeHydrateRouter: external_hooks_js_namespaceObject.onBeforeHydrateRouter
-        },
+        registryHooks: external_hooks_js_namespaceObject.routerProviderRegistryHooks,
         setup: (api)=>{
+            const hooks = api.getHooks();
+            let cachedRouteObjects;
+            let cachedRouteTree = null;
+            let cachedRouter = null;
+            let cachedRouterBasepath = null;
+            const getMergedConfig = ()=>(0, external_pluginCore_js_namespaceObject.getMergedRouterConfig)(api, userConfig);
+            const getRouteObjects = ()=>{
+                if (void 0 !== cachedRouteObjects) return cachedRouteObjects;
+                const mergedConfig = getMergedConfig();
+                const { createRoutes } = mergedConfig;
+                const finalRouteConfig = (0, external_pluginCore_js_namespaceObject.getFinalRouteConfig)(mergedConfig);
+                const routeObjects = createRoutes ? createRoutes() : (0, external_utils_js_namespaceObject.createRouteObjectsFromConfig)({
+                    routesConfig: finalRouteConfig
+                }) || [];
+                cachedRouteObjects = hooks.modifyRoutes.call(routeObjects);
+                return cachedRouteObjects;
+            };
+            const getRouteTree = ()=>{
+                if (cachedRouteTree) return cachedRouteTree;
+                const routeObjects = getRouteObjects();
+                if (!routeObjects.length) return null;
+                cachedRouteTree = (0, external_routeTree_js_namespaceObject.createRouteTreeFromRouteObjects)(routeObjects, {
+                    rscPayloadRouter: (0, context_namespaceObject.getGlobalEnableRsc)()
+                });
+                return cachedRouteTree;
+            };
+            const selectBasePath = (pathname)=>{
+                const { serverBase = [] } = getMergedConfig();
+                const match = serverBase.find((baseUrl)=>isSegmentPrefix(pathname, baseUrl));
+                return match || '/';
+            };
+            const getClientBasename = (runtimeContext)=>{
+                const { basename = '' } = getMergedConfig();
+                const baseUrl = selectBasePath(location.pathname).replace(/^\/*/, '/');
+                return '/' === baseUrl ? (0, external_utils_js_namespaceObject.urlJoin)(baseUrl, runtimeContext._internalRouterBaseName || basename || '') : baseUrl;
+            };
+            const getRouter = (runtimeContext, _basename)=>{
+                const routeTree = getRouteTree();
+                if (!routeTree) return null;
+                const lifecycleContext = {
+                    framework: 'tanstack',
+                    phase: 'client-create',
+                    routes: getRouteObjects(),
+                    runtimeContext,
+                    basename: _basename
+                };
+                hooks.onBeforeCreateRouter.call(lifecycleContext);
+                if (cachedRouter && cachedRouterBasepath === _basename) {
+                    wrapRouterSubscribeWithBlockState(cachedRouter, runtimeContext.unstable_getBlockNavState);
+                    hooks.onAfterCreateRouter.call({
+                        ...lifecycleContext,
+                        router: cachedRouter,
+                        runtimeContext
+                    });
+                    return cachedRouter;
+                }
+                const mergedConfig = getMergedConfig();
+                const { supportHtml5History = true } = mergedConfig;
+                const history = supportHtml5History ? (0, react_router_namespaceObject.createBrowserHistory)() : (0, react_router_namespaceObject.createHashHistory)();
+                const rewrite = (0, external_basepathRewrite_js_namespaceObject.createModernBasepathRewrite)(_basename);
+                const serializationAdapters = (0, context_namespaceObject.getGlobalEnableRsc)() ? (0, client_js_namespaceObject.getTanstackRscSerializationAdapters)() : void 0;
+                cachedRouter = (0, react_router_namespaceObject.createRouter)({
+                    ...(0, external_types_js_namespaceObject.getModernTanstackRouterFastDefaults)(mergedConfig),
+                    routeTree,
+                    basepath: '/',
+                    rewrite,
+                    history,
+                    context: {},
+                    ...serializationAdapters ? {
+                        serializationAdapters
+                    } : {}
+                });
+                cachedRouterBasepath = _basename;
+                wrapRouterSubscribeWithBlockState(cachedRouter, runtimeContext.unstable_getBlockNavState);
+                hooks.onAfterCreateRouter.call({
+                    ...lifecycleContext,
+                    router: cachedRouter,
+                    runtimeContext
+                });
+                return cachedRouter;
+            };
             api.onBeforeRender((context)=>{
-                const pluginConfig = api.getRuntimeConfig();
-                const mergedConfig = (0, merge_namespaceObject.merge)(pluginConfig.router || {}, userConfig);
-                if ("u" > typeof window && window._SSR_DATA && mergedConfig.unstable_reloadOnURLMismatch) {
+                const mergedConfig = getMergedConfig();
+                if ("u" > typeof window && void 0 !== window._SSR_DATA && mergedConfig.unstable_reloadOnURLMismatch) {
                     const { ssrContext } = context;
                     const currentPathname = (0, url_namespaceObject.normalizePathname)(window.location.pathname);
-                    const initialPathname = ssrContext?.request?.pathname && (0, url_namespaceObject.normalizePathname)(ssrContext.request.pathname);
-                    if (initialPathname && initialPathname !== currentPathname) {
+                    const initialPathname = 'string' == typeof ssrContext?.request?.pathname ? (0, url_namespaceObject.normalizePathname)(ssrContext.request.pathname) : void 0;
+                    if (void 0 !== initialPathname && '' !== initialPathname && initialPathname !== currentPathname) {
                         const errorMsg = `The initial URL ${initialPathname} and the URL ${currentPathname} to be hydrated do not match, reload.`;
                         console.error(errorMsg);
                         window.location.reload();
@@ -111,94 +258,26 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                     useNavigate: react_router_namespaceObject.useNavigate,
                     useRouter: react_router_namespaceObject.useRouter
                 };
+                const hasSSRBootstrap = "u" > typeof window && Boolean(window.$_TSR);
+                if (hasSSRBootstrap && getRouteObjects().length > 0) {
+                    const runtimeContext = context;
+                    const router = getRouter(runtimeContext, getClientBasename(runtimeContext));
+                    if (null != router) return getTanstackSsrHydrationPromise(router).then(()=>void 0);
+                }
             });
             api.wrapRoot((App)=>{
-                const mergedConfig = (0, merge_namespaceObject.merge)(api.getRuntimeConfig().router || {}, userConfig);
-                const { serverBase = [], supportHtml5History = true, basename = '', routesConfig, createRoutes } = mergedConfig;
-                const finalRouteConfig = {
-                    routes: (0, context_namespaceObject.getGlobalRoutes)(),
-                    globalApp: (0, context_namespaceObject.getGlobalLayoutApp)(),
-                    ...routesConfig
-                };
-                if (!finalRouteConfig.routes && !createRoutes) return App;
-                const hooks = api.getHooks();
-                let cachedRouteObjects;
-                const getRouteObjects = ()=>{
-                    if (void 0 !== cachedRouteObjects) return cachedRouteObjects;
-                    const routeObjects = createRoutes ? createRoutes() : (0, external_utils_js_namespaceObject.createRouteObjectsFromConfig)({
-                        routesConfig: finalRouteConfig
-                    }) || [];
-                    const normalizedRouteObjects = createRoutes ? routeObjects : stripSyntheticNotFoundRoute(routeObjects);
-                    cachedRouteObjects = hooks.modifyRoutes.call(normalizedRouteObjects);
-                    return cachedRouteObjects;
-                };
-                const selectBasePath = (pathname)=>{
-                    const match = serverBase.find((baseUrl)=>isSegmentPrefix(pathname, baseUrl));
-                    return match || '/';
-                };
-                let cachedRouteTree = null;
-                let cachedRouter = null;
-                let cachedRouterBasepath = null;
+                if (0 === getRouteObjects().length) return App;
                 const RouterWrapper = ()=>{
                     const runtimeContext = (0, external_react_namespaceObject.useContext)(context_namespaceObject.InternalRuntimeContext);
-                    const baseUrl = selectBasePath(location.pathname).replace(/^\/*/, '/');
-                    const _basename = '/' === baseUrl ? (0, external_utils_js_namespaceObject.urlJoin)(baseUrl, runtimeContext._internalRouterBaseName || basename || '') : baseUrl;
-                    const routeTree = (0, external_react_namespaceObject.useMemo)(()=>{
-                        if (cachedRouteTree) return cachedRouteTree;
-                        const routeObjects = getRouteObjects();
-                        if (!routeObjects.length) return null;
-                        cachedRouteTree = (0, external_routeTree_js_namespaceObject.createRouteTreeFromRouteObjects)(routeObjects, {
-                            rscPayloadRouter: (0, context_namespaceObject.getGlobalEnableRsc)()
-                        });
-                        return cachedRouteTree;
-                    }, []);
+                    const _basename = getClientBasename(runtimeContext);
+                    const routeTree = (0, external_react_namespaceObject.useMemo)(()=>getRouteTree(), []);
                     if (!routeTree) return App ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {}) : null;
-                    const router = (0, external_react_namespaceObject.useMemo)(()=>{
-                        const lifecycleContext = {
-                            framework: 'tanstack',
-                            phase: 'client-create',
-                            routes: getRouteObjects(),
-                            runtimeContext,
-                            basename: _basename
-                        };
-                        hooks.onBeforeCreateRouter.call(lifecycleContext);
-                        if (cachedRouter && cachedRouterBasepath === _basename) {
-                            wrapRouterSubscribeWithBlockState(cachedRouter, runtimeContext.unstable_getBlockNavState);
-                            hooks.onAfterCreateRouter.call({
-                                ...lifecycleContext,
-                                router: cachedRouter,
-                                runtimeContext
-                            });
-                            return cachedRouter;
-                        }
-                        const history = supportHtml5History ? (0, react_router_namespaceObject.createBrowserHistory)() : (0, react_router_namespaceObject.createHashHistory)();
-                        const rewrite = (0, external_basepathRewrite_js_namespaceObject.createModernBasepathRewrite)(_basename);
-                        const serializationAdapters = (0, context_namespaceObject.getGlobalEnableRsc)() ? (0, client_js_namespaceObject.getTanstackRscSerializationAdapters)() : void 0;
-                        cachedRouter = (0, react_router_namespaceObject.createRouter)({
-                            ...(0, external_types_js_namespaceObject.getModernTanstackRouterFastDefaults)(mergedConfig),
-                            routeTree,
-                            basepath: '/',
-                            rewrite,
-                            history,
-                            context: {},
-                            ...serializationAdapters ? {
-                                serializationAdapters
-                            } : {}
-                        });
-                        cachedRouterBasepath = _basename;
-                        wrapRouterSubscribeWithBlockState(cachedRouter, runtimeContext.unstable_getBlockNavState);
-                        hooks.onAfterCreateRouter.call({
-                            ...lifecycleContext,
-                            router: cachedRouter,
-                            runtimeContext
-                        });
-                        return cachedRouter;
-                    }, [
+                    const router = (0, external_react_namespaceObject.useMemo)(()=>getRouter(runtimeContext, _basename), [
                         _basename,
                         routeTree,
-                        supportHtml5History,
                         runtimeContext
                     ]);
+                    if (!router) return App ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {}) : null;
                     const runtimeState = (0, external_lifecycle_js_namespaceObject.applyRouterRuntimeState)(runtimeContext, {
                         framework: 'tanstack',
                         basename: _basename,
@@ -212,20 +291,21 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                         basename: _basename,
                         router
                     };
-                    const hasSSRBootstrap = "u" > typeof window && Boolean(window.$_TSR);
-                    if (hasSSRBootstrap) hooks.onBeforeHydrateRouter.call({
+                    const hasSSRBootstrap = "u" > typeof window && (Boolean(window.$_TSR) || hasTanstackSsrHydrationRecord(router));
+                    const needsRouterClient = hasSSRBootstrap;
+                    if (needsRouterClient) hooks.onBeforeHydrateRouter.call({
                         ...lifecycleContext,
                         phase: 'hydrate',
                         router,
                         runtimeContext: runtimeState
                     });
-                    const RouterContent = hasSSRBootstrap ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(client_namespaceObject.RouterClient, {
+                    const RouterContent = needsRouterClient ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(ModernRouterClient, {
                         router: router
                     }) : /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(react_router_namespaceObject.RouterProvider, {
                         router: router
                     });
                     const HydratableRouterContent = (0, external_hydrationBoundary_js_namespaceObject.wrapTanstackSsrHydrationBoundary)(RouterContent, hasSSRBootstrap);
-                    if (hasSSRBootstrap) hooks.onAfterHydrateRouter.call({
+                    if (needsRouterClient) hooks.onAfterHydrateRouter.call({
                         ...lifecycleContext,
                         phase: 'hydrate',
                         router,

package/dist/cjs/runtime/plugin.node.js

@@ -1,11 +1,15 @@
 "use strict";
 var __webpack_require__ = {};
 (()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
     };
 })();
 (()=>{
@@ -29,17 +33,16 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
 const context_namespaceObject = require("@modern-js/runtime/context");
-const merge_namespaceObject = require("@modern-js/runtime-utils/merge");
 const node_namespaceObject = require("@modern-js/runtime-utils/node");
 const time_namespaceObject = require("@modern-js/runtime-utils/time");
 const constants_namespaceObject = require("@modern-js/utils/universal/constants");
 const react_router_namespaceObject = require("@tanstack/react-router");
-const server_namespaceObject = require("@tanstack/router-core/ssr/server");
 const external_react_namespaceObject = require("react");
 const external_basepathRewrite_js_namespaceObject = require("./basepathRewrite.js");
 const external_hooks_js_namespaceObject = require("./hooks.js");
 const external_hydrationBoundary_js_namespaceObject = require("./hydrationBoundary.js");
 const external_lifecycle_js_namespaceObject = require("./lifecycle.js");
+const external_pluginCore_js_namespaceObject = require("./pluginCore.js");
 const external_routeTree_js_namespaceObject = require("./routeTree.js");
 const payloadRouter_js_namespaceObject = require("./rsc/payloadRouter.js");
 const external_types_js_namespaceObject = require("./types.js");
@@ -57,7 +60,7 @@ function isPreloadableRouteComponent(component) {
     return 'function' == typeof preloadable.load || 'function' == typeof preloadable.preload;
 }
 function isReactLazyRouteComponent(component) {
-    return Boolean(component) && 'object' == typeof component && 'function' == typeof component._init && '_payload' in component;
+    return null != component && 'object' == typeof component && 'function' == typeof component._init && '_payload' in component;
 }
 async function preloadReactLazyRouteComponent(component) {
     try {
@@ -124,15 +127,6 @@ function createGetSsrHref(request) {
     const url = new URL(request.url);
     return `${url.pathname}${url.search}${url.hash}`;
 }
-function stripSyntheticNotFoundRoute(routes) {
-    return routes.filter((route)=>!('*' === route.path && !route.id && !route.loader)).map((route)=>{
-        if (!route.children?.length) return route;
-        return {
-            ...route,
-            children: stripSyntheticNotFoundRoute(route.children)
-        };
-    });
-}
 function collectRouterErrors(tanstackRouter) {
     const state = tanstackRouter.state;
     const matches = Array.isArray(state.matches) ? state.matches : [];
@@ -144,29 +138,24 @@ function collectRouterErrors(tanstackRouter) {
     }, {});
     return Object.keys(errors).length > 0 ? errors : void 0;
 }
+async function attachServerSsrUtils(router) {
+    const { attachRouterServerSsrUtils } = await import("@tanstack/router-core/ssr/server");
+    attachRouterServerSsrUtils({
+        router,
+        manifest: void 0
+    });
+}
 const tanstackRouterPlugin = (userConfig = {})=>{
     const plugin = {
         name: '@modern-js/plugin-router-tanstack',
-        registryHooks: {
-            modifyRoutes: external_hooks_js_namespaceObject.modifyRoutes,
-            onAfterCreateRouter: external_hooks_js_namespaceObject.onAfterCreateRouter,
-            onAfterHydrateRouter: external_hooks_js_namespaceObject.onAfterHydrateRouter,
-            onBeforeCreateRouter: external_hooks_js_namespaceObject.onBeforeCreateRouter,
-            onBeforeCreateRoutes: external_hooks_js_namespaceObject.onBeforeCreateRoutes,
-            onBeforeHydrateRouter: external_hooks_js_namespaceObject.onBeforeHydrateRouter
-        },
+        registryHooks: external_hooks_js_namespaceObject.routerProviderRegistryHooks,
         setup: (api)=>{
             api.onBeforeRender(async (context, interrupt)=>{
-                const pluginConfig = api.getRuntimeConfig();
-                const mergedConfig = (0, merge_namespaceObject.merge)(pluginConfig.router || {}, userConfig);
+                const mergedConfig = (0, external_pluginCore_js_namespaceObject.getMergedRouterConfig)(api, userConfig);
                 const serializationAdapters = (0, context_namespaceObject.getGlobalEnableRsc)() ? (await import("./rsc/server.js")).getTanstackRscSerializationAdapters() : void 0;
                 const enableRsc = (0, context_namespaceObject.getGlobalEnableRsc)();
-                const { basename = '', routesConfig, createRoutes } = mergedConfig;
-                const finalRouteConfig = {
-                    routes: (0, context_namespaceObject.getGlobalRoutes)(),
-                    globalApp: (0, context_namespaceObject.getGlobalLayoutApp)(),
-                    ...routesConfig
-                };
+                const { basename = '', createRoutes } = mergedConfig;
+                const finalRouteConfig = (0, external_pluginCore_js_namespaceObject.getFinalRouteConfig)(mergedConfig);
                 if (!finalRouteConfig.routes && !createRoutes) return;
                 const hooks = api.getHooks();
                 await hooks.onBeforeCreateRoutes.call(context);
@@ -174,8 +163,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                     routesConfig: finalRouteConfig,
                     ssrMode: context.ssrContext?.mode
                 }) || [];
-                const normalizedRouteObjects = createRoutes ? routeObjects : stripSyntheticNotFoundRoute(routeObjects);
-                const modifiedRouteObjects = hooks.modifyRoutes.call(normalizedRouteObjects);
+                const modifiedRouteObjects = hooks.modifyRoutes.call(routeObjects);
                 if (!modifiedRouteObjects.length) return;
                 const { request, nonce, baseUrl, loaderFailureMode = 'errorBoundary' } = context.ssrContext;
                 const _basename = '/' === baseUrl ? (0, external_utils_js_namespaceObject.urlJoin)(baseUrl, basename || '') : baseUrl;
@@ -223,10 +211,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                     } : {}
                 });
                 const serverRouter = tanstackRouter;
-                (0, server_namespaceObject.attachRouterServerSsrUtils)({
-                    router: serverRouter,
-                    manifest: void 0
-                });
+                await attachServerSsrUtils(serverRouter);
                 const end = (0, time_namespaceObject.time)();
                 try {
                     await tanstackRouter.load({
@@ -293,7 +278,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
             api.wrapRoot((App)=>{
                 const getRouteApp = ()=>(props)=>{
                         const context = (0, external_react_namespaceObject.useContext)(context_namespaceObject.InternalRuntimeContext);
-                        const router = context.routerInstance ?? context.routerRuntime?.instance;
+                        const router = (0, external_lifecycle_js_namespaceObject.getRouterRuntimeState)(context)?.instance;
                         if (!router) return App ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {
                             ...props
                         }) : null;

package/dist/cjs/runtime/plugin.worker.js

@@ -10,11 +10,15 @@ var __webpack_require__ = {};
     };
 })();
 (()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
     };
 })();
 (()=>{

package/dist/cjs/runtime/pluginCore.js

@@ -0,0 +1,55 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    getFinalRouteConfig: ()=>getFinalRouteConfig,
+    getMergedRouterConfig: ()=>getMergedRouterConfig
+});
+const context_namespaceObject = require("@modern-js/runtime/context");
+const merge_namespaceObject = require("@modern-js/runtime-utils/merge");
+function getMergedRouterConfig(api, userConfig) {
+    const pluginConfig = api.getRuntimeConfig();
+    return (0, merge_namespaceObject.merge)(pluginConfig.router || {}, userConfig);
+}
+function getFinalRouteConfig(mergedConfig) {
+    return {
+        routes: (0, context_namespaceObject.getGlobalRoutes)(),
+        globalApp: (0, context_namespaceObject.getGlobalLayoutApp)(),
+        ...mergedConfig.routesConfig
+    };
+}
+exports.getFinalRouteConfig = __webpack_exports__.getFinalRouteConfig;
+exports.getMergedRouterConfig = __webpack_exports__.getMergedRouterConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getFinalRouteConfig",
+    "getMergedRouterConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/prefetchLink.js

@@ -1,11 +1,15 @@
 "use strict";
 var __webpack_require__ = {};
 (()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
     };
 })();
 (()=>{
@@ -33,7 +37,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;