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

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

@@ -1,7 +1,9 @@
 import "node:module";
-import { createRootRoute, createRoute, notFound, redirect } 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) {
     return createRoute(options);
@@ -9,6 +11,10 @@ function createTanstackRoute(options) {
 function createTanstackRootRoute(options) {
     return createRootRoute(options);
 }
+function wrapRouteComponentWithModernContext(route, component, routeId) {
+    const routeMatchId = routeId || route.id;
+    if (component && routeMatchId) route.options.component = withModernRouteMatchContext(component, routeMatchId);
+}
 function toTanstackPath(pathname) {
     return pathname.split('/').map((segment)=>{
         if (!segment) return segment;
@@ -21,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;
@@ -90,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
@@ -151,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;
 }
@@ -271,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;
@@ -313,9 +223,10 @@ function createRouteFromRouteObject(opts) {
     const shouldRevalidate = modernRouteObject.shouldRevalidate;
     const shouldReload = createModernShouldReload(shouldRevalidate, revalidationState);
     const stableFallbackId = routeObject.id || modernRouteObject.file || routeObject.path || 'pathless';
+    const component = toRouteComponent(routeObject);
     const base = {
         getParentRoute: ()=>parent,
-        component: toRouteComponent(routeObject),
+        component,
         pendingComponent: toPendingComponent(routeObject),
         errorComponent: toErrorComponent(routeObject),
         validateSearch: modernRouteObject.validateSearch,
@@ -338,6 +249,7 @@ function createRouteFromRouteObject(opts) {
     if (isRouteObjectPathlessLayout(routeObject)) base.id = stableFallbackId;
     else base.path = routeObject.index ? '/' : toTanstackPath(routeObject.path || '');
     const route = createTanstackRoute(base);
+    wrapRouteComponentWithModernContext(route, component, routeObject.id);
     const children = routeObject.children;
     if (children && children.length > 0) {
         const childRoutes = children.map((child)=>createRouteFromRouteObject({
@@ -349,103 +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);
-    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);
-    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);
 }
@@ -454,8 +269,9 @@ function createRouteTreeFromRouteObjects(routes, options = {}) {
     const rootRevalidationState = {};
     const rootShouldRevalidate = rootLikeRoute?.shouldRevalidate;
     const rootShouldReload = createModernShouldReload(rootShouldRevalidate, rootRevalidationState);
+    const rootComponent = rootLikeRoute ? toRouteComponent(rootLikeRoute) : void 0;
     const rootRouteOptions = {
-        component: rootLikeRoute ? toRouteComponent(rootLikeRoute) : void 0,
+        component: rootComponent,
         pendingComponent: rootLikeRoute ? toPendingComponent(rootLikeRoute) : void 0,
         errorComponent: rootLikeRoute ? toErrorComponent(rootLikeRoute) : void 0,
         validateSearch: rootLikeRoute?.validateSearch,
@@ -477,6 +293,7 @@ function createRouteTreeFromRouteObjects(routes, options = {}) {
     if (rootShouldReload) rootRouteOptions.shouldReload = rootShouldReload;
     if (rootLikeRoute?.inValidSSRRoute) rootRouteOptions.ssr = false;
     const rootRoute = createTanstackRootRoute(rootRouteOptions);
+    if (rootComponent) rootRoute.options.component = withModernRouteMatchContext(rootComponent, rootRouteId);
     const topLevel = rootLikeRoute ? [
         ...rootLikeRoute.children || [],
         ...routes.filter((route)=>route !== rootLikeRoute)
@@ -499,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;
@@ -22,7 +21,6 @@ function getRouteObjects(routes, { globalApp, ssrMode, props }) {
             id: route.id,
             loader: route.loader,
             action: route.action,
-            hasErrorBoundary: route.hasErrorBoundary,
             shouldRevalidate: route.shouldRevalidate,
             handle: {
                 ...route.handle,
@@ -58,10 +56,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 { generateTanstackRouterTypesSourceForEntry, isTanstackRouterFrameworkEnabled, } from './tanstackTypes';
+export { createTanstackRsbuildRouteSplittingProfile, resolveTanstackRouteCodeSplittingEnabled, } from './routeSplitting';
+export { type CollectCanonicalRoutesOptions, collectCanonicalRoutesForEntry, generateTanstackRouterTypesSourceForEntry, } from './tanstackTypes';
 export type TanstackRouterPluginOptions = {
     routesDir?: string;
     generatedDirName?: string;
@@ -14,11 +14,20 @@ export declare function writeTanstackRegisterFile(opts: {
     generatedDirName?: string;
     runtimeModule?: string;
     srcDirectory: string;
+    canonicalRoutes?: Record<string, string> | null;
+    i18nRuntimeModule?: string;
 }): Promise<void>;
 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,6 +1,26 @@
 import type { AppToolsContext } from '@modern-js/app-tools';
 import type { NestedRouteForCli, PageRoute } from '@modern-js/types';
-export declare function isTanstackRouterFrameworkEnabled(appContext: AppToolsContext): Promise<boolean>;
+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
+ * carrying `modernCanonicalPath` metadata from `@modern-js/plugin-i18n`)
+ * collapse to their canonical pattern. Returns `null` when the entry has no
+ * 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)[], options?: CollectCanonicalRoutesOptions): Record<string, string> | null;
 export declare function generateTanstackRouterTypesSourceForEntry(opts: {
     appContext: AppToolsContext;
     entryName: string;

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

@@ -1,33 +1,8 @@
-declare const modifyRoutes: {
-    tap: (cb: any) => void;
-    call: (...params: any[]) => any;
-};
-declare const onBeforeCreateRoutes: {
-    tap: (cb: any) => void;
-    call: (...params: any[]) => any;
-};
-declare const onBeforeCreateRouter: {
-    tap: (cb: any) => void;
-    call: (...params: any[]) => any;
-};
-declare const onAfterCreateRouter: {
-    tap: (cb: any) => void;
-    call: (...params: any[]) => any;
-};
-declare const onBeforeHydrateRouter: {
-    tap: (cb: any) => void;
-    call: (...params: any[]) => any;
-};
-declare const onAfterHydrateRouter: {
-    tap: (cb: any) => void;
-    call: (...params: any[]) => any;
-};
-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,11 +1,14 @@
+import './register';
 export * from '@tanstack/react-router';
-export { Outlet, useLocation, useMatch, useMatches, useNavigate, useRouter, } 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';

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

@@ -0,0 +1,48 @@
+/** Router context shape used by the generated TanStack router types. */
+export type ModernRouterContext = {
+    request?: Request;
+    requestContext?: unknown;
+};
+export declare function isResponse(value: unknown): value is Response;
+export declare function isRedirectResponse(res: Response): boolean;
+/**
+ * TanStack redirects are Response objects carrying the original redirect
+ * `options`. They must be re-thrown untouched — re-translating them through
+ * the Modern Response handling would lose `to`-based (internal) targets.
+ */
+export declare function isTanstackRedirect(value: unknown): boolean;
+export declare function isAbsoluteUrl(value: string): boolean;
+/**
+ * Re-throw a Modern.js `Location` redirect as a TanStack redirect.
+ *
+ * Prefers `to` for internal/relative redirects so the basepath rewrite can be
+ * applied; absolute (external) URLs go through `href` untouched.
+ */
+export declare function throwTanstackRedirect(location: string): never;
+/**
+ * React Router uses `*` for splat params, TanStack Router uses `_splat`.
+ * Modern loaders expect the React Router spelling.
+ */
+export declare function mapSplatParamsForModernLoader(params: Record<string, string>, hasSplat: boolean): Record<string, string>;
+/**
+ * Static-data factory used by the generated router files: drops empty fields
+ * so route static data stays minimal.
+ */
+export declare function createRouteStaticData(opts: {
+    modernRouteId?: string;
+    modernRouteAction?: unknown;
+    modernRouteLoader?: unknown;
+}): {
+    modernRouteId?: string;
+    modernRouteAction?: unknown;
+    modernRouteLoader?: unknown;
+};
+/**
+ * Wrap a Modern.js data loader (`page.data.ts` loader/action style) into a
+ * TanStack Router loader: builds a `Request` from the loader context, maps
+ * splat params, and translates Response redirects/404s into TanStack
+ * `redirect()`/`notFound()`.
+ */
+export declare function modernLoaderToTanstack<TLoader extends (args: any) => any>(opts: {
+    hasSplat: boolean;
+}, modernLoader: TLoader): (ctx: unknown) => Promise<Awaited<ReturnType<TLoader>>>;

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

@@ -0,0 +1,2 @@
+export declare const Outlet: import("react").MemoExoticComponent<() => import("react").JSX.Element>;
+export declare function withModernRouteMatchContext(component: unknown, _routeId: string): unknown;

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

@@ -1,17 +1,4 @@
-import type { Plugin, RuntimePluginExtends } from '@modern-js/plugin';
-import type { RuntimePluginAPI } from '@modern-js/plugin/runtime';
-import { type TInternalRuntimeContext } from '@modern-js/runtime/context';
-import { type RouterExtendsHooks } from './hooks';
+import { type TanstackRouterRuntimePlugin } from './pluginCore';
 import { type RouterConfig } from './types';
-type TanstackRouterRuntimeConfig = {
-    plugins?: TanstackRouterRuntimePlugin[];
-    router?: Partial<RouterConfig>;
-    [key: string]: unknown;
-};
-type TanstackRouterRuntimeExtends = Required<RuntimePluginExtends<TanstackRouterRuntimeConfig, TInternalRuntimeContext>> & {
-    extendHooks: RouterExtendsHooks;
-};
-type TanstackRouterPluginAPI = RuntimePluginAPI<TanstackRouterRuntimeExtends>;
-type TanstackRouterRuntimePlugin = Plugin<TanstackRouterPluginAPI, TInternalRuntimeContext>;
 export declare const tanstackRouterPlugin: (userConfig?: Partial<RouterConfig>) => TanstackRouterRuntimePlugin;
 export default tanstackRouterPlugin;