@bleedingdev/modern-js-plugin-tanstack 3.5.0-ultramodern.27 → 3.5.0-ultramodern.29

package/dist/cjs/cli/index.js

@@ -55,6 +55,7 @@ var __webpack_exports__ = {};
         collectCanonicalRoutesForEntry: ()=>external_tanstackTypes_js_namespaceObject.collectCanonicalRoutesForEntry,
         createTanstackRsbuildRouteSplittingProfile: ()=>external_routeSplitting_js_namespaceObject.createTanstackRsbuildRouteSplittingProfile,
         default: ()=>src_cli,
+        generateTanstackRouteArtifacts: ()=>generateTanstackRouteArtifacts,
         generateTanstackRouterTypesSourceForEntry: ()=>external_tanstackTypes_js_namespaceObject.generateTanstackRouterTypesSourceForEntry,
         resolveTanstackRouteCodeSplittingEnabled: ()=>external_routeSplitting_js_namespaceObject.resolveTanstackRouteCodeSplittingEnabled,
         tanstackRouterPlugin: ()=>tanstackRouterPlugin,
@@ -295,11 +296,30 @@ ${canonicalRoutesAugmentation}`;
             }
         };
     }
+    async function generateTanstackRouteArtifacts(opts) {
+        const [{ createRunOptions }, { cli }, utils] = await Promise.all([
+            import("@modern-js/app-tools/cli/run"),
+            import("@modern-js/plugin/cli"),
+            import("@modern-js/utils")
+        ]);
+        process.env.MODERN_ARGV = 'node modern build';
+        process.env.NODE_ENV = process.env.NODE_ENV || 'production';
+        const runOptions = await createRunOptions({
+            cwd: opts.appDirectory,
+            version: opts.version || process.env.MODERN_JS_VERSION || '0.0.0-routes-generate',
+            internalPlugins: utils.INTERNAL_RUNTIME_PLUGINS
+        });
+        await cli.init({
+            ...runOptions,
+            command: 'build'
+        });
+    }
     const src_cli = tanstackRouterPlugin;
 })();
 exports.collectCanonicalRoutesForEntry = __webpack_exports__.collectCanonicalRoutesForEntry;
 exports.createTanstackRsbuildRouteSplittingProfile = __webpack_exports__.createTanstackRsbuildRouteSplittingProfile;
 exports["default"] = __webpack_exports__["default"];
+exports.generateTanstackRouteArtifacts = __webpack_exports__.generateTanstackRouteArtifacts;
 exports.generateTanstackRouterTypesSourceForEntry = __webpack_exports__.generateTanstackRouterTypesSourceForEntry;
 exports.resolveTanstackRouteCodeSplittingEnabled = __webpack_exports__.resolveTanstackRouteCodeSplittingEnabled;
 exports.tanstackRouterPlugin = __webpack_exports__.tanstackRouterPlugin;
@@ -309,6 +329,7 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "collectCanonicalRoutesForEntry",
     "createTanstackRsbuildRouteSplittingProfile",
     "default",
+    "generateTanstackRouteArtifacts",
     "generateTanstackRouterTypesSourceForEntry",
     "resolveTanstackRouteCodeSplittingEnabled",
     "tanstackRouterPlugin",

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

@@ -167,13 +167,14 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                 if (!modifiedRouteObjects.length) return;
                 const { request, nonce, baseUrl, loaderFailureMode = 'errorBoundary' } = context.ssrContext;
                 const _basename = '/' === baseUrl ? (0, external_utils_js_namespaceObject.urlJoin)(baseUrl, basename || '') : baseUrl;
-                const initialHref = createGetSsrHref(request.raw);
-                const isRSCNavigation = enableRsc && 'true' === request.raw.headers.get('x-rsc-tree');
+                const rawRequest = request.raw;
+                const initialHref = createGetSsrHref(rawRequest);
+                const isRSCNavigation = enableRsc && 'true' === rawRequest.headers.get('x-rsc-tree');
                 const requestContext = (0, node_namespaceObject.createRequestContext)(context.ssrContext?.loaderContext);
                 const controller = new AbortController();
-                const ssrRequest = new Request(request.raw.url, {
+                const ssrRequest = new Request(rawRequest.url, {
                     method: 'GET',
-                    headers: request.raw.headers,
+                    headers: rawRequest.headers,
                     signal: controller.signal
                 });
                 const routerContext = {
@@ -201,7 +202,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                     history,
                     basepath: '/',
                     rewrite,
-                    origin: new URL(request.raw.url).origin,
+                    origin: new URL(rawRequest.url).origin,
                     ssr: {
                         nonce
                     },
@@ -230,14 +231,14 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                 }
                 const routerErrors = collectRouterErrors(tanstackRouter);
                 if (routerErrors && 'clientRender' === loaderFailureMode) {
-                    context.ssrContext?.response.status(200);
+                    context.ssrContext?.response?.status(200);
                     try {
                         serverRouter.serverSsr?.cleanup?.();
                     } catch  {}
                     throw Object.values(routerErrors)[0];
                 }
                 await preloadMatchedRouteComponents(serverRouter);
-                context.ssrContext?.response.status(tanstackRouter.state.statusCode);
+                context.ssrContext?.response?.status(tanstackRouter.state.statusCode);
                 await serverRouter.serverSsr?.dehydrate?.();
                 if (isRSCNavigation) {
                     await waitForRouterSerialization(serverRouter);

package/dist/cjs/runtime/prefetchLink.js

@@ -40,10 +40,23 @@ function resolvePreloadFromPrefetch(prefetch, preload) {
     return 'viewport';
 }
 const LinkComponentImpl = (props)=>{
-    const { prefetch, preload, ...rest } = props;
-    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(react_router_namespaceObject.Link, {
+    const { prefetch, preload, 'aria-current': ariaCurrentProp, ref, children, ...rest } = props;
+    const hasAriaCurrentOverride = 'aria-current' in props;
+    const linkOptions = {
         ...rest,
         preload: resolvePreloadFromPrefetch(prefetch, preload)
+    };
+    const linkProps = (0, react_router_namespaceObject.useLinkProps)(linkOptions, ref);
+    const { disabled: _disabled, type: _type, ...anchorProps } = linkProps;
+    if (hasAriaCurrentOverride) if (false === ariaCurrentProp || void 0 === ariaCurrentProp) delete anchorProps['aria-current'];
+    else anchorProps['aria-current'] = ariaCurrentProp;
+    const resolvedChildren = 'function' == typeof children ? children({
+        isActive: 'active' === anchorProps['data-status'],
+        isTransitioning: 'transitioning' === anchorProps['data-transitioning']
+    }) : children;
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("a", {
+        ...anchorProps,
+        children: resolvedChildren
     });
 };
 const Link = LinkComponentImpl;

package/dist/esm/cli/index.mjs

@@ -238,6 +238,24 @@ function tanstackRouterPlugin(options = {}) {
         }
     };
 }
+async function generateTanstackRouteArtifacts(opts) {
+    const [{ createRunOptions }, { cli }, utils] = await Promise.all([
+        import("@modern-js/app-tools/cli/run"),
+        import("@modern-js/plugin/cli"),
+        import("@modern-js/utils")
+    ]);
+    process.env.MODERN_ARGV = 'node modern build';
+    process.env.NODE_ENV = process.env.NODE_ENV || 'production';
+    const runOptions = await createRunOptions({
+        cwd: opts.appDirectory,
+        version: opts.version || process.env.MODERN_JS_VERSION || '0.0.0-routes-generate',
+        internalPlugins: utils.INTERNAL_RUNTIME_PLUGINS
+    });
+    await cli.init({
+        ...runOptions,
+        command: 'build'
+    });
+}
 const src_cli = tanstackRouterPlugin;
 export default src_cli;
-export { collectCanonicalRoutesForEntry, createTanstackRsbuildRouteSplittingProfile, generateTanstackRouterTypesSourceForEntry, resolveTanstackRouteCodeSplittingEnabled, tanstackRouterPlugin, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries };
+export { collectCanonicalRoutesForEntry, createTanstackRsbuildRouteSplittingProfile, generateTanstackRouteArtifacts, generateTanstackRouterTypesSourceForEntry, resolveTanstackRouteCodeSplittingEnabled, tanstackRouterPlugin, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries };

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

@@ -134,13 +134,14 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                 if (!modifiedRouteObjects.length) return;
                 const { request, nonce, baseUrl, loaderFailureMode = 'errorBoundary' } = context.ssrContext;
                 const _basename = '/' === baseUrl ? urlJoin(baseUrl, basename || '') : baseUrl;
-                const initialHref = createGetSsrHref(request.raw);
-                const isRSCNavigation = enableRsc && 'true' === request.raw.headers.get('x-rsc-tree');
+                const rawRequest = request.raw;
+                const initialHref = createGetSsrHref(rawRequest);
+                const isRSCNavigation = enableRsc && 'true' === rawRequest.headers.get('x-rsc-tree');
                 const requestContext = createRequestContext(context.ssrContext?.loaderContext);
                 const controller = new AbortController();
-                const ssrRequest = new Request(request.raw.url, {
+                const ssrRequest = new Request(rawRequest.url, {
                     method: 'GET',
-                    headers: request.raw.headers,
+                    headers: rawRequest.headers,
                     signal: controller.signal
                 });
                 const routerContext = {
@@ -168,7 +169,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                     history,
                     basepath: '/',
                     rewrite,
-                    origin: new URL(request.raw.url).origin,
+                    origin: new URL(rawRequest.url).origin,
                     ssr: {
                         nonce
                     },
@@ -197,14 +198,14 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                 }
                 const routerErrors = collectRouterErrors(tanstackRouter);
                 if (routerErrors && 'clientRender' === loaderFailureMode) {
-                    context.ssrContext?.response.status(200);
+                    context.ssrContext?.response?.status(200);
                     try {
                         serverRouter.serverSsr?.cleanup?.();
                     } catch  {}
                     throw Object.values(routerErrors)[0];
                 }
                 await preloadMatchedRouteComponents(serverRouter);
-                context.ssrContext?.response.status(tanstackRouter.state.statusCode);
+                context.ssrContext?.response?.status(tanstackRouter.state.statusCode);
                 await serverRouter.serverSsr?.dehydrate?.();
                 if (isRSCNavigation) {
                     await waitForRouterSerialization(serverRouter);

package/dist/esm/runtime/prefetchLink.mjs

@@ -1,5 +1,5 @@
 import { jsx } from "react/jsx-runtime";
-import { Link } from "@tanstack/react-router";
+import { useLinkProps } from "@tanstack/react-router";
 function resolvePreloadFromPrefetch(prefetch, preload) {
     if (void 0 !== preload) return preload;
     if ('none' === prefetch) return false;
@@ -7,12 +7,25 @@ function resolvePreloadFromPrefetch(prefetch, preload) {
     return 'viewport';
 }
 const LinkComponentImpl = (props)=>{
-    const { prefetch, preload, ...rest } = props;
-    return /*#__PURE__*/ jsx(Link, {
+    const { prefetch, preload, 'aria-current': ariaCurrentProp, ref, children, ...rest } = props;
+    const hasAriaCurrentOverride = 'aria-current' in props;
+    const linkOptions = {
         ...rest,
         preload: resolvePreloadFromPrefetch(prefetch, preload)
+    };
+    const linkProps = useLinkProps(linkOptions, ref);
+    const { disabled: _disabled, type: _type, ...anchorProps } = linkProps;
+    if (hasAriaCurrentOverride) if (false === ariaCurrentProp || void 0 === ariaCurrentProp) delete anchorProps['aria-current'];
+    else anchorProps['aria-current'] = ariaCurrentProp;
+    const resolvedChildren = 'function' == typeof children ? children({
+        isActive: 'active' === anchorProps['data-status'],
+        isTransitioning: 'transitioning' === anchorProps['data-transitioning']
+    }) : children;
+    return /*#__PURE__*/ jsx("a", {
+        ...anchorProps,
+        children: resolvedChildren
     });
 };
-const prefetchLink_Link = LinkComponentImpl;
+const Link = LinkComponentImpl;
 const NavLink = LinkComponentImpl;
-export { NavLink, prefetchLink_Link as Link };
+export { Link, NavLink };

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

@@ -242,6 +242,24 @@ function tanstackRouterPlugin(options = {}) {
         }
     };
 }
+async function generateTanstackRouteArtifacts(opts) {
+    const [{ createRunOptions }, { cli }, utils] = await Promise.all([
+        import("@modern-js/app-tools/cli/run"),
+        import("@modern-js/plugin/cli"),
+        import("@modern-js/utils")
+    ]);
+    process.env.MODERN_ARGV = 'node modern build';
+    process.env.NODE_ENV = process.env.NODE_ENV || 'production';
+    const runOptions = await createRunOptions({
+        cwd: opts.appDirectory,
+        version: opts.version || process.env.MODERN_JS_VERSION || '0.0.0-routes-generate',
+        internalPlugins: utils.INTERNAL_RUNTIME_PLUGINS
+    });
+    await cli.init({
+        ...runOptions,
+        command: 'build'
+    });
+}
 const src_cli = tanstackRouterPlugin;
 export default src_cli;
-export { collectCanonicalRoutesForEntry, createTanstackRsbuildRouteSplittingProfile, generateTanstackRouterTypesSourceForEntry, resolveTanstackRouteCodeSplittingEnabled, tanstackRouterPlugin, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries };
+export { collectCanonicalRoutesForEntry, createTanstackRsbuildRouteSplittingProfile, generateTanstackRouteArtifacts, generateTanstackRouterTypesSourceForEntry, resolveTanstackRouteCodeSplittingEnabled, tanstackRouterPlugin, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries };

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

@@ -135,13 +135,14 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                 if (!modifiedRouteObjects.length) return;
                 const { request, nonce, baseUrl, loaderFailureMode = 'errorBoundary' } = context.ssrContext;
                 const _basename = '/' === baseUrl ? urlJoin(baseUrl, basename || '') : baseUrl;
-                const initialHref = createGetSsrHref(request.raw);
-                const isRSCNavigation = enableRsc && 'true' === request.raw.headers.get('x-rsc-tree');
+                const rawRequest = request.raw;
+                const initialHref = createGetSsrHref(rawRequest);
+                const isRSCNavigation = enableRsc && 'true' === rawRequest.headers.get('x-rsc-tree');
                 const requestContext = createRequestContext(context.ssrContext?.loaderContext);
                 const controller = new AbortController();
-                const ssrRequest = new Request(request.raw.url, {
+                const ssrRequest = new Request(rawRequest.url, {
                     method: 'GET',
-                    headers: request.raw.headers,
+                    headers: rawRequest.headers,
                     signal: controller.signal
                 });
                 const routerContext = {
@@ -169,7 +170,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                     history,
                     basepath: '/',
                     rewrite,
-                    origin: new URL(request.raw.url).origin,
+                    origin: new URL(rawRequest.url).origin,
                     ssr: {
                         nonce
                     },
@@ -198,14 +199,14 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                 }
                 const routerErrors = collectRouterErrors(tanstackRouter);
                 if (routerErrors && 'clientRender' === loaderFailureMode) {
-                    context.ssrContext?.response.status(200);
+                    context.ssrContext?.response?.status(200);
                     try {
                         serverRouter.serverSsr?.cleanup?.();
                     } catch  {}
                     throw Object.values(routerErrors)[0];
                 }
                 await preloadMatchedRouteComponents(serverRouter);
-                context.ssrContext?.response.status(tanstackRouter.state.statusCode);
+                context.ssrContext?.response?.status(tanstackRouter.state.statusCode);
                 await serverRouter.serverSsr?.dehydrate?.();
                 if (isRSCNavigation) {
                     await waitForRouterSerialization(serverRouter);

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

@@ -1,6 +1,6 @@
 import "node:module";
 import { jsx } from "react/jsx-runtime";
-import { Link } from "@tanstack/react-router";
+import { useLinkProps } from "@tanstack/react-router";
 function resolvePreloadFromPrefetch(prefetch, preload) {
     if (void 0 !== preload) return preload;
     if ('none' === prefetch) return false;
@@ -8,12 +8,25 @@ function resolvePreloadFromPrefetch(prefetch, preload) {
     return 'viewport';
 }
 const LinkComponentImpl = (props)=>{
-    const { prefetch, preload, ...rest } = props;
-    return /*#__PURE__*/ jsx(Link, {
+    const { prefetch, preload, 'aria-current': ariaCurrentProp, ref, children, ...rest } = props;
+    const hasAriaCurrentOverride = 'aria-current' in props;
+    const linkOptions = {
         ...rest,
         preload: resolvePreloadFromPrefetch(prefetch, preload)
+    };
+    const linkProps = useLinkProps(linkOptions, ref);
+    const { disabled: _disabled, type: _type, ...anchorProps } = linkProps;
+    if (hasAriaCurrentOverride) if (false === ariaCurrentProp || void 0 === ariaCurrentProp) delete anchorProps['aria-current'];
+    else anchorProps['aria-current'] = ariaCurrentProp;
+    const resolvedChildren = 'function' == typeof children ? children({
+        isActive: 'active' === anchorProps['data-status'],
+        isTransitioning: 'transitioning' === anchorProps['data-transitioning']
+    }) : children;
+    return /*#__PURE__*/ jsx("a", {
+        ...anchorProps,
+        children: resolvedChildren
     });
 };
-const prefetchLink_Link = LinkComponentImpl;
+const Link = LinkComponentImpl;
 const NavLink = LinkComponentImpl;
-export { NavLink, prefetchLink_Link as Link };
+export { Link, NavLink };

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

@@ -30,4 +30,15 @@ export declare function writeTanstackRouterTypesForEntries(opts: {
     i18nPluginInstalled?: boolean;
 }): Promise<void>;
 export declare function tanstackRouterPlugin(options?: TanstackRouterPluginOptions): CliPlugin<AppTools>;
+/**
+ * Headless regeneration of `router.gen.ts` / `register.gen.d.ts` for a generated
+ * app, without running a full dev/build. Drives the app-tools analyze `onPrepare`
+ * (which fires `generateEntryCode`) and returns before any bundling — the app's
+ * own registered plugin-tanstack writes the artifacts via its `generateEntryCode`
+ * subscriber. Reuses the exact hook dev/build use, so there is no scanning drift.
+ */
+export declare function generateTanstackRouteArtifacts(opts: {
+    appDirectory: string;
+    version?: string;
+}): Promise<void>;
 export default tanstackRouterPlugin;

package/package.json

@@ -18,7 +18,7 @@
     "modern.js",
     "tanstack-router"
   ],
-  "version": "3.5.0-ultramodern.27",
+  "version": "3.5.0-ultramodern.29",
   "engines": {
     "node": ">=20"
   },
@@ -77,13 +77,14 @@
     "@swc/helpers": "^0.5.23",
     "@tanstack/react-router": "1.170.16",
     "@tanstack/router-core": "1.171.13",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.5.0-ultramodern.27",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.27",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.27",
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.5.0-ultramodern.27"
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.5.0-ultramodern.29",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.29",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.29",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.5.0-ultramodern.29"
   },
   "peerDependencies": {
-    "@modern-js/runtime": "3.5.0-ultramodern.27",
+    "@modern-js/app-tools": "3.5.0-ultramodern.29",
+    "@modern-js/runtime": "3.5.0-ultramodern.29",
     "react": "^19.2.7",
     "react-dom": "^19.2.7"
   },
@@ -98,9 +99,9 @@
     "@typescript/native-preview": "7.0.0-dev.20260628.1",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
-    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.5.0-ultramodern.27",
-    "@scripts/rstest-config": "2.66.0",
-    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.5.0-ultramodern.27"
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.5.0-ultramodern.29",
+    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.5.0-ultramodern.29",
+    "@scripts/rstest-config": "2.66.0"
   },
   "sideEffects": [
     "./src/runtime/register.ts",

package/rstest.config.mts

@@ -25,6 +25,7 @@ export default {
       include: [
         'tests/router/cli.test.ts',
         'tests/router/fastDefaults.test.ts',
+        'tests/router/generateRouteArtifacts.test.ts',
         'tests/router/hooks.test.ts',
         'tests/router/loaderBridge.test.ts',
         'tests/router/packageSurface.test.ts',
@@ -44,6 +45,7 @@ export default {
         'tests/router/dataMutation.test.tsx',
         'tests/router/hydrationBoundary.test.tsx',
         'tests/router/prefetchLink.test.tsx',
+        'tests/router/prefetchLinkPreload.test.tsx',
       ],
       extends: commonConfig,
     }),

package/src/cli/index.ts

@@ -1,4 +1,4 @@
-// @effect-diagnostics asyncFunction:off nodeBuiltinImport:off strictBooleanExpressions:off
+// @effect-diagnostics asyncFunction:off nodeBuiltinImport:off strictBooleanExpressions:off processEnv:off processEnvInEffect:off
 import path from 'node:path';
 import type {
   AppNormalizedConfig,
@@ -518,4 +518,37 @@ export function tanstackRouterPlugin(
   };
 }
 
+/**
+ * Headless regeneration of `router.gen.ts` / `register.gen.d.ts` for a generated
+ * app, without running a full dev/build. Drives the app-tools analyze `onPrepare`
+ * (which fires `generateEntryCode`) and returns before any bundling — the app's
+ * own registered plugin-tanstack writes the artifacts via its `generateEntryCode`
+ * subscriber. Reuses the exact hook dev/build use, so there is no scanning drift.
+ */
+export async function generateTanstackRouteArtifacts(opts: {
+  appDirectory: string;
+  version?: string;
+}): Promise<void> {
+  const [{ createRunOptions }, { cli }, utils] = await Promise.all([
+    import('@modern-js/app-tools/cli/run'),
+    import('@modern-js/plugin/cli'),
+    import('@modern-js/utils'),
+  ]);
+  // Load-bearing, not decoration: app-tools' analyze.onPrepare only fires
+  // generateEntryCode (the hook that writes the route artifacts) when
+  // checkIsBuildCommands() is true, and getCommand() resolves the command
+  // from MODERN_ARGV before process.argv — cli.init's `command` option does
+  // not feed that check.
+  process.env.MODERN_ARGV = 'node modern build';
+  process.env.NODE_ENV = process.env.NODE_ENV || 'production';
+  const runOptions = await createRunOptions({
+    cwd: opts.appDirectory,
+    version:
+      opts.version || process.env.MODERN_JS_VERSION || '0.0.0-routes-generate',
+    internalPlugins: (utils as { INTERNAL_RUNTIME_PLUGINS: unknown })
+      .INTERNAL_RUNTIME_PLUGINS as never,
+  });
+  await cli.init({ ...runOptions, command: 'build' });
+}
+
 export default tanstackRouterPlugin;

package/src/runtime/plugin.node.tsx

@@ -357,18 +357,19 @@ export const tanstackRouterPlugin = (
         const _basename =
           baseUrl === '/' ? urlJoin(baseUrl, basename || '') : baseUrl;
 
-        const initialHref = createGetSsrHref(request.raw);
+        const rawRequest = request.raw as Request;
+        const initialHref = createGetSsrHref(rawRequest);
         const isRSCNavigation =
-          enableRsc && request.raw.headers.get('x-rsc-tree') === 'true';
+          enableRsc && rawRequest.headers.get('x-rsc-tree') === 'true';
 
         const requestContext = createRequestContext(
           context.ssrContext?.loaderContext,
         ) as RequestContext<Record<string, unknown>>;
 
         const controller = new AbortController();
-        const ssrRequest = new Request(request.raw.url, {
+        const ssrRequest = new Request(rawRequest.url, {
           method: 'GET',
-          headers: request.raw.headers,
+          headers: rawRequest.headers,
           signal: controller.signal,
         });
 
@@ -398,7 +399,7 @@ export const tanstackRouterPlugin = (
           history,
           basepath: '/',
           rewrite,
-          origin: new URL(request.raw.url).origin,
+          origin: new URL(rawRequest.url).origin,
           ssr: { nonce },
           context: routerContext as never,
           ...(serializationAdapters ? { serializationAdapters } : {}),
@@ -439,7 +440,11 @@ export const tanstackRouterPlugin = (
 
         const routerErrors = collectRouterErrors(tanstackRouter);
         if (routerErrors && loaderFailureMode === 'clientRender') {
-          context.ssrContext?.response.status(200);
+          (
+            context.ssrContext?.response as
+              | { status: (code: number) => void }
+              | undefined
+          )?.status(200);
           try {
             serverRouter.serverSsr?.cleanup?.();
           } catch {}
@@ -448,7 +453,11 @@ export const tanstackRouterPlugin = (
 
         await preloadMatchedRouteComponents(serverRouter);
 
-        context.ssrContext?.response.status(tanstackRouter.state.statusCode);
+        (
+          context.ssrContext?.response as
+            | { status: (code: number) => void }
+            | undefined
+        )?.status(tanstackRouter.state.statusCode);
 
         await serverRouter.serverSsr?.dehydrate?.();
 

package/src/runtime/prefetchLink.tsx

@@ -2,9 +2,9 @@ import {
   type AnyRouter,
   type LinkComponentProps,
   type RegisteredRouter,
-  Link as TanStackLink,
+  useLinkProps,
 } from '@tanstack/react-router';
-import type { ReactElement } from 'react';
+import type { AnchorHTMLAttributes, ReactElement, ReactNode, Ref } from 'react';
 
 export type PrefetchBehavior = 'intent' | 'render' | 'viewport' | 'none';
 
@@ -65,21 +65,84 @@ type LinkComponentImplProps = LinkProps<
   string | undefined,
   string,
   string
->;
+> & { ref?: Ref<HTMLAnchorElement> };
 
 const LinkComponentImpl = (props: LinkComponentImplProps) => {
-  const { prefetch, preload, ...rest } = props;
-  return (
-    <TanStackLink
-      {...rest}
-      preload={
-        resolvePreloadFromPrefetch(
-          prefetch,
-          preload,
-        ) as LinkComponentImplProps['preload']
-      }
-    />
-  );
+  const {
+    prefetch,
+    preload,
+    'aria-current': ariaCurrentProp,
+    ref,
+    children,
+    ...rest
+  } = props as LinkComponentImplProps & {
+    children?:
+      | ReactNode
+      | ((state: { isActive: boolean; isTransitioning: boolean }) => ReactNode);
+  };
+  const hasAriaCurrentOverride = 'aria-current' in props;
+
+  // Children are rendered by us, not by useLinkProps() — the hook filters
+  // unknown/function props out of its return value, so anything routed
+  // through it would be silently dropped.
+  const linkOptions = {
+    ...rest,
+    preload: resolvePreloadFromPrefetch(
+      prefetch,
+      preload,
+    ) as LinkComponentImplProps['preload'],
+  } as LinkComponentImplProps;
+
+  // TanStack Router's useLinkProps() unconditionally spreads
+  // STATIC_ACTIVE_PROPS = { "data-status": "active", "aria-current": "page" }
+  // as the LAST entry of the props object it returns for an active link
+  // (@tanstack/react-router dist/esm/link.js:369 `...isActive &&
+  // STATIC_ACTIVE_PROPS`, defined at line 379-382, spread after
+  // `...propsSafeToSpread`, `...resolvedActiveProps`, and
+  // `...resolvedInactiveProps`). That means any caller-supplied aria-current
+  // -- whether passed directly or via activeProps -- is always clobbered by
+  // the time <Link>/createLink render the anchor; there is no props-merge
+  // order that lets a caller win from inside <Link>. So instead of
+  // delegating rendering to <Link>, we call useLinkProps() ourselves and
+  // re-apply the caller's original aria-current (including `false`, meaning
+  // "suppress the attribute entirely") as the final word on the anchor we
+  // render.
+  const linkProps = useLinkProps(
+    linkOptions as Parameters<typeof useLinkProps>[0],
+    ref as Parameters<typeof useLinkProps>[1],
+  ) as AnchorHTMLAttributes<HTMLAnchorElement> & {
+    disabled?: boolean;
+    type?: string;
+  };
+
+  // TanStack's own Link strips `type` and `disabled` before rendering the
+  // anchor (link.js:449-452) — mirror that.
+  const { disabled: _disabled, type: _type, ...anchorProps } = linkProps;
+
+  if (hasAriaCurrentOverride) {
+    if (ariaCurrentProp === false || typeof ariaCurrentProp === 'undefined') {
+      delete anchorProps['aria-current'];
+    } else {
+      anchorProps['aria-current'] = ariaCurrentProp;
+    }
+  }
+
+  // TanStack's Link resolves render-prop children with the active state
+  // (link.js:450) — without this, function children reach React as an
+  // invalid child and crash the render.
+  const resolvedChildren =
+    typeof children === 'function'
+      ? children({
+          isActive:
+            (anchorProps as Record<string, unknown>)['data-status'] ===
+            'active',
+          isTransitioning:
+            (anchorProps as Record<string, unknown>)['data-transitioning'] ===
+            'transitioning',
+        })
+      : children;
+
+  return <a {...anchorProps}>{resolvedChildren}</a>;
 };
 
 export const Link = LinkComponentImpl as LinkComponent;

package/tests/router/cli.test.ts

@@ -6,6 +6,7 @@ import type { Entrypoint } from '@modern-js/types';
 import { fs, NESTED_ROUTE_SPEC_FILE } from '@modern-js/utils';
 import {
   createTanstackRsbuildRouteSplittingProfile,
+  generateTanstackRouteArtifacts,
   tanstackRouterPlugin,
   writeTanstackRegisterFile,
   writeTanstackRouterTypesForEntries,
@@ -977,3 +978,9 @@ describe('tanstack router cli plugin', () => {
     });
   });
 });
+
+describe('generateTanstackRouteArtifacts export', () => {
+  test('is exported as a function', () => {
+    expect(typeof generateTanstackRouteArtifacts).toBe('function');
+  });
+});

package/tests/router/generateRouteArtifacts.test.ts

@@ -0,0 +1,61 @@
+// Behavioral coverage for the headless routes-generate entry point: the
+// export-shape test in cli.test.ts would pass even if the body were
+// reverted, so this file pins the actual prepare-only drive contract —
+// createRunOptions against the app dir, cli.init with build-command
+// semantics, and the MODERN_ARGV gate that makes analyze.onPrepare fire
+// generateEntryCode.
+const createRunOptionsMock = rstest.fn(async (options: unknown) => ({
+  mockRunOptions: true,
+  received: options,
+}));
+const cliInitMock = rstest.fn(async (options: unknown) => ({
+  appContext: {},
+  received: options,
+}));
+
+rstest.mock('@modern-js/app-tools/cli/run', () => ({
+  createRunOptions: createRunOptionsMock,
+}));
+rstest.mock('@modern-js/plugin/cli', () => ({
+  cli: { init: cliInitMock },
+}));
+
+import { INTERNAL_RUNTIME_PLUGINS } from '@modern-js/utils';
+import { generateTanstackRouteArtifacts } from '../../src/cli';
+
+describe('generateTanstackRouteArtifacts (headless routes-generate)', () => {
+  it('drives a prepare-only cli.init with build-command semantics', async () => {
+    const previousArgv = process.env.MODERN_ARGV;
+
+    try {
+      await generateTanstackRouteArtifacts({
+        appDirectory: '/workspace/apps/shell',
+        version: '9.9.9-test',
+      });
+
+      expect(createRunOptionsMock).toHaveBeenCalledTimes(1);
+      const runOptionsArg = createRunOptionsMock.mock.calls[0][0] as Record<
+        string,
+        unknown
+      >;
+      expect(runOptionsArg.cwd).toBe('/workspace/apps/shell');
+      expect(runOptionsArg.version).toBe('9.9.9-test');
+      expect(runOptionsArg.internalPlugins).toBe(INTERNAL_RUNTIME_PLUGINS);
+
+      expect(cliInitMock).toHaveBeenCalledTimes(1);
+      const initArg = cliInitMock.mock.calls[0][0] as Record<string, unknown>;
+      expect(initArg.command).toBe('build');
+      expect(initArg.mockRunOptions).toBe(true);
+
+      // checkIsBuildCommands() resolves the command from MODERN_ARGV — this
+      // is what lets analyze.onPrepare fire generateEntryCode headlessly.
+      expect(process.env.MODERN_ARGV).toBe('node modern build');
+    } finally {
+      if (previousArgv === undefined) {
+        delete process.env.MODERN_ARGV;
+      } else {
+        process.env.MODERN_ARGV = previousArgv;
+      }
+    }
+  });
+});

package/tests/router/prefetchLink.test.tsx

@@ -1,79 +1,126 @@
-import { render } from '@testing-library/react';
+import { createMemoryHistory } from '@tanstack/history';
+import {
+  createRootRoute,
+  createRoute,
+  createRouter,
+  RouterProvider,
+} from '@tanstack/react-router';
+import { render, waitFor } from '@testing-library/react';
 import React from 'react';
 import { Link, NavLink } from '../../src/runtime/prefetchLink';
 
-type MockLinkProps = {
-  children?: React.ReactNode;
-  preload?: unknown;
-};
-
-let capturedPreloads: unknown[] = [];
-
-rstest.mock('@tanstack/react-router', () => ({
-  Link: (props: MockLinkProps) => {
-    capturedPreloads.push(props.preload);
-    return <a href="/settings">{props.children}</a>;
-  },
-}));
-
-describe('tanstack prefetch link adapter', () => {
-  beforeEach(() => {
-    capturedPreloads = [];
+// Real-router harness (no module mocking): STATIC_ACTIVE_PROPS (the
+// TanStack behavior this adapter works around) is injected by
+// useLinkProps() based on live route match state, which a mocked
+// useLinkProps() cannot reproduce faithfully. We tried spying on
+// useLinkProps via rstest.mock()+importActual while re-exporting the rest
+// of the module untouched, but rstest's module-mock hoisting resolves the
+// "actual" import for a module through its own in-progress mock
+// registration, so every named export (createRootRoute included) comes
+// back undefined -- see the sibling prefetchLinkPreload.test.tsx file for
+// the fully-mocked preload-mapping coverage instead. This file renders
+// through an actual createRouter()/RouterProvider tree with in-memory
+// history so the active/inactive aria-current behavior is exercised for
+// real.
+function buildRouter(options: {
+  initialPath: string;
+  linkProps?: Record<string, unknown>;
+  useNavLink?: boolean;
+  children?:
+    | React.ReactNode
+    | ((state: { isActive: boolean }) => React.ReactNode);
+}) {
+  // The Link lives on the always-rendered root component (not a route
+  // that's only matched at "/settings") so the "inactive link" case -
+  // sitting at "/" while linking to "/settings" - actually mounts it.
+  const rootRoute = createRootRoute({
+    component: () => {
+      const Component = options.useNavLink ? NavLink : Link;
+      return (
+        <Component to="/settings" {...(options.linkProps ?? {})}>
+          {options.children ?? 'Settings'}
+        </Component>
+      );
+    },
   });
-
-  it('defaults TanStack preload to viewport', () => {
-    render(<Link to="/settings">Settings</Link>);
-
-    expect(capturedPreloads).toEqual(['viewport']);
+  const homeRoute = createRoute({
+    getParentRoute: () => rootRoute,
+    path: '/',
+    component: () => null,
+  });
+  const settingsRoute = createRoute({
+    getParentRoute: () => rootRoute,
+    path: '/settings',
+    component: () => null,
   });
 
-  it('preserves explicit preload', () => {
-    render(
-      <Link to="/settings" prefetch="render" preload="intent">
-        Settings
-      </Link>,
-    );
+  const routeTree = rootRoute.addChildren([homeRoute, settingsRoute]);
 
-    expect(capturedPreloads).toEqual(['intent']);
+  return createRouter({
+    routeTree,
+    history: createMemoryHistory({ initialEntries: [options.initialPath] }),
+  });
+}
+
+async function renderLink(options: Parameters<typeof buildRouter>[0]) {
+  const router = buildRouter(options);
+  const utils = render(<RouterProvider router={router} />);
+
+  const anchor = await waitFor(() => {
+    const found = utils.container.querySelector('a[href="/settings"]');
+    if (!found) {
+      throw new Error('anchor not rendered yet');
+    }
+    return found as HTMLAnchorElement;
   });
 
-  it('preserves explicit disabled preload', () => {
-    render(
-      <Link to="/settings" prefetch="render" preload={false}>
-        Settings
-      </Link>,
-    );
+  return { anchor, ...utils };
+}
 
-    expect(capturedPreloads).toEqual([false]);
+describe('tanstack prefetch link adapter - aria-current override', () => {
+  it('defaults active link to aria-current="page" when caller passes nothing', async () => {
+    const { anchor } = await renderLink({ initialPath: '/settings' });
+    expect(anchor.getAttribute('aria-current')).toBe('page');
   });
 
-  it('maps none prefetch to disabled TanStack preload', () => {
-    render(
-      <Link to="/settings" prefetch="none">
-        Settings
-      </Link>,
-    );
-
-    expect(capturedPreloads).toEqual([false]);
+  it('lets caller aria-current="true" win over the TanStack-forced value', async () => {
+    const { anchor } = await renderLink({
+      initialPath: '/settings',
+      linkProps: { 'aria-current': 'true' },
+    });
+    expect(anchor.getAttribute('aria-current')).toBe('true');
+    expect(anchor.outerHTML.match(/aria-current=/g)).toHaveLength(1);
   });
 
-  it.each([
-    'intent',
-    'render',
-    'viewport',
-  ] as const)('maps %s prefetch to TanStack preload', prefetch => {
-    render(
-      <Link to="/settings" prefetch={prefetch}>
-        Settings
-      </Link>,
-    );
+  it('suppresses aria-current entirely when caller passes false', async () => {
+    const { anchor } = await renderLink({
+      initialPath: '/settings',
+      linkProps: { 'aria-current': false },
+    });
+    expect(anchor.hasAttribute('aria-current')).toBe(false);
+  });
 
-    expect(capturedPreloads).toEqual([prefetch]);
+  it('leaves an inactive link untouched when caller passes nothing', async () => {
+    const { anchor } = await renderLink({ initialPath: '/' });
+    expect(anchor.hasAttribute('aria-current')).toBe(false);
+    expect(anchor.getAttribute('data-status')).not.toBe('active');
   });
 
-  it('defaults NavLink preload to viewport', () => {
-    render(<NavLink to="/settings">Settings</NavLink>);
+  it('resolves render-prop children with the active state like TanStack Link', async () => {
+    const { anchor } = await renderLink({
+      initialPath: '/settings',
+      children: ({ isActive }: { isActive: boolean }) =>
+        isActive ? 'Active settings' : 'Settings',
+    });
+    expect(anchor.textContent).toBe('Active settings');
+  });
 
-    expect(capturedPreloads).toEqual(['viewport']);
+  it('resolves render-prop children as inactive on a non-matching route', async () => {
+    const { anchor } = await renderLink({
+      initialPath: '/',
+      children: ({ isActive }: { isActive: boolean }) =>
+        isActive ? 'Active settings' : 'Settings',
+    });
+    expect(anchor.textContent).toBe('Settings');
   });
 });

package/tests/router/prefetchLinkPreload.test.tsx

@@ -0,0 +1,85 @@
+import { render } from '@testing-library/react';
+import React from 'react';
+import { Link, NavLink } from '../../src/runtime/prefetchLink';
+
+type CapturedOptions = {
+  preload?: unknown;
+};
+
+type MockLinkAnchorProps = Record<string, unknown> & {
+  href?: string;
+  ref?: unknown;
+};
+
+let capturedOptions: CapturedOptions[] = [];
+let mockReturnProps: MockLinkAnchorProps = { href: '/settings' };
+
+rstest.mock('@tanstack/react-router', () => ({
+  useLinkProps: (options: CapturedOptions) => {
+    capturedOptions.push(options);
+    return mockReturnProps;
+  },
+}));
+
+describe('tanstack prefetch link adapter - preload mapping', () => {
+  beforeEach(() => {
+    capturedOptions = [];
+    mockReturnProps = { href: '/settings' };
+  });
+
+  it('defaults TanStack preload to viewport', () => {
+    render(<Link to="/settings">Settings</Link>);
+
+    expect(capturedOptions.map(o => o.preload)).toEqual(['viewport']);
+  });
+
+  it('preserves explicit preload', () => {
+    render(
+      <Link to="/settings" prefetch="render" preload="intent">
+        Settings
+      </Link>,
+    );
+
+    expect(capturedOptions.map(o => o.preload)).toEqual(['intent']);
+  });
+
+  it('preserves explicit disabled preload', () => {
+    render(
+      <Link to="/settings" prefetch="render" preload={false}>
+        Settings
+      </Link>,
+    );
+
+    expect(capturedOptions.map(o => o.preload)).toEqual([false]);
+  });
+
+  it('maps none prefetch to disabled TanStack preload', () => {
+    render(
+      <Link to="/settings" prefetch="none">
+        Settings
+      </Link>,
+    );
+
+    expect(capturedOptions.map(o => o.preload)).toEqual([false]);
+  });
+
+  it.each([
+    'intent',
+    'render',
+    'viewport',
+  ] as const)('maps %s prefetch to TanStack preload', prefetch => {
+    render(
+      <Link to="/settings" prefetch={prefetch}>
+        Settings
+      </Link>,
+    );
+
+    expect(capturedOptions.map(o => o.preload)).toEqual([prefetch]);
+  });
+
+  it('defaults NavLink preload to viewport', () => {
+    render(<NavLink to="/settings">Settings</NavLink>);
+
+    expect(capturedOptions.map(o => o.preload)).toEqual(['viewport']);
+  });
+});