@bleedingdev/modern-js-plugin-tanstack 3.5.0-ultramodern.3 → 3.5.0-ultramodern.31

package/dist/types/runtime/rsc/payloadRouter.d.ts

@@ -1,12 +1,6 @@
 import type { ServerPayload } from '@modern-js/runtime/context';
-type PayloadDecoder = (stream: ReadableStream<Uint8Array>) => Promise<unknown>;
-type TanstackPayloadRouterLike = {
-    state?: {
-        location?: unknown;
-        matches?: unknown;
-        statusCode?: unknown;
-    };
-};
+import type { TanstackPayloadRouterLike } from './payloadRoutes';
+export { __setTanstackRscPayloadDecoderForTests } from './payloadFetch';
 type LoadRouteDataOptions = {
     hasClientLoader?: boolean;
     loadClientData: () => Promise<unknown>;
@@ -20,5 +14,3 @@ export declare function handleTanstackRscRedirect(headers: Headers, basename: st
 export declare function isTanstackRscPayloadNavigationEnabled(): boolean;
 export declare function loadTanstackRscPayload(request: Request): Promise<ServerPayload>;
 export declare function loadTanstackRscRouteData({ hasClientLoader, loadClientData, request, routeId, }: LoadRouteDataOptions): Promise<unknown>;
-export declare function __setTanstackRscPayloadDecoderForTests(decoder?: PayloadDecoder): void;
-export {};

package/dist/types/runtime/rsc/payloadRoutes.d.ts

@@ -0,0 +1,43 @@
+import type { PayloadRoute, ServerPayload } from '@modern-js/runtime/context';
+export type RouterStaticData = {
+    modernRouteAction?: unknown;
+    modernRouteHandle?: unknown;
+    modernRouteHasAction?: unknown;
+    modernRouteHasClientLoader?: unknown;
+    modernRouteHasLoader?: unknown;
+    modernRouteId?: unknown;
+    modernRouteIsClientComponent?: unknown;
+};
+export type RouterRouteLike = {
+    id?: unknown;
+    options?: {
+        index?: unknown;
+        path?: unknown;
+        staticData?: RouterStaticData;
+    };
+    parentRoute?: RouterRouteLike;
+};
+export type RouterMatchLike = {
+    error?: unknown;
+    id?: unknown;
+    loaderData?: unknown;
+    params?: unknown;
+    pathname?: unknown;
+    pathnameBase?: unknown;
+    route?: RouterRouteLike;
+    routeId?: unknown;
+};
+export type TanstackPayloadRouterLike = {
+    state?: {
+        location?: unknown;
+        matches?: unknown;
+        statusCode?: unknown;
+    };
+};
+export declare function toPlainRecord(value: unknown): Record<string, unknown>;
+export declare function toPlainLocation(location: unknown): ServerPayload['location'];
+export declare function getRouteId(match: RouterMatchLike): string | undefined;
+export declare function getRouteStaticData(match: RouterMatchLike): RouterStaticData;
+export declare function getRouteParentId(match: RouterMatchLike): string | undefined;
+export declare function toRoutePath(match: RouterMatchLike): string | undefined;
+export declare function toPayloadRoute(match: RouterMatchLike): PayloadRoute | undefined;

package/dist/types/runtime/rsc/payloadStorage.d.ts

@@ -0,0 +1,5 @@
+import type { ServerPayload } from '@modern-js/runtime/context';
+import type { TanstackRouterWithServerSsr } from '../ssrTypes';
+export declare const setTanstackRscServerPayload: (payload: ServerPayload) => void;
+export declare const setTanstackRscRouter: (router: TanstackRouterWithServerSsr) => void;
+export declare const getTanstackRscRouter: () => TanstackRouterWithServerSsr | undefined;

package/dist/types/runtime/rsc/shared.d.ts

@@ -0,0 +1,19 @@
+import type React from 'react';
+import { type AnyCompositeComponent, type AnyRenderableServerComponent, type RscSlotUsageEvent } from './symbols';
+export declare const TANSTACK_RSC_FLIGHT_VALUE = "__modernTanstackRsc";
+export type SerializedTanstackRscFlightValue = {
+    [TANSTACK_RSC_FLIGHT_VALUE]: true;
+    kind: 'renderable' | 'composite';
+    slotUsagesStream?: ReadableStream<RscSlotUsageEvent>;
+    stream: ReadableStream<Uint8Array>;
+};
+export declare function isSerializedTanstackRscFlightValue(value: unknown): value is SerializedTanstackRscFlightValue;
+export declare function EmptyFallback(): null;
+export declare function selectTreePath(tree: unknown, path: string[]): React.ReactNode;
+type RenderSelectedTreeSource = AnyRenderableServerComponent | AnyCompositeComponent;
+type RenderSelectedTreeOptions = {
+    getTree?: (() => unknown) | undefined;
+    missingTreeError: string;
+};
+export declare function renderSelectedTree(src: RenderSelectedTreeSource, { getTree, missingTreeError, }: RenderSelectedTreeOptions): React.ReactNode;
+export {};

package/dist/types/runtime/rsc/treeGetter.d.ts

@@ -0,0 +1 @@
+export declare function createTreeGetterFromFlightStream(stream: ReadableStream<Uint8Array>): () => any;

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

@@ -0,0 +1,7 @@
+import type { AnyRouter } from '@tanstack/react-router';
+import type { TanstackRouterWithServerSsr } from './ssrTypes';
+export declare function waitForRouterSerialization(tanstackRouter: TanstackRouterWithServerSsr): Promise<void>;
+export declare function routerManagedTagsToHtml(tags: unknown): string[];
+export declare function createGetSsrHref(request: Request): string;
+export declare function collectRouterErrors(tanstackRouter: AnyRouter): Record<string, unknown> | undefined;
+export declare function attachServerSsrUtils(router: TanstackRouterWithServerSsr): Promise<void>;

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

@@ -0,0 +1,2 @@
+import type { TanstackRouterWithServerSsr } from './ssrTypes';
+export declare function preloadMatchedRouteComponents(tanstackRouter: TanstackRouterWithServerSsr): Promise<void>;

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

@@ -0,0 +1,43 @@
+import type { RequestContext } from '@modern-js/runtime-utils/node';
+import type { AnyRouter } from '@tanstack/react-router';
+export type ModernTanstackRouterContext = {
+    request: Request;
+    requestContext: RequestContext<Record<string, unknown>>;
+};
+export type RouterManagedTag = {
+    attrs?: Record<string, unknown>;
+    children?: unknown;
+    tag?: unknown;
+};
+export type RouterMatchWithError = {
+    error?: unknown;
+    route?: {
+        id?: unknown;
+        options?: RouterRouteOptions;
+    };
+    routeId?: unknown;
+};
+export type RouterRouteOptions = {
+    component?: unknown;
+    errorComponent?: unknown;
+    notFoundComponent?: unknown;
+    pendingComponent?: unknown;
+};
+export type RouterRouteWithOptions = {
+    options?: RouterRouteOptions;
+};
+export type TanstackRouterWithServerSsr = AnyRouter & {
+    resolveRedirect?: (redirect: Response) => Response;
+    routesById?: Record<string, RouterRouteWithOptions>;
+    serverSsr?: {
+        cleanup?: () => void;
+        dehydrate?: () => Promise<void> | void;
+        isSerializationFinished?: () => boolean;
+        onSerializationFinished?: (listener: () => void) => void;
+        takeBufferedScripts?: () => unknown;
+    };
+    state: AnyRouter['state'] & {
+        matches?: unknown;
+        redirect?: Response;
+    };
+};

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

@@ -1,5 +1,5 @@
+import { type InternalRouterRuntimeState } from '@modern-js/runtime/context';
 import type { AnyRouter } from '@tanstack/react-router';
-import type { InternalRouterRuntimeState } from './types';
 /**
  * Router runtime state as published by the TanStack router provider into the
  * runtime-context extension slot.

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

@@ -0,0 +1,14 @@
+import type { AnyRouter } from '@tanstack/react-router';
+import type { SubmitOptions, SubmitTarget } from './formData';
+export declare class RouteActionResponseError<TData = unknown> extends Error {
+    readonly response: Response;
+    readonly data: TData;
+    constructor(response: Response, data: TData);
+}
+export declare function submitRouteAction({ router, target, options, isFetcher, onInvalidateStart, }: {
+    router: AnyRouter;
+    target: SubmitTarget;
+    options?: SubmitOptions;
+    isFetcher?: boolean;
+    onInvalidateStart?: () => void;
+}): Promise<any>;

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

@@ -1,18 +1,13 @@
-import type { RouterFramework } from '@modern-js/runtime/context';
+import type { ModernRoute, RouterFramework } from '@modern-js/runtime/context';
 import type { RouteObject } from '@modern-js/runtime-utils/router';
-import type { NestedRoute, PageRoute } from '@modern-js/types';
 import type React from 'react';
-export type { BuiltInRouterFramework, InternalRouterRuntimeState, InternalRouterServerSnapshot, RouterFramework, RouterRouteMatchSnapshot, RouterServerPrepareResult, } from '@modern-js/runtime/context';
-/**
- * TanStack-specific router config. Unlike the react-router provider config,
- * this intentionally has no `oldVersion`/`future` fields — those are
- * react-router-only knobs with no meaning here.
- */
+export type { BuiltInRouterFramework, InternalRouterRuntimeState, InternalRouterServerSnapshot, LoaderFunction, LoaderFunctionArgs, ModernRoute, RouterFramework, RouterRouteMatchSnapshot, RouterServerPrepareResult, } from '@modern-js/runtime/context';
+/** TanStack-specific router config. */
 export type RouterConfig = {
     framework?: RouterFramework;
     routesConfig: {
         globalApp?: React.ComponentType<any>;
-        routes?: (NestedRoute | PageRoute)[];
+        routes?: ModernRoute[];
     };
     serverBase?: string[];
     supportHtml5History?: boolean;

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

@@ -1,36 +1,16 @@
 import type { RouteObject } from '@modern-js/runtime-utils/router';
-import type { NestedRoute, PageRoute, SSRMode } from '@modern-js/types';
 import React from 'react';
+import type { ModernRoute } from './types';
+export type SSRMode = 'string' | 'stream';
 type RouterConfig = {
     routesConfig: {
         globalApp?: React.ComponentType<any>;
-        routes?: (NestedRoute | PageRoute)[];
+        routes?: ModernRoute[];
     };
 };
-type GlobalAppProps = {
-    Component: React.ComponentType;
-    [key: string]: unknown;
-};
-export type ModernRouteObject = RouteObject & {
-    isClientComponent?: boolean;
-    hasClientLoader?: boolean;
-    hasLoader?: boolean;
-    hasAction?: boolean;
-    inValidSSRRoute?: boolean;
-    lazyImport?: () => Promise<{
-        default: React.ComponentType;
-    }>;
-};
-export declare function getRouteObjects(routes: (NestedRoute | PageRoute)[], { globalApp, ssrMode, props, }: {
-    globalApp?: React.ComponentType<GlobalAppProps>;
-    ssrMode?: SSRMode;
-    props?: Record<string, unknown>;
-}): RouteObject[];
-export declare function createRouteObjectsFromConfig({ routesConfig, props, ssrMode, }: {
+export declare function createTanstackRouteObjectsFromConfig({ routesConfig, }: {
     routesConfig: RouterConfig['routesConfig'];
     props?: Record<string, unknown>;
     ssrMode?: SSRMode;
 }): RouteObject[] | null;
-export declare const urlJoin: (...parts: string[]) => string;
-export declare function standardSlash(str: string): string;
 export {};

package/package.json

@@ -18,7 +18,7 @@
     "modern.js",
     "tanstack-router"
   ],
-  "version": "3.5.0-ultramodern.3",
+  "version": "3.5.0-ultramodern.31",
   "engines": {
     "node": ">=20"
   },
@@ -55,6 +55,20 @@
         "module": "./dist/esm/runtime/router.mjs"
       },
       "default": "./dist/esm/runtime/router.mjs"
+    },
+    "./runtime/rsc/client": {
+      "types": "./dist/types/runtime/rsc/client.d.ts",
+      "node": {
+        "module": "./dist/esm/runtime/rsc/client.mjs"
+      },
+      "default": "./dist/esm/runtime/rsc/client.mjs"
+    },
+    "./runtime/rsc/server": {
+      "types": "./dist/types/runtime/rsc/server.d.ts",
+      "node": {
+        "module": "./dist/esm/runtime/rsc/server.mjs"
+      },
+      "default": "./dist/esm/runtime/rsc/server.mjs"
     }
   },
   "typesVersions": {
@@ -70,6 +84,12 @@
       ],
       "runtime/router": [
         "./dist/types/runtime/router.d.ts"
+      ],
+      "runtime/rsc/client": [
+        "./dist/types/runtime/rsc/client.d.ts"
+      ],
+      "runtime/rsc/server": [
+        "./dist/types/runtime/rsc/server.d.ts"
       ]
     }
   },
@@ -77,13 +97,15 @@
     "@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.3",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.3",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.3",
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.5.0-ultramodern.3"
+    "react-server-dom-rspack": "0.0.2",
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.5.0-ultramodern.31",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.31",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.31",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.5.0-ultramodern.31"
   },
   "peerDependencies": {
-    "@modern-js/runtime": "3.5.0-ultramodern.3",
+    "@modern-js/app-tools": "3.5.0-ultramodern.31",
+    "@modern-js/runtime": "3.5.0-ultramodern.31",
     "react": "^19.2.7",
     "react-dom": "^19.2.7"
   },
@@ -98,8 +120,8 @@
     "@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.3",
-    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.5.0-ultramodern.3",
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.5.0-ultramodern.31",
+    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.5.0-ultramodern.31",
     "@scripts/rstest-config": "2.66.0"
   },
   "sideEffects": [

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',
@@ -32,6 +33,7 @@ export default {
         'tests/router/register.test.ts',
         'tests/router/routeHooks.test.ts',
         'tests/router/rsc.test.tsx',
+        'tests/router/ssrPreload.test.ts',
         'tests/router/tanstackTypes.test.ts',
         'tests/router/routeTree.test.ts',
       ],
@@ -44,6 +46,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/artifacts.ts

@@ -0,0 +1,255 @@
+// @effect-diagnostics asyncFunction:off nodeBuiltinImport:off strictBooleanExpressions:off processEnv:off processEnvInEffect:off
+
+import path from 'node:path';
+import type { AppToolsContext } from '@modern-js/app-tools';
+import type { NestedRouteForCli, PageRoute } from '@modern-js/types';
+import { fs } from '@modern-js/utils';
+
+import {
+  collectCanonicalRoutesForEntry,
+  generateTanstackRouterTypesSourceForEntry,
+} from './tanstackTypes';
+
+const DEFAULT_GENERATED_DIR_NAME = 'modern-tanstack';
+
+async function writeFileIfChanged(filePath: string, content: string) {
+  try {
+    const previous = (await fs.pathExists(filePath))
+      ? await fs.readFile(filePath, 'utf-8')
+      : null;
+    if (previous === content) {
+      return;
+    }
+  } catch {
+    // Fall through and rewrite the generated file.
+  }
+
+  await fs.outputFile(filePath, content, 'utf-8');
+}
+
+function createRegisterDtsContent(opts: {
+  entries: string[];
+  runtimeModule: string;
+  canonicalRoutes?: Record<string, string> | null;
+  i18nRuntimeModule?: string;
+}) {
+  const importStatements = opts.entries
+    .map(
+      (entryName, index) =>
+        `import type { router as router${index} } from './${entryName}/router.gen';`,
+    )
+    .join('\n');
+  const routerUnionType = opts.entries
+    .map((_, index) => `typeof router${index}`)
+    .join(' | ');
+
+  const canonicalEntries = Object.entries(opts.canonicalRoutes ?? {});
+  const canonicalRoutesAugmentation =
+    canonicalEntries.length > 0
+      ? `
+declare module '${opts.i18nRuntimeModule || '@modern-js/plugin-i18n/runtime'}' {
+  interface UltramodernCanonicalRoutes {
+${canonicalEntries
+  .map(([routePath, paramsType]) => `    '${routePath}': ${paramsType};`)
+  .join('\n')}
+  }
+}
+`
+      : '';
+
+  return `// This file is auto-generated by Modern.js. Do not edit manually.
+
+${importStatements}
+
+declare module '${opts.runtimeModule}' {
+  interface Register {
+    router: ${routerUnionType};
+  }
+}
+${canonicalRoutesAugmentation}`;
+}
+
+export async function writeTanstackRegisterFile(opts: {
+  entries: string[];
+  generatedDirName?: string;
+  runtimeModule?: string;
+  srcDirectory: string;
+  canonicalRoutes?: Record<string, string> | null;
+  i18nRuntimeModule?: string;
+}) {
+  const {
+    entries,
+    generatedDirName = DEFAULT_GENERATED_DIR_NAME,
+    runtimeModule = '@modern-js/plugin-tanstack/runtime',
+    srcDirectory,
+    canonicalRoutes,
+    i18nRuntimeModule,
+  } = opts;
+
+  if (entries.length === 0) {
+    return;
+  }
+
+  const registerDtsPath = path.join(
+    srcDirectory,
+    generatedDirName,
+    'register.gen.d.ts',
+  );
+
+  await writeFileIfChanged(
+    registerDtsPath,
+    createRegisterDtsContent({
+      entries,
+      runtimeModule,
+      canonicalRoutes,
+      i18nRuntimeModule,
+    }),
+  );
+}
+
+export async 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;
+}) {
+  const {
+    appContext,
+    generatedDirName = DEFAULT_GENERATED_DIR_NAME,
+    routesByEntry,
+    i18nPluginInstalled = false,
+  } = opts;
+
+  const entryNames = Object.keys(routesByEntry);
+
+  await Promise.all(
+    entryNames.map(async entryName => {
+      const { routerGenTs } = await generateTanstackRouterTypesSourceForEntry({
+        appContext,
+        entryName,
+        generatedDirName,
+        routes: routesByEntry[entryName],
+      });
+
+      await writeFileIfChanged(
+        path.join(
+          appContext.srcDirectory,
+          generatedDirName,
+          entryName,
+          'router.gen.ts',
+        ),
+        routerGenTs,
+      );
+    }),
+  );
+
+  const mainEntryName = appContext.entrypoints?.find(
+    entrypoint => entrypoint.isMainEntry,
+  )?.entryName;
+  const registerEntries = entryNames.sort((a, b) => {
+    if (mainEntryName && a === mainEntryName) {
+      return -1;
+    }
+
+    if (mainEntryName && b === mainEntryName) {
+      return 1;
+    }
+
+    return a.localeCompare(b);
+  });
+
+  // Merge the canonical (language-agnostic) route maps of every entry so the
+  // typed i18n Link covers all routes the app can navigate to. Only relevant
+  // when plugin-i18n is actually installed — without it the emitted module
+  // augmentation would reference an unresolvable module.
+  let canonicalRoutes: Record<string, string> | null = null;
+  if (i18nPluginInstalled) {
+    for (const entryName of registerEntries) {
+      const entryCanonicalRoutes = collectCanonicalRoutesForEntry(
+        routesByEntry[entryName],
+        { localeParamHeuristic: true },
+      );
+      if (entryCanonicalRoutes) {
+        canonicalRoutes = {
+          ...entryCanonicalRoutes,
+          ...(canonicalRoutes ?? {}),
+        };
+      }
+    }
+  }
+
+  await writeTanstackRegisterFile({
+    entries: registerEntries,
+    generatedDirName,
+    srcDirectory: appContext.srcDirectory,
+    canonicalRoutes,
+  });
+}
+
+/**
+ * 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';
+
+  // Resolve the app's Modern.js config file ourselves and pass it as an
+  // absolute base path. `createRunOptions` otherwise defaults its config lookup
+  // to `process.cwd()` (not `cwd`/appDirectory), so headless invocations that
+  // run from a different directory than the app — e.g. the create CLI spawning
+  // this from the workspace root — find no config, and `findExists` returns
+  // `false`. That `false` then flows into `cli.init` -> `getConfigFilePath` ->
+  // `path.isAbsolute(false)`, throwing the opaque
+  // `The "path" argument must be of type string. Received type boolean (false)`.
+  // Passing an absolute base is resolution-based: cwd no longer matters, and the
+  // downstream `getConfigFile` still appends the correct extension.
+  const { findExists, CONFIG_FILE_EXTENSIONS } = utils as {
+    findExists: (paths: string[]) => string | false;
+    CONFIG_FILE_EXTENSIONS: string[];
+  };
+  const configFileBase = path.resolve(opts.appDirectory, 'modern.config');
+  const resolvedConfigFile = findExists(
+    CONFIG_FILE_EXTENSIONS.map(extension => `${configFileBase}${extension}`),
+  );
+  if (!resolvedConfigFile) {
+    throw new Error(
+      `[plugin-tanstack] Unable to locate a Modern.js config file (modern.config.{${CONFIG_FILE_EXTENSIONS.map(
+        extension => extension.slice(1),
+      ).join(',')}}) in ${opts.appDirectory}. ` +
+        'TanStack route generation requires the app config to resolve its plugins.',
+    );
+  }
+
+  const runOptions = await createRunOptions({
+    cwd: opts.appDirectory,
+    configFile: configFileBase,
+    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' });
+}