@bleedingdev/modern-js-plugin-tanstack 3.2.0-ultramodern.120 → 3.2.0-ultramodern.122

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

@@ -1,7 +1,6 @@
 import "node:module";
 import { jsx } from "react/jsx-runtime";
-import { InternalRuntimeContext, getGlobalEnableRsc, getGlobalLayoutApp, getGlobalRoutes } from "@modern-js/runtime/context";
-import { merge } from "@modern-js/runtime-utils/merge";
+import { InternalRuntimeContext, getGlobalEnableRsc } from "@modern-js/runtime/context";
 import { createRequestContext, storage } from "@modern-js/runtime-utils/node";
 import { time } from "@modern-js/runtime-utils/time";
 import { LOADER_REPORTER_NAME } from "@modern-js/utils/universal/constants";
@@ -9,9 +8,10 @@ import { RouterProvider, createMemoryHistory, createRouter } from "@tanstack/rea
 import { attachRouterServerSsrUtils } from "@tanstack/router-core/ssr/server";
 import { useContext } from "react";
 import { createModernBasepathRewrite } from "./basepathRewrite.mjs";
-import { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter } from "./hooks.mjs";
+import { routerProviderRegistryHooks } from "./hooks.mjs";
 import { wrapTanstackSsrHydrationBoundary } from "./hydrationBoundary.mjs";
-import { applyRouterServerPrepareResult, createRouterServerSnapshot } from "./lifecycle.mjs";
+import { applyRouterServerPrepareResult, createRouterServerSnapshot, getRouterRuntimeState } from "./lifecycle.mjs";
+import { getFinalRouteConfig, getMergedRouterConfig } from "./pluginCore.mjs";
 import { createRouteTreeFromRouteObjects, getModernRouteIdsFromMatches } from "./routeTree.mjs";
 import { createTanstackRscServerPayload, handleTanstackRscRedirect } from "./rsc/payloadRouter.mjs";
 import { getModernTanstackRouterFastDefaults } from "./types.mjs";
@@ -96,15 +96,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 : [];
@@ -119,26 +110,14 @@ function collectRouterErrors(tanstackRouter) {
 const tanstackRouterPlugin = (userConfig = {})=>{
     const plugin = {
         name: '@modern-js/plugin-router-tanstack',
-        registryHooks: {
-            modifyRoutes: modifyRoutes,
-            onAfterCreateRouter: onAfterCreateRouter,
-            onAfterHydrateRouter: onAfterHydrateRouter,
-            onBeforeCreateRouter: onBeforeCreateRouter,
-            onBeforeCreateRoutes: onBeforeCreateRoutes,
-            onBeforeHydrateRouter: onBeforeHydrateRouter
-        },
+        registryHooks: routerProviderRegistryHooks,
         setup: (api)=>{
             api.onBeforeRender(async (context, interrupt)=>{
-                const pluginConfig = api.getRuntimeConfig();
-                const mergedConfig = merge(pluginConfig.router || {}, userConfig);
+                const mergedConfig = getMergedRouterConfig(api, userConfig);
                 const serializationAdapters = getGlobalEnableRsc() ? (await import("./rsc/server.mjs")).getTanstackRscSerializationAdapters() : void 0;
                 const enableRsc = getGlobalEnableRsc();
-                const { basename = '', routesConfig, createRoutes } = mergedConfig;
-                const finalRouteConfig = {
-                    routes: getGlobalRoutes(),
-                    globalApp: getGlobalLayoutApp(),
-                    ...routesConfig
-                };
+                const { basename = '', createRoutes } = mergedConfig;
+                const finalRouteConfig = getFinalRouteConfig(mergedConfig);
                 if (!finalRouteConfig.routes && !createRoutes) return;
                 const hooks = api.getHooks();
                 await hooks.onBeforeCreateRoutes.call(context);
@@ -146,8 +125,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 ? urlJoin(baseUrl, basename || '') : baseUrl;
@@ -265,7 +243,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
             api.wrapRoot((App)=>{
                 const getRouteApp = ()=>(props)=>{
                         const context = useContext(InternalRuntimeContext);
-                        const router = context.routerInstance ?? context.routerRuntime?.instance;
+                        const router = getRouterRuntimeState(context)?.instance;
                         if (!router) return App ? /*#__PURE__*/ jsx(App, {
                             ...props
                         }) : null;

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

@@ -0,0 +1,15 @@
+import "node:module";
+import { getGlobalLayoutApp, getGlobalRoutes } from "@modern-js/runtime/context";
+import { merge } from "@modern-js/runtime-utils/merge";
+function getMergedRouterConfig(api, userConfig) {
+    const pluginConfig = api.getRuntimeConfig();
+    return merge(pluginConfig.router || {}, userConfig);
+}
+function getFinalRouteConfig(mergedConfig) {
+    return {
+        routes: getGlobalRoutes(),
+        globalApp: getGlobalLayoutApp(),
+        ...mergedConfig.routesConfig
+    };
+}
+export { getFinalRouteConfig, getMergedRouterConfig };

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

@@ -0,0 +1,19 @@
+import "node:module";
+import { registerRouterProvider } from "@modern-js/runtime/context";
+import { Form, RouteActionResponseError, useFetcher } from "./dataMutation.mjs";
+import { Outlet } from "./outlet.mjs";
+import { tanstackRouterPlugin } from "./plugin.mjs";
+import { Link, NavLink } from "./prefetchLink.mjs";
+const tanstackRouterProviderFactory = (userConfig)=>tanstackRouterPlugin(userConfig);
+registerRouterProvider('tanstack', tanstackRouterProviderFactory);
+const COMPAT_BINDINGS_SLOT = Symbol.for('@modern-js/plugin-tanstack:runtime-compat-bindings');
+const tanstackRouterCompatBindings = {
+    Form: Form,
+    Link: Link,
+    NavLink: NavLink,
+    Outlet: Outlet,
+    RouteActionResponseError: RouteActionResponseError,
+    useFetcher: useFetcher
+};
+globalThis[COMPAT_BINDINGS_SLOT] ??= tanstackRouterCompatBindings;
+export { tanstackRouterCompatBindings };

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

@@ -1,7 +1,8 @@
 import "node:module";
-import { createRootRoute, createRoute, notFound, redirect, rootRouteId } from "@tanstack/react-router";
+import { DefaultNotFound } from "@modern-js/runtime/context";
+import { createRootRoute, createRoute, notFound, rootRouteId } from "@tanstack/react-router";
 import { createElement } from "react";
-import { DefaultNotFound } from "./DefaultNotFound.mjs";
+import { isRedirectResponse, isResponse, isTanstackRedirect, throwTanstackRedirect } from "./loaderBridge.mjs";
 import { withModernRouteMatchContext } from "./outlet.mjs";
 import { isTanstackRscPayloadNavigationEnabled, loadTanstackRscRouteData } from "./rsc/payloadRouter.mjs";
 function createTanstackRoute(options) {
@@ -26,23 +27,6 @@ function toTanstackPath(pathname) {
         return segment;
     }).join('/');
 }
-function isResponse(value) {
-    const record = value;
-    return null != record && 'object' == typeof record && 'number' == typeof record.status && 'object' == typeof record.headers;
-}
-function isTanstackRedirect(value) {
-    return isResponse(value) && 'object' == typeof value.options;
-}
-const redirectStatusCodes = new Set([
-    301,
-    302,
-    303,
-    307,
-    308
-]);
-function isRedirectResponse(res) {
-    return redirectStatusCodes.has(res.status);
-}
 function isModernDeferredData(value) {
     if (!value || 'object' != typeof value) return false;
     const deferred = value;
@@ -95,34 +79,6 @@ function createServerLazyImportComponent(lazyImport, fallbackComponent) {
     Component.preload = load;
     return Component;
 }
-function isAbsoluteUrl(value) {
-    try {
-        new URL(value);
-        return true;
-    } catch  {
-        return false;
-    }
-}
-function throwTanstackRedirect(location) {
-    const target = location || '/';
-    if (isAbsoluteUrl(target)) throw redirect({
-        href: target
-    });
-    throw redirect({
-        to: target
-    });
-}
-function mapParamsForModernLoader({ modernRoute, params }) {
-    if ('nested' === modernRoute.type && modernRoute.path?.includes('*')) {
-        const { _splat, ...rest } = params;
-        if (void 0 !== _splat) return {
-            ...rest,
-            '*': _splat
-        };
-        return rest;
-    }
-    return params;
-}
 function createModernRequest(input, signal) {
     return new Request(input, {
         signal
@@ -156,52 +112,6 @@ function createModernShouldReload(shouldRevalidate, state) {
         return 'boolean' == typeof result ? result : void 0;
     };
 }
-function wrapModernLoader(modernRoute, modernLoader, revalidationState, options = {}) {
-    const route = modernRoute;
-    return async (ctx)=>{
-        try {
-            if (revalidationState) rememberRouteLocation(revalidationState, ctx);
-            if ('function' == typeof route.lazyImport) try {
-                await route.lazyImport();
-            } catch  {}
-            const signal = ctx?.abortController?.signal || ctx?.signal || new AbortController().signal;
-            const baseRequest = ctx?.context?.request instanceof Request ? ctx.context.request : void 0;
-            const href = 'string' == typeof ctx?.location ? ctx.location : ctx?.location?.publicHref || ctx?.location?.href || ctx?.location?.url?.href || '';
-            const request = void 0 !== baseRequest ? new Request(baseRequest, {
-                signal
-            }) : createModernRequest(href, signal);
-            const params = mapParamsForModernLoader({
-                modernRoute,
-                params: ctx.params || {}
-            });
-            const loadModernData = async ()=>{
-                const result = modernLoader ? await modernLoader({
-                    request,
-                    params,
-                    context: ctx?.context?.requestContext
-                }) : null;
-                return normalizeModernLoaderResponse(result);
-            };
-            if (options.rscPayloadRouter && isTanstackRscPayloadNavigationEnabled()) return loadTanstackRscRouteData({
-                hasClientLoader: route.hasClientLoader || void 0 !== route.clientData,
-                loadClientData: loadModernData,
-                request,
-                routeId: ctx.route?.id
-            });
-            return loadModernData();
-        } catch (err) {
-            if (isResponse(err)) {
-                if (isTanstackRedirect(err)) throw err;
-                if (isRedirectResponse(err)) {
-                    const location = err.headers.get('Location') || '/';
-                    throwTanstackRedirect(location);
-                }
-                if (404 === err.status) throw notFound();
-            }
-            throw err;
-        }
-    };
-}
 function isRouteObjectPathlessLayout(route) {
     return !route.path && !route.index;
 }
@@ -276,11 +186,6 @@ function toRouteComponent(routeObject) {
     const element = route.element;
     if (element) return ()=>element;
 }
-function toModernRouteComponent(route) {
-    const component = route.component || void 0;
-    if ('function' == typeof route.lazyImport && component) return createServerLazyImportComponent(route.lazyImport, component);
-    return component;
-}
 function toErrorComponent(routeObject) {
     const route = routeObject;
     if (route.ErrorBoundary) return route.ErrorBoundary;
@@ -356,105 +261,6 @@ function createRouteFromRouteObject(opts) {
     }
     return route;
 }
-function createRouteFromModernRoute(opts) {
-    const { options = {}, parent, modernRoute } = opts;
-    const route = modernRoute;
-    const revalidationState = {};
-    const modernId = route.id;
-    const stableFallbackId = modernId || route._component || route.filename || route.data || ('function' == typeof route.loader ? route.id : void 0);
-    const pendingComponent = route.loading || route.pendingComponent;
-    const errorComponent = route.error || route.errorComponent;
-    const component = toModernRouteComponent(route);
-    const modernLoader = route.loader;
-    const modernAction = route.action;
-    const modernShouldRevalidate = route.shouldRevalidate;
-    const shouldReload = createModernShouldReload(modernShouldRevalidate, revalidationState);
-    const isPathlessLayout = 'nested' === route.type && 'boolean' != typeof route.index && void 0 === route.path;
-    const isIndexRoute = 'nested' === route.type && Boolean(route.index);
-    const base = {
-        getParentRoute: ()=>parent,
-        component: component || void 0,
-        pendingComponent: pendingComponent || void 0,
-        errorComponent: errorComponent || void 0,
-        validateSearch: route.validateSearch,
-        loaderDeps: route.loaderDeps,
-        staticData: createRouteStaticData({
-            modernRouteId: modernId,
-            modernRouteAction: modernAction,
-            modernRouteHandle: mergeModernRouteHandle(route),
-            modernRouteHasAction: route.hasAction || Boolean(modernAction),
-            modernRouteHasClientLoader: route.hasClientLoader || void 0 !== route.clientData,
-            modernRouteHasLoader: route.hasLoader || 'function' == typeof modernLoader,
-            modernRouteIsClientComponent: route.isClientComponent,
-            modernRouteLoader: modernLoader,
-            modernRouteShouldRevalidate: modernShouldRevalidate
-        }),
-        loader: wrapModernLoader(modernRoute, modernLoader, revalidationState, options)
-    };
-    if (route.inValidSSRRoute) base.ssr = false;
-    if (shouldReload) base.shouldReload = shouldReload;
-    if (isPathlessLayout) base.id = stableFallbackId || 'pathless';
-    else {
-        const rawPath = route.path;
-        base.path = isIndexRoute ? '/' : toTanstackPath(rawPath || '');
-    }
-    const tanstackRoute = createTanstackRoute(base);
-    wrapRouteComponentWithModernContext(tanstackRoute, component, modernId);
-    const children = route.children;
-    if (children && children.length > 0) {
-        const childRoutes = children.map((child)=>createRouteFromModernRoute({
-                options,
-                parent: tanstackRoute,
-                modernRoute: child
-            }));
-        tanstackRoute.addChildren(childRoutes);
-    }
-    return tanstackRoute;
-}
-function createRouteTreeFromModernRoutes(routes, options = {}) {
-    const rootModern = routes.find((r)=>r && 'nested' === r.type && r.isRoot);
-    const rootComponent = rootModern ? toModernRouteComponent(rootModern) : void 0;
-    const pendingComponent = rootModern?.loading;
-    const errorComponent = rootModern?.error;
-    const rootLoader = rootModern?.loader;
-    const rootAction = rootModern?.action;
-    const rootModernId = rootModern?.id;
-    const rootShouldRevalidate = rootModern?.shouldRevalidate;
-    const rootRevalidationState = {};
-    const rootShouldReload = createModernShouldReload(rootShouldRevalidate, rootRevalidationState);
-    const rootRouteOptions = {
-        component: rootComponent || void 0,
-        pendingComponent: pendingComponent || void 0,
-        errorComponent: errorComponent || void 0,
-        validateSearch: rootModern?.validateSearch,
-        loaderDeps: rootModern?.loaderDeps,
-        notFoundComponent: DefaultNotFound,
-        staticData: createRouteStaticData({
-            modernRouteId: rootModernId,
-            modernRouteAction: rootAction,
-            modernRouteHandle: rootModern ? mergeModernRouteHandle(rootModern) : void 0,
-            modernRouteHasAction: rootModern?.hasAction || Boolean(rootAction),
-            modernRouteHasClientLoader: rootModern?.hasClientLoader || void 0 !== rootModern?.clientData,
-            modernRouteHasLoader: rootModern?.hasLoader || 'function' == typeof rootLoader,
-            modernRouteIsClientComponent: rootModern?.isClientComponent,
-            modernRouteLoader: rootLoader,
-            modernRouteShouldRevalidate: rootShouldRevalidate
-        }),
-        loader: rootModern ? wrapModernLoader(rootModern, rootLoader, rootRevalidationState, options) : void 0
-    };
-    if (rootShouldReload) rootRouteOptions.shouldReload = rootShouldReload;
-    if (rootModern?.inValidSSRRoute) rootRouteOptions.ssr = false;
-    const rootRoute = createTanstackRootRoute(rootRouteOptions);
-    if (rootComponent) rootRoute.options.component = withModernRouteMatchContext(rootComponent, rootRouteId);
-    const topLevel = rootModern ? rootModern.children || [] : routes;
-    const childRoutes = topLevel.map((child)=>createRouteFromModernRoute({
-            options,
-            parent: rootRoute,
-            modernRoute: child
-        }));
-    rootRoute.addChildren(childRoutes);
-    return rootRoute;
-}
 function getRootLikeRouteObject(routes) {
     return routes.find((route)=>'/' === route.path && !route.index);
 }
@@ -510,4 +316,4 @@ function getModernRouteIdsFromMatches(router) {
     }).filter((id)=>'string' == typeof id);
     return Array.from(new Set(ids));
 }
-export { createRouteTreeFromModernRoutes, createRouteTreeFromRouteObjects, getModernRouteIdsFromMatches };
+export { createRouteTreeFromRouteObjects, getModernRouteIdsFromMatches };

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

@@ -0,0 +1,3 @@
+import "node:module";
+import "./register.mjs";
+export { routerPlugin } from "@modern-js/runtime/router/internal";

package/dist/esm-node/runtime/rsc/payloadRouter.mjs

@@ -1,4 +1,5 @@
 import "node:module";
+import { isRouteErrorResponse } from "@modern-js/runtime-utils/router";
 import { notFound, redirect } from "@tanstack/react-router";
 const payloadFetchCache = new Map();
 let payloadDecoder;
@@ -38,6 +39,39 @@ function toPayloadRoute(match) {
         pathnameBase: 'string' == typeof match.pathnameBase ? match.pathnameBase : pathname
     };
 }
+function shouldRedactServerError(status = 500) {
+    return status >= 500 && 'development' !== process.env.NODE_ENV && 'test' !== process.env.NODE_ENV;
+}
+function serializePayloadError(error) {
+    if (isRouteErrorResponse(error)) {
+        if (shouldRedactServerError(error.status)) return {
+            status: error.status,
+            statusText: 'Internal Server Error',
+            data: 'Unexpected Server Error',
+            __type: 'RouteErrorResponse'
+        };
+        return {
+            ...error,
+            __type: 'RouteErrorResponse'
+        };
+    }
+    if (error instanceof Error) {
+        if (shouldRedactServerError()) return {
+            message: 'Unexpected Server Error',
+            stack: void 0,
+            __type: 'Error'
+        };
+        return {
+            message: error.message,
+            stack: error.stack,
+            __type: 'Error',
+            ...'Error' !== error.name ? {
+                __subType: error.name
+            } : {}
+        };
+    }
+    return error;
+}
 function createTanstackRscServerPayload(router, options = {}) {
     const matches = Array.isArray(router.state?.matches) ? router.state.matches : [];
     const routes = [];
@@ -48,7 +82,7 @@ function createTanstackRscServerPayload(router, options = {}) {
         if (payloadRoute) {
             routes.push(payloadRoute);
             if ('loaderData' in match && void 0 !== match.loaderData && !(options.omitClientLoaderData && payloadRoute.hasClientLoader)) loaderData[payloadRoute.id] = match.loaderData;
-            if (void 0 !== match.error) errors[payloadRoute.id] = match.error;
+            if (void 0 !== match.error) errors[payloadRoute.id] = serializePayloadError(match.error);
         }
     }
     return {

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

@@ -0,0 +1,8 @@
+import "node:module";
+import { getRouterRuntimeState } from "@modern-js/runtime/context";
+function getTanstackRouterState(context) {
+    const state = getRouterRuntimeState(context);
+    if (void 0 === state || 'tanstack' !== state.framework) return;
+    return state;
+}
+export { getTanstackRouterState };

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

@@ -1,7 +1,6 @@
 import "node:module";
 import { jsx } from "react/jsx-runtime";
 import react from "react";
-import { DefaultNotFound } from "./DefaultNotFound.mjs";
 function getRouteObjects(routes, { globalApp, ssrMode, props }) {
     const createLayoutElement = (Component)=>{
         const GlobalLayout = globalApp;
@@ -58,10 +57,6 @@ function getRouteObjects(routes, { globalApp, ssrMode, props }) {
         };
         routeObjects.push(routeObject);
     }
-    routeObjects.push({
-        path: '*',
-        element: /*#__PURE__*/ jsx(DefaultNotFound, {})
-    });
     return routeObjects;
 }
 function createRouteObjectsFromConfig({ routesConfig, props, ssrMode }) {

package/dist/types/cli/index.d.ts

@@ -2,8 +2,8 @@ import type { AppTools, AppToolsContext, CliPlugin } from '@modern-js/app-tools'
 import type { NestedRouteForCli, PageRoute } from '@modern-js/types';
 import { type TanstackRouteCodeSplittingOption } from './routeSplitting';
 export type { TanstackRouteCodeSplittingOption, TanstackRsbuildRouteSplittingProfile, } from './routeSplitting';
-export { createTanstackRsbuildRouteSplittingProfile, isTanstackStartRouteModuleSource, resolveTanstackRouteCodeSplittingEnabled, } from './routeSplitting';
-export { collectCanonicalRoutesForEntry, generateTanstackRouterTypesSourceForEntry, isTanstackRouterFrameworkEnabled, } from './tanstackTypes';
+export { createTanstackRsbuildRouteSplittingProfile, resolveTanstackRouteCodeSplittingEnabled, } from './routeSplitting';
+export { type CollectCanonicalRoutesOptions, collectCanonicalRoutesForEntry, generateTanstackRouterTypesSourceForEntry, } from './tanstackTypes';
 export type TanstackRouterPluginOptions = {
     routesDir?: string;
     generatedDirName?: string;
@@ -21,6 +21,13 @@ export declare function writeTanstackRouterTypesForEntries(opts: {
     appContext: AppToolsContext;
     generatedDirName?: string;
     routesByEntry: Record<string, (NestedRouteForCli | PageRoute)[]>;
+    /**
+     * Whether `@modern-js/plugin-i18n` is actually installed in the app. The
+     * `register.gen.d.ts` augmentation of '@modern-js/plugin-i18n/runtime' is
+     * only emitted when this is true — otherwise apps with a hand-rolled
+     * `/:lang/` param would fail typechecking on an unresolvable module.
+     */
+    i18nPluginInstalled?: boolean;
 }): Promise<void>;
 export declare function tanstackRouterPlugin(options?: TanstackRouterPluginOptions): CliPlugin<AppTools>;
 export default tanstackRouterPlugin;

package/dist/types/cli/routeSplitting.d.ts

@@ -7,23 +7,14 @@ export type TanstackRsbuildRouteSplittingProfile = {
             splitRouteChunks: boolean;
         };
     };
-    modernRouteChunks: {
-        enabled: boolean;
-        owner: 'modern';
-    };
-    builderChunkSplit: {
-        owner: 'modern-rsbuild';
-        preserved: true;
-    };
-    tanstackStartRspackSplitter: {
-        compatible: boolean;
-        reason: string;
-        clientDeleteNodes: string[];
-        routeFactoryCalls: string[];
-    };
 };
-export declare function isTanstackStartRouteModuleSource(source: string): boolean;
 export declare function resolveTanstackRouteCodeSplittingEnabled(option?: TanstackRouteCodeSplittingOption): boolean;
+/**
+ * Route chunking for TanStack entries is owned by Modern's
+ * `output.splitRouteChunks`; the TanStack Start Rspack splitter does not
+ * apply because Modern generates TanStack route trees from Modern route
+ * metadata rather than TanStack file-route factory modules.
+ */
 export declare function createTanstackRsbuildRouteSplittingProfile(opts: {
     routeCodeSplitting?: TanstackRouteCodeSplittingOption;
 }): TanstackRsbuildRouteSplittingProfile;

package/dist/types/cli/tanstackTypes.d.ts

@@ -1,5 +1,17 @@
 import type { AppToolsContext } from '@modern-js/app-tools';
 import type { NestedRouteForCli, PageRoute } from '@modern-js/types';
+export type CollectCanonicalRoutesOptions = {
+    /**
+     * Whether a leading `:lang`/`:locale`/`:language` route param may be
+     * treated as an i18n locale prefix. This MUST only be enabled when
+     * `@modern-js/plugin-i18n` is actually installed: the emitted
+     * `declare module '@modern-js/plugin-i18n/runtime'` augmentation breaks
+     * typechecking (TS2664) for apps that hand-roll a `/:lang/` param without
+     * the plugin. Routes carrying `modernCanonicalPath` metadata are always
+     * honored — only plugin-i18n produces them.
+     */
+    localeParamHeuristic?: boolean;
+};
 /**
  * Derive the canonical (language-agnostic) route map for an entry: the
  * leading locale param is stripped and localized physical variants (routes
@@ -8,8 +20,7 @@ import type { NestedRouteForCli, PageRoute } from '@modern-js/types';
  * i18n routing surface (no locale param and no localized variants), so plain
  * TanStack apps never get a `@modern-js/plugin-i18n` module augmentation.
  */
-export declare function collectCanonicalRoutesForEntry(routes: (NestedRouteForCli | PageRoute)[]): Record<string, string> | null;
-export declare function isTanstackRouterFrameworkEnabled(appContext: AppToolsContext): Promise<boolean>;
+export declare function collectCanonicalRoutesForEntry(routes: (NestedRouteForCli | PageRoute)[], options?: CollectCanonicalRoutesOptions): Record<string, string> | null;
 export declare function generateTanstackRouterTypesSourceForEntry(opts: {
     appContext: AppToolsContext;
     entryName: string;

package/dist/types/runtime/hooks.d.ts

@@ -1,18 +1,8 @@
-import type { TRuntimeContext } from '@modern-js/runtime/context';
-import type { RouteObject } from '@modern-js/runtime-utils/router';
-import type { RouterLifecycleContext } from './lifecycle';
-declare const modifyRoutes: import("@modern-js/plugin").SyncHook<(routes: RouteObject[]) => RouteObject[]>;
-declare const onBeforeCreateRoutes: import("@modern-js/plugin").SyncHook<(context: TRuntimeContext) => void>;
-declare const onBeforeCreateRouter: import("@modern-js/plugin").SyncHook<(context: RouterLifecycleContext) => void>;
-declare const onAfterCreateRouter: import("@modern-js/plugin").SyncHook<(context: RouterLifecycleContext) => void>;
-declare const onBeforeHydrateRouter: import("@modern-js/plugin").SyncHook<(context: RouterLifecycleContext) => void>;
-declare const onAfterHydrateRouter: import("@modern-js/plugin").SyncHook<(context: RouterLifecycleContext) => void>;
-export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter, };
-export type RouterExtendsHooks = {
-    modifyRoutes: typeof modifyRoutes;
-    onBeforeCreateRoutes: typeof onBeforeCreateRoutes;
-    onBeforeCreateRouter: typeof onBeforeCreateRouter;
-    onAfterCreateRouter: typeof onAfterCreateRouter;
-    onBeforeHydrateRouter: typeof onBeforeHydrateRouter;
-    onAfterHydrateRouter: typeof onAfterHydrateRouter;
-};
+/**
+ * The router hooks are owned by @modern-js/runtime — this module re-exports
+ * the canonical instances through the `/context` seam, so the TanStack
+ * provider taps and calls the exact same hooks the built-in router wrapper
+ * registers. Creating separate hook instances here would silently split the
+ * hook registry between the wrapper and this provider.
+ */
+export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter, type RouterExtendsHooks, routerProviderRegistryHooks, } from '@modern-js/runtime/context';

package/dist/types/runtime/index.d.ts

@@ -1,12 +1,14 @@
-export type * from '@tanstack/react-router';
-export { Asset, Await, Block, CatchBoundary, CatchNotFound, ClientOnly, cleanPath, composeRewrites, createBrowserHistory, createControlledPromise, createFileRoute, createHashHistory, createHistory, createLazyFileRoute, createLazyRoute, createLink, createMemoryHistory, createRootRoute, createRootRouteWithContext, createRoute, createRouteMask, createRouter, createRouterConfig, createSerializationAdapter, DEFAULT_PROTOCOL_ALLOWLIST, DefaultGlobalNotFound, deepEqual, defaultParseSearch, defaultStringifySearch, defer, ErrorComponent, FileRoute, FileRouteLoader, functionalUpdate, getRouteApi, HeadContent, interpolatePath, isMatch, isNotFound, isPlainArray, isPlainObject, isRedirect, joinPaths, LazyRoute, lazyFn, lazyRouteComponent, linkOptions, Match, Matches, MatchRoute, Navigate, NotFoundRoute, notFound, parseSearchWith, RootRoute, Route, RouteApi, Router, RouterContextProvider, RouterProvider, reactUse, redirect, replaceEqualDeep, resolvePath, retainSearchParams, rootRouteId, rootRouteWithContext, ScriptOnce, Scripts, ScrollRestoration, SearchParamError, stringifySearchWith, stripSearchParams, trimPath, trimPathLeft, trimPathRight, useAwaited, useBlocker, useCanGoBack, useChildMatches, useElementScrollRestoration, useHydrated, useLayoutEffect, useLinkProps, useLoaderData, useLoaderDeps, useLocation, useMatch, useMatches, useMatchRoute, useNavigate, useParams, useParentMatches, useRouteContext, useRouter, useRouterState, useSearch, useTags, } from '@tanstack/react-router';
+import './register';
+export * from '@tanstack/react-router';
 export type { Fetcher, FetcherState, FetcherSubmitOptions, FormProps, SubmitOptions, } from './dataMutation';
 export { Form, RouteActionResponseError, useFetcher, } from './dataMutation';
+export type { ModernRouterContext } from './loaderBridge';
+export { createRouteStaticData, isAbsoluteUrl, modernLoaderToTanstack, throwTanstackRedirect, } from './loaderBridge';
 export { Outlet } from './outlet';
 export { tanstackRouterPlugin, tanstackRouterPlugin as default, } from './plugin';
 export type { LinkProps, NavLinkProps, PrefetchBehavior, } from './prefetchLink';
 export { Link, NavLink } from './prefetchLink';
-export type { AnyCompositeComponent, AnyRenderableServerComponent, CompositeComponentProps, } from './rsc/client';
-export { CompositeComponent } from './rsc/client';
+export type { TanstackRouterState } from './state';
+export { getTanstackRouterState } from './state';
 export type { RouterConfig } from './types';
 export { getModernTanstackRouterFastDefaults, modernTanstackRouterFastDefaults, } from './types';

package/dist/types/runtime/lifecycle.d.ts

@@ -1,22 +1,7 @@
-import type { TInternalRuntimeContext } from '@modern-js/runtime/context';
-import type { RouteObject } from '@modern-js/runtime-utils/router';
-import type { InternalRouterRuntimeState, InternalRouterServerSnapshot, RouterFramework, RouterRouteMatchSnapshot, RouterServerPrepareResult } from './types';
-export type RouterLifecyclePhase = 'ssr-prepare' | 'client-create' | 'hydrate';
-export type RouterLifecycleContext = {
-    framework: RouterFramework;
-    phase: RouterLifecyclePhase;
-    routes: RouteObject[];
-    runtimeContext: TInternalRuntimeContext;
-    basename?: string;
-    hydrationData?: unknown;
-    router?: unknown;
-    matches?: RouterRouteMatchSnapshot[];
-    cleanup?: () => void | Promise<void>;
-    serverSnapshot?: InternalRouterServerSnapshot;
-};
-type RouterSnapshotLike = Partial<InternalRouterServerSnapshot>;
-export declare function createRouterServerSnapshot(state: RouterSnapshotLike): InternalRouterServerSnapshot;
-export declare function createRouterRuntimeState(state: InternalRouterRuntimeState): InternalRouterRuntimeState;
-export declare function applyRouterRuntimeState(runtimeContext: TInternalRuntimeContext, state: InternalRouterRuntimeState): TInternalRuntimeContext;
-export declare function applyRouterServerPrepareResult(runtimeContext: TInternalRuntimeContext, result: RouterServerPrepareResult): TInternalRuntimeContext;
-export {};
+/**
+ * The router runtime state helpers are owned by @modern-js/runtime (the same
+ * implementation backs the built-in react-router provider and the SSR
+ * pipeline). This module only re-exports them so every router provider
+ * writes to the exact same runtime-context extension slot.
+ */
+export { applyRouterRuntimeState, applyRouterServerPrepareResult, createRouterRuntimeState, createRouterServerSnapshot, getRouterRuntimeState, getRouterServerSnapshot, type RouterLifecycleContext, type RouterLifecyclePhase, } from '@modern-js/runtime/context';