@bleedingdev/modern-js-plugin-tanstack 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

package/dist/esm-node/cli/tanstackTypes/canonicalRoutes.mjs

@@ -1,4 +1,5 @@
 import "node:module";
+import { describeRouteTree } from "../../shared/routeDescriptor.mjs";
 import { toTanstackPath } from "./shared.mjs";
 const LOCALE_PARAM_SEGMENTS = new Set([
     ':lang',
@@ -45,11 +46,13 @@ function collectCanonicalRoutesForEntry(routes, options = {}) {
         const key = toTanstackPath(normalized);
         if (!canonicalParams.has(key)) canonicalParams.set(key, paramsTypeForCanonicalPath(normalized));
     };
-    const visit = (route, parentPath)=>{
+    const visit = (descriptor, parentPath)=>{
+        const { source: route, children } = descriptor;
         let currentPath = parentPath;
-        if ('string' == typeof route.modernCanonicalPath) {
+        const canonicalPath = route.modernLocalisedRoute?.canonicalPath ?? route.modernCanonicalPath;
+        if ('string' == typeof canonicalPath) {
             hasI18nSurface = true;
-            currentPath = normalizeJoined(route.modernCanonicalPath);
+            currentPath = canonicalPath ? normalizeJoined(canonicalPath) : '';
         } else if ('string' == typeof route.path && route.path.length > 0) {
             const segments = route.path.replace(/\[(.+?)\]/g, ':$1').split('/').filter(Boolean);
             if (localeParamHeuristic && '' === parentPath && LOCALE_PARAM_SEGMENTS.has(segments[0])) {
@@ -58,16 +61,13 @@ function collectCanonicalRoutesForEntry(routes, options = {}) {
             }
             currentPath = segments.length ? normalizeJoined(`${parentPath}/${segments.join('/')}`) : parentPath;
         }
-        const children = route.children;
         if (children && children.length > 0) {
             for (const child of children)visit(child, currentPath);
             return;
         }
         record(currentPath || '/');
     };
-    const rootModern = routes.find((route)=>route.isRoot);
-    const topLevel = rootModern ? rootModern.children ?? [] : routes;
-    for (const route of topLevel)visit(route, '');
+    for (const route of describeRouteTree(routes).children)visit(route, '');
     if (!hasI18nSurface || 0 === canonicalParams.size) return null;
     return Object.fromEntries([
         ...canonicalParams.entries()

package/dist/esm-node/cli/tanstackTypes/shared.mjs

@@ -43,14 +43,6 @@ function pickRouteSearchContractModules(route) {
         loaderDepsPath: 'string' == typeof loaderDepsPath ? loaderDepsPath : null
     };
 }
-function isPathlessLayout(route) {
-    const extras = route;
-    return 'nested' === extras.type && 'boolean' != typeof extras.index && void 0 === extras.path;
-}
-function isIndexRoute(route) {
-    const extras = route;
-    return 'nested' === extras.type && Boolean(extras.index);
-}
 function createRouteStaticDataSnippet(opts) {
     const staticData = createRouteStaticData({
         modernRouteId: opts.modernRouteId && quote(opts.modernRouteId),
@@ -61,4 +53,4 @@ function createRouteStaticDataSnippet(opts) {
     return entries.length > 0 ? `staticData: createRouteStaticData({\n    ${entries.map(([key, value])=>`${key}: ${value},`).join('\n    ')}\n  }),` : null;
 }
 export { toTanstackPath } from "../../runtime/routeTree/paths.mjs";
-export { createRouteStaticDataSnippet, isIndexRoute, isPathlessLayout, normalizeRelativeImport, pickModernLoaderModule, pickRouteSearchContractModules, quote, resolveFileNoExt };
+export { createRouteStaticDataSnippet, normalizeRelativeImport, pickModernLoaderModule, pickRouteSearchContractModules, quote, resolveFileNoExt };

package/dist/esm-node/cli/tanstackTypes/source.mjs

@@ -1,16 +1,12 @@
 import "node:module";
 import { makeLegalIdentifier } from "@modern-js/runtime/cli";
 import { upath } from "@modern-js/utils";
-import { createRouteStaticDataSnippet, isIndexRoute, isPathlessLayout, normalizeRelativeImport, pickModernLoaderModule, pickRouteSearchContractModules, quote, resolveFileNoExt, toTanstackPath } from "./shared.mjs";
+import { describeRouteTree } from "../../shared/routeDescriptor.mjs";
+import { createRouteStaticDataSnippet, normalizeRelativeImport, pickModernLoaderModule, pickRouteSearchContractModules, quote, resolveFileNoExt } from "./shared.mjs";
 async function generateTanstackRouterTypesSourceForEntry(opts) {
     const { appContext, entryName, generatedDirName = 'modern-tanstack', routes } = opts;
     const outDir = upath.join(appContext.srcDirectory, generatedDirName, entryName);
-    const rootModern = routes.find((r)=>{
-        const extras = r;
-        return r && 'nested' === extras.type && extras.isRoot;
-    });
-    const rootExtras = rootModern;
-    const topLevel = rootModern ? rootExtras?.children || [] : routes;
+    const { root: rootModern, children: topLevel } = describeRouteTree(routes);
     const imports = [];
     const statements = [];
     const loaderImportMap = new Map();
@@ -27,9 +23,8 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
         let pendingImportName = componentImportMap.get(componentPath);
         if (!pendingImportName) {
             pendingImportName = (async ()=>{
-                const resolvedNoExt = await resolveRouteModuleNoExt(componentPath);
-                if (!resolvedNoExt) return null;
-                const relImport = normalizeRelativeImport(upath.relative(outDir, resolvedNoExt));
+                const relImport = await resolveRouteImport(componentPath);
+                if (!relImport) return null;
                 const componentName = `component_${componentIndex++}`;
                 imports.push(`import ${componentName} from ${quote(relImport)};`);
                 return componentName;
@@ -38,14 +33,15 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
         }
         return pendingImportName;
     };
-    const resolveRouteModuleNoExt = async (aliasedNoExtPath)=>{
+    const resolveRouteImport = async (aliasedNoExtPath)=>{
         const prefix = `${appContext.internalSrcAlias}/`;
         let absNoExt;
         if (aliasedNoExtPath.startsWith(prefix)) {
             const rel = aliasedNoExtPath.slice(prefix.length);
             absNoExt = upath.join(appContext.srcDirectory, rel);
         } else absNoExt = upath.isAbsolute(aliasedNoExtPath) ? aliasedNoExtPath : upath.join(appContext.srcDirectory, aliasedNoExtPath);
-        return resolveFileNoExt(absNoExt);
+        const resolvedNoExt = await resolveFileNoExt(absNoExt);
+        return resolvedNoExt ? normalizeRelativeImport(upath.relative(outDir, resolvedNoExt)) : null;
     };
     const getImportNamesForLoader = async (aliasedNoExtPath, inline, hasAction)=>{
         const key = `${inline ? 'inline' : 'default'}:${hasAction ? 'action' : 'loader'}:${aliasedNoExtPath}`;
@@ -54,9 +50,8 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
             loaderName: existing,
             actionName: hasAction ? existing.replace(/^loader_/, 'action_') : null
         };
-        const resolvedNoExt = await resolveRouteModuleNoExt(aliasedNoExtPath);
-        if (!resolvedNoExt) return null;
-        const relImport = normalizeRelativeImport(upath.relative(outDir, resolvedNoExt));
+        const relImport = await resolveRouteImport(aliasedNoExtPath);
+        if (!relImport) return null;
         const importName = `loader_${loaderIndex++}`;
         const actionName = hasAction ? importName.replace(/^loader_/, 'action_') : null;
         if (inline) {
@@ -76,9 +71,8 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
         const key = `${exportName}:${aliasedNoExtPath}`;
         const existing = searchContractImportMap.get(key);
         if (existing) return existing;
-        const resolvedNoExt = await resolveRouteModuleNoExt(aliasedNoExtPath);
-        if (!resolvedNoExt) return null;
-        const relImport = normalizeRelativeImport(upath.relative(outDir, resolvedNoExt));
+        const relImport = await resolveRouteImport(aliasedNoExtPath);
+        if (!relImport) return null;
         const importName = 'validateSearch' === exportName ? `validateSearch_${validateSearchIndex++}` : `loaderDeps_${loaderDepsIndex++}`;
         imports.push(`import { ${exportName} as ${importName} } from ${quote(relImport)};`);
         searchContractImportMap.set(key, importName);
@@ -96,9 +90,7 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
         const base = id ? makeLegalIdentifier(id) : `r_${routeIndex++}`;
         return reserveRouteVarName(`route_${base}`);
     };
-    const buildRoute = async (opts)=>{
-        const { parentVar, route } = opts;
-        const varName = createRouteVarName(route);
+    const createRouteOptions = async (route, hasSplat)=>{
         const routeExtras = route;
         const loaderInfo = pickModernLoaderModule(route);
         const routeAction = routeExtras.action;
@@ -108,20 +100,9 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
         const searchContractInfo = pickRouteSearchContractModules(route);
         const validateSearchName = searchContractInfo.validateSearchPath ? await getImportNameForSearchContract(searchContractInfo.validateSearchPath, 'validateSearch') : null;
         const loaderDepsName = searchContractInfo.loaderDepsPath ? await getImportNameForSearchContract(searchContractInfo.loaderDepsPath, 'loaderDeps') : null;
-        const rawPath = routeExtras.path;
-        const hasSplat = 'string' == typeof rawPath && rawPath.includes('*');
-        const routeOpts = [
-            `getParentRoute: () => ${parentVar},`
-        ];
+        const routeOpts = [];
         const componentName = await getImportNameForComponent(routeExtras._component);
         if (componentName) routeOpts.push(`component: ${componentName},`);
-        if (isPathlessLayout(route)) {
-            const id = routeExtras.id;
-            routeOpts.push(`id: ${quote(id || 'pathless')},`);
-        } else {
-            const p = isIndexRoute(route) ? '/' : toTanstackPath(rawPath || '');
-            routeOpts.push(`path: ${quote(p)},`);
-        }
         if (loaderName) routeOpts.push(`loader: modernLoaderToTanstack({ hasSplat: ${hasSplat} }, ${loaderName}),`);
         if (validateSearchName) routeOpts.push(`validateSearch: ${validateSearchName},`);
         if (loaderDepsName) routeOpts.push(`loaderDeps: ${loaderDepsName},`);
@@ -131,39 +112,29 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
             actionName
         });
         if (staticDataSnippet) routeOpts.push(staticDataSnippet);
-        const children = routeExtras.children;
+        return routeOpts;
+    };
+    const buildRoute = async (descriptor, parentVar)=>{
+        const { source: route, location, hasSplat, children } = descriptor;
+        const varName = createRouteVarName(route);
+        const routeOpts = [
+            `getParentRoute: () => ${parentVar},`,
+            ...Object.entries(location).map(([key, value])=>`${key}: ${quote(value)},`),
+            ...await createRouteOptions(route, hasSplat)
+        ];
         const hasChildren = Boolean(children && children.length > 0);
         const routeCtorVarName = hasChildren ? reserveRouteVarName(`${varName}__base`) : varName;
         statements.push(`const ${routeCtorVarName} = createRoute({\n  ${routeOpts.join('\n  ')}\n});`);
         if (children && children.length > 0) {
             const childVars = [];
-            for (const child of children)childVars.push(await buildRoute({
-                parentVar: routeCtorVarName,
-                route: child
-            }));
+            for (const child of children)childVars.push(await buildRoute(child, routeCtorVarName));
             statements.push(`const ${varName} = ${routeCtorVarName}.addChildren([${childVars.join(', ')}]);`);
         }
         return varName;
     };
-    const rootLoaderInfo = rootModern ? pickModernLoaderModule(rootModern) : null;
-    const rootAction = rootExtras?.action;
-    const rootLoaderImports = rootLoaderInfo?.loaderPath ? await getImportNamesForLoader(rootLoaderInfo.loaderPath, rootLoaderInfo.inline, Boolean(rootLoaderInfo.inline && rootAction === rootLoaderInfo.loaderPath)) : null;
-    const rootLoaderName = rootLoaderImports?.loaderName || null;
-    const rootActionName = rootLoaderImports?.actionName || null;
-    const rootSearchContractInfo = rootModern ? pickRouteSearchContractModules(rootModern) : null;
-    const rootValidateSearchName = rootSearchContractInfo?.validateSearchPath ? await getImportNameForSearchContract(rootSearchContractInfo.validateSearchPath, 'validateSearch') : null;
-    const rootLoaderDepsName = rootSearchContractInfo?.loaderDepsPath ? await getImportNameForSearchContract(rootSearchContractInfo.loaderDepsPath, 'loaderDeps') : null;
     const topLevelVars = [];
-    for (const route of topLevel)topLevelVars.push(await buildRoute({
-        parentVar: 'rootRoute',
-        route
-    }));
-    const rootOpts = [];
-    const rootComponentName = await getImportNameForComponent(rootExtras?._component);
-    if (rootComponentName) rootOpts.push(`component: ${rootComponentName},`);
-    if (rootLoaderName) rootOpts.push(`loader: modernLoaderToTanstack({ hasSplat: false }, ${rootLoaderName}),`);
-    if (rootValidateSearchName) rootOpts.push(`validateSearch: ${rootValidateSearchName},`);
-    if (rootLoaderDepsName) rootOpts.push(`loaderDeps: ${rootLoaderDepsName},`);
+    for (const route of topLevel)topLevelVars.push(await buildRoute(route, 'rootRoute'));
+    const rootOpts = rootModern ? await createRouteOptions(rootModern, false) : [];
     const routerGenTs = `// This file is auto-generated by Modern.js. Do not edit manually.
 
 import {
@@ -180,11 +151,7 @@ ${imports.join('\n')}
 
 export const rootRoute = createRootRouteWithContext<ModernRouterContext>()({
   ${rootOpts.join('\n  ')}
-  ${createRouteStaticDataSnippet({
-        modernRouteId: rootExtras?.id,
-        loaderName: rootLoaderName,
-        actionName: rootActionName
-    }) || ''}
+
 });
 
 ${statements.join('\n\n')}

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

@@ -1,17 +1,20 @@
 import "node:module";
+import { createLocalisedRouteRewrite } from "@modern-js/i18n-runtime-extensions";
+import { composeRewrites } from "@tanstack/react-router";
 function normalizeBasepath(basepath) {
     if (!basepath) return '/';
     let normalized = basepath.startsWith('/') ? basepath : `/${basepath}`;
     if (normalized.length > 1 && normalized.endsWith('/')) normalized = normalized.slice(0, -1);
     return normalized || '/';
 }
-function createModernBasepathRewrite(basepath, caseSensitive = false) {
+function createModernBasepathRewrite(basepath, caseSensitive = false, routes = []) {
+    const localisedRewrite = createLocalisedRouteRewrite(routes);
     const normalizedBasepath = normalizeBasepath(basepath);
-    if ('/' === normalizedBasepath) return;
+    if ('/' === normalizedBasepath) return localisedRewrite;
     const normalizedBasepathWithSlash = `${normalizedBasepath}/`;
     const checkBasepath = caseSensitive ? normalizedBasepath : normalizedBasepath.toLowerCase();
     const checkBasepathWithSlash = caseSensitive ? normalizedBasepathWithSlash : normalizedBasepathWithSlash.toLowerCase();
-    return {
+    const basepathRewrite = {
         input: ({ url })=>{
             const pathname = caseSensitive ? url.pathname : url.pathname.toLowerCase();
             if (pathname === checkBasepath) url.pathname = '/';
@@ -25,5 +28,9 @@ function createModernBasepathRewrite(basepath, caseSensitive = false) {
             return url;
         }
     };
+    return localisedRewrite ? composeRewrites([
+        basepathRewrite,
+        localisedRewrite
+    ]) : basepathRewrite;
 }
 export { createModernBasepathRewrite };

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

@@ -1,2 +1,2 @@
 import "node:module";
-export { applyRouterRuntimeState, applyRouterServerPrepareResult, createRouterRuntimeState, createRouterServerSnapshot, getRouterRuntimeState, getRouterServerSnapshot } from "@modern-js/runtime/context";
+export { applyRouterRuntimeState, applyRouterServerPrepareResult, createRouterServerSnapshot, getRouterRuntimeState, getRouterServerSnapshot } from "@modern-js/runtime-extensions/router-state";

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

@@ -37,10 +37,13 @@ function mapSplatParamsForModernLoader(params, hasSplat) {
     return rest;
 }
 function getLoaderSignal(ctx) {
-    const abortSignal = ctx?.abortController?.signal;
-    if (abortSignal instanceof AbortSignal) return abortSignal;
-    if (ctx?.signal instanceof AbortSignal) return ctx.signal;
-    return new AbortController().signal;
+    const matchSignal = ctx?.abortController?.signal ?? ctx?.signal;
+    const requestSignal = ctx?.context?.request?.signal;
+    const signals = [
+        matchSignal,
+        requestSignal
+    ].filter((signal)=>signal instanceof AbortSignal);
+    return AbortSignal.any(signals);
 }
 function getLoaderHref(ctx) {
     if ('string' == typeof ctx?.location) return ctx.location;
@@ -102,4 +105,4 @@ function modernLoaderToTanstack(opts, modernLoader) {
     };
 }
 export { createRouteStaticData } from "../shared/routeStaticData.mjs";
-export { getLoaderHref, handleModernLoaderError, handleModernLoaderResult, isAbsoluteUrl, isRedirectResponse, isResponse, isTanstackRedirect, mapSplatParamsForModernLoader, modernLoaderToTanstack, throwTanstackRedirect };
+export { getLoaderHref, getLoaderSignal, handleModernLoaderError, handleModernLoaderResult, isAbsoluteUrl, isRedirectResponse, isResponse, isTanstackRedirect, mapSplatParamsForModernLoader, modernLoaderToTanstack, throwTanstackRedirect };

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

@@ -0,0 +1,65 @@
+import "node:module";
+import { Link } from "./prefetchLink.mjs";
+function createTanstackNavigation(router) {
+    let location;
+    let matches;
+    let snapshot;
+    return {
+        Link: Link,
+        getSnapshot () {
+            const state = router.state;
+            if (location !== state.location || void 0 === matches || matches.length !== state.matches.length || matches.some((match, index)=>match.params !== state.matches[index]?.params)) {
+                location = state.location;
+                matches = state.matches;
+                snapshot = {
+                    location: {
+                        pathname: location.pathname,
+                        search: location.searchStr,
+                        hash: '' !== location.hash ? `#${location.hash.replace(/^#/, '')}` : ''
+                    },
+                    params: Object.assign({}, ...matches.map((match)=>match.params))
+                };
+            }
+            return snapshot;
+        },
+        subscribe (listener) {
+            const stops = [
+                'onBeforeNavigate',
+                'onBeforeLoad',
+                'onLoad',
+                'onResolved'
+            ].map((event)=>router.subscribe(event, listener));
+            return ()=>{
+                for (const stop of stops)stop();
+            };
+        },
+        navigate (href, options) {
+            return router.navigate({
+                to: href,
+                replace: options?.replace,
+                ...options?.state === void 0 ? {} : {
+                    state: options.state
+                }
+            });
+        },
+        createLinkProps (target) {
+            const preload = void 0 !== target.preload ? target.preload : 'none' === target.prefetch ? false : target.prefetch;
+            return {
+                to: target.pathname,
+                ...void 0 !== target.search ? {
+                    search: target.search
+                } : {},
+                ...void 0 !== target.hash && '' !== target.hash ? {
+                    hash: target.hash
+                } : {},
+                ...void 0 === target.hashScrollIntoView ? {} : {
+                    hashScrollIntoView: target.hashScrollIntoView
+                },
+                ...void 0 === preload ? {} : {
+                    preload
+                }
+            };
+        }
+    };
+}
+export { createTanstackNavigation };

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

@@ -11,6 +11,7 @@ import { ModernRouterClient, getTanstackSsrHydrationPromise, hasTanstackSsrHydra
 import { routerProviderRegistryHooks } from "./hooks.mjs";
 import { wrapTanstackSsrHydrationBoundary } from "./hydrationBoundary.mjs";
 import { applyRouterRuntimeState } from "./lifecycle.mjs";
+import { createTanstackNavigation } from "./navigation.mjs";
 import { createTanstackRouteObjects, getMergedRouterConfig, getTanstackRouteConfig, joinBasename } from "./pluginShared.mjs";
 import { Link } from "./prefetchLink.mjs";
 import { useMatches } from "./routeHooks.mjs";
@@ -78,7 +79,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                 const mergedConfig = getMergedConfig();
                 const { supportHtml5History = true } = mergedConfig;
                 const history = supportHtml5History ? createBrowserHistory() : createHashHistory();
-                const rewrite = createModernBasepathRewrite(_basename);
+                const rewrite = createModernBasepathRewrite(_basename, false, getRouteObjects());
                 const serializationAdapters = getGlobalEnableRsc() ? getTanstackRscSerializationAdapters() : void 0;
                 const routerFastDefaults = getModernTanstackRouterFastDefaults(mergedConfig);
                 cachedRouter = createRouter({
@@ -143,10 +144,14 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                         runtimeContext
                     ]);
                     if (!router) return App ? /*#__PURE__*/ jsx(App, {}) : null;
+                    const navigation = useMemo(()=>createTanstackNavigation(router), [
+                        router
+                    ]);
                     const runtimeState = applyRouterRuntimeState(runtimeContext, {
                         framework: 'tanstack',
                         basename: _basename,
-                        instance: router
+                        instance: router,
+                        navigation
                     });
                     const lifecycleContext = {
                         framework: 'tanstack',

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

@@ -9,12 +9,14 @@ import { useContext } from "react";
 import { createModernBasepathRewrite } from "./basepathRewrite.mjs";
 import { routerProviderRegistryHooks } from "./hooks.mjs";
 import { wrapTanstackSsrHydrationBoundary } from "./hydrationBoundary.mjs";
-import { applyRouterServerPrepareResult, createRouterServerSnapshot, getRouterRuntimeState } from "./lifecycle.mjs";
+import { applyRouterRuntimeState, applyRouterServerPrepareResult, getRouterRuntimeState, getRouterServerSnapshot } from "./lifecycle.mjs";
+import { createTanstackNavigation } from "./navigation.mjs";
 import { createTanstackRouteObjects, getTanstackRouteConfig, joinBasename } from "./pluginShared.mjs";
+import { Link } from "./prefetchLink.mjs";
 import { createRouteTreeFromRouteObjects, getModernRouteIdsFromMatches } from "./routeTree/index.mjs";
 import { createTanstackRscServerPayload, handleTanstackRscRedirect } from "./rsc/payloadRouter.mjs";
 import { getTanstackRscRouter, setTanstackRscRouter, setTanstackRscServerPayload } from "./rsc/payloadStorage.mjs";
-import { attachServerSsrUtils, collectRouterErrors, createGetSsrHref, routerManagedTagsToHtml, waitForRouterSerialization } from "./ssrManagedTags.mjs";
+import { attachServerSsrUtils, collectRouterErrors, createGetSsrHref, routerManagedTagsToHtml } from "./ssrManagedTags.mjs";
 import { preloadMatchedRouteComponents } from "./ssrPreload.mjs";
 import { getModernTanstackRouterFastDefaults } from "./types.mjs";
 const tanstackRouterPlugin = (userConfig = {})=>{
@@ -36,6 +38,9 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                     routeConfig
                 });
                 if (!modifiedRouteObjects.length) return;
+                context.router = {
+                    Link: Link
+                };
                 const { request, nonce, baseUrl, loaderFailureMode = 'errorBoundary' } = context.ssrContext;
                 const _basename = '/' === baseUrl ? joinBasename(baseUrl, basename || '') : baseUrl;
                 const rawRequest = request.raw;
@@ -58,7 +63,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                         initialHref
                     ]
                 });
-                const rewrite = createModernBasepathRewrite(_basename);
+                const rewrite = createModernBasepathRewrite(_basename, false, modifiedRouteObjects);
                 const routerLifecycleContext = {
                     framework: 'tanstack',
                     phase: 'ssr-prepare',
@@ -84,76 +89,93 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                 });
                 const serverRouter = tanstackRouter;
                 if (enableRsc) setTanstackRscRouter(serverRouter);
-                await attachServerSsrUtils(serverRouter);
-                const end = time();
+                let disposed = false;
+                let prepared = false;
+                const onAbort = ()=>controller.abort(rawRequest.signal.reason);
+                const cleanup = ()=>{
+                    if (disposed) return;
+                    disposed = true;
+                    rawRequest.signal.removeEventListener('abort', onAbort);
+                    controller.abort();
+                    serverRouter.serverSsr?.cleanup();
+                };
+                applyRouterRuntimeState(context, {
+                    framework: 'tanstack',
+                    basename: _basename,
+                    instance: serverRouter,
+                    cleanup
+                });
+                rawRequest.signal.addEventListener('abort', onAbort, {
+                    once: true
+                });
                 try {
-                    await tanstackRouter.load({
-                        sync: true
-                    });
-                } finally{
-                    const cost = end();
-                    context.ssrContext?.onTiming?.(LOADER_REPORTER_NAME, cost);
-                }
-                const serverLoadResult = serverRouter._serverResult;
-                if (!serverLoadResult) {
+                    rawRequest.signal.throwIfAborted();
+                    await attachServerSsrUtils(serverRouter);
+                    rawRequest.signal.throwIfAborted();
+                    const end = time();
                     try {
-                        serverRouter.serverSsr?.cleanup?.();
-                    } catch  {}
-                    throw new Error('TanStack Router completed an SSR load without a server result.');
-                }
-                if ('redirect' === serverLoadResult.type) {
-                    const { redirect } = serverLoadResult;
-                    try {
-                        serverRouter.serverSsr?.cleanup?.();
-                    } catch  {}
-                    return interrupt(isRSCNavigation ? handleTanstackRscRedirect(redirect.headers, _basename, redirect.status) : redirect);
-                }
-                const routerErrors = collectRouterErrors(tanstackRouter);
-                if (routerErrors && 'clientRender' === loaderFailureMode) {
-                    context.ssrContext?.response?.status(200);
-                    try {
-                        serverRouter.serverSsr?.cleanup?.();
-                    } catch  {}
-                    throw Object.values(routerErrors)[0];
-                }
-                await preloadMatchedRouteComponents(serverRouter);
-                context.ssrContext?.response?.status(serverLoadResult.status);
-                await serverRouter.serverSsr?.dehydrate?.();
-                if (enableRsc) {
-                    if (isRSCNavigation) await waitForRouterSerialization(serverRouter);
-                    setTanstackRscServerPayload(createTanstackRscServerPayload(serverRouter, {
+                        await tanstackRouter.load({
+                            sync: true
+                        });
+                    } finally{
+                        const cost = end();
+                        context.ssrContext?.onTiming?.(LOADER_REPORTER_NAME, cost);
+                    }
+                    rawRequest.signal.throwIfAborted();
+                    const serverLoadResult = serverRouter._serverResult;
+                    if (!serverLoadResult) throw new Error('TanStack Router completed an SSR load without a server result.');
+                    if ('redirect' === serverLoadResult.type) {
+                        const { redirect } = serverLoadResult;
+                        return interrupt(isRSCNavigation ? handleTanstackRscRedirect(redirect.headers, _basename, redirect.status) : redirect);
+                    }
+                    const routerErrors = collectRouterErrors(tanstackRouter);
+                    if (routerErrors && 'clientRender' === loaderFailureMode) {
+                        context.ssrContext?.response?.status(200);
+                        throw Object.values(routerErrors)[0];
+                    }
+                    await preloadMatchedRouteComponents(serverRouter);
+                    context.ssrContext?.response?.status(serverLoadResult.status);
+                    await serverRouter.serverSsr?.dehydrate();
+                    if (enableRsc) setTanstackRscServerPayload(createTanstackRscServerPayload(serverRouter, {
                         omitClientLoaderData: isRSCNavigation
                     }));
-                }
-                const ssrScriptTags = serverRouter.serverSsr?.takeBufferedScripts?.();
-                const hydrationScripts = routerManagedTagsToHtml(ssrScriptTags);
-                const matchedRouteIds = getModernRouteIdsFromMatches(serverRouter);
-                const routerServerSnapshot = createRouterServerSnapshot({
-                    framework: 'tanstack',
-                    basename: _basename,
-                    statusCode: serverLoadResult.status,
-                    errors: routerErrors,
-                    matchedRouteIds,
-                    hydrationScripts
-                });
-                const runtimeContext = applyRouterServerPrepareResult(context, {
-                    snapshot: routerServerSnapshot,
-                    cleanup: ()=>serverRouter.serverSsr?.cleanup?.(),
-                    state: {
+                    const initialScriptTags = serverRouter.serverSsr?.takeInitialHydrationScriptTags();
+                    const hydrationScripts = initialScriptTags ? routerManagedTagsToHtml([
+                        ...initialScriptTags.before,
+                        initialScriptTags.boundary
+                    ]) : [];
+                    const matchedRouteIds = getModernRouteIdsFromMatches(serverRouter);
+                    const routerServerSnapshot = {
                         framework: 'tanstack',
                         basename: _basename,
-                        instance: serverRouter,
-                        hydrationScripts,
+                        statusCode: serverLoadResult.status,
+                        errors: routerErrors,
                         matchedRouteIds,
-                        serverSnapshot: routerServerSnapshot
-                    }
-                });
-                hooks.onAfterCreateRouter.call({
-                    ...routerLifecycleContext,
-                    router: serverRouter,
-                    serverSnapshot: routerServerSnapshot,
-                    runtimeContext
-                });
+                        hydrationScripts
+                    };
+                    const runtimeContext = applyRouterServerPrepareResult(context, {
+                        snapshot: routerServerSnapshot,
+                        cleanup,
+                        state: {
+                            framework: 'tanstack',
+                            basename: _basename,
+                            instance: serverRouter,
+                            navigation: createTanstackNavigation(tanstackRouter)
+                        }
+                    });
+                    rawRequest.signal.throwIfAborted();
+                    hooks.onAfterCreateRouter.call({
+                        ...routerLifecycleContext,
+                        router: serverRouter,
+                        serverSnapshot: getRouterServerSnapshot(runtimeContext),
+                        runtimeContext
+                    });
+                    prepared = true;
+                } finally{
+                    if (!prepared) try {
+                        cleanup();
+                    } catch  {}
+                }
             });
             api.wrapRoot((App)=>{
                 const getRouteApp = ()=>{

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

@@ -1,12 +1,7 @@
 import "node:module";
 import { jsx } from "react/jsx-runtime";
+import { resolvePreloadFromPrefetch } from "@modern-js/runtime-extensions";
 import { useLinkProps } from "@tanstack/react-router";
-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 'viewport';
-}
 const LinkComponentImpl = (props)=>{
     const { prefetch, preload, 'aria-current': ariaCurrentProp, ref, children, ...rest } = props;
     const hasAriaCurrentOverride = 'aria-current' in props;

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

@@ -1,6 +1,4 @@
 import "node:module";
-import { registerRouterProvider } from "@modern-js/runtime/context";
 import { tanstackRouterPlugin } from "./plugin.mjs";
 const tanstackRouterProviderFactory = (userConfig)=>tanstackRouterPlugin(userConfig);
-registerRouterProvider('tanstack', tanstackRouterProviderFactory);
 export { tanstackRouterProviderFactory };