@bleedingdev/modern-js-plugin-tanstack 3.8.3-ultramodern.6 → 3.9.0-ultramodern.10

package/tests/router/cli.test.ts

@@ -1,18 +1,12 @@
 import { execFile } from 'node:child_process';
-import { mkdir, mkdtemp, rm } from 'node:fs/promises';
+import { mkdtemp, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { promisify } from 'node:util';
-import { mergeConfig } from '@modern-js/plugin/cli';
+import { compile } from '@modern-js/server-utils';
 import type { Entrypoint } from '@modern-js/types';
-import { fs, NESTED_ROUTE_SPEC_FILE } from '@modern-js/utils';
-import {
-  createTanstackRsbuildRouteSplittingProfile,
-  generateTanstackRouteArtifacts,
-  tanstackRouterPlugin,
-  writeTanstackRegisterFile,
-  writeTanstackRouterTypesForEntries,
-} from '../../src/cli';
+import { fs } from '@modern-js/utils';
+import { tanstackRouterPlugin, writeTanstackRegisterFile } from '../../src/cli';
 
 const execFileAsync = promisify(execFile);
 const strictestTsconfigPath = path.resolve(
@@ -20,11 +14,24 @@ const strictestTsconfigPath = path.resolve(
   '../../node_modules/@tsconfig/strictest/tsconfig.json',
 );
 
+function createAppContextApi<T extends object>(initial: T) {
+  let context: T & { serverCompileExcludedFiles?: string[] } = { ...initial };
+  return {
+    getAppContext: () => context,
+    updateAppContext: (update: Partial<typeof context>) => {
+      context = { ...context, ...update };
+    },
+  };
+}
+
+/**
+ * Compiles the generated registration output with `tsgo` under
+ * @tsconfig/strictest — the way a consumer's own type check would see it.
+ */
 async function typecheckGeneratedRegistration(options: {
   entries: string[];
   generatedDirName: string;
   srcDirectory: string;
-  runtimeModule?: string;
   i18nRuntimeModule?: string;
   canonicalTypeChecks?: string[];
 }) {
@@ -32,10 +39,10 @@ async function typecheckGeneratedRegistration(options: {
     entries,
     generatedDirName,
     srcDirectory,
-    runtimeModule = '@modern-js/plugin-tanstack/runtime',
     i18nRuntimeModule,
     canonicalTypeChecks = [],
   } = options;
+  const runtimeModule = '@modern-js/plugin-tanstack/runtime';
   const projectDirectory = path.dirname(srcDirectory);
 
   for (const entry of entries) {
@@ -64,33 +71,28 @@ async function typecheckGeneratedRegistration(options: {
     '  export function modernLoaderToTanstack<TLoader extends (...args: never[]) => unknown>(options: { hasSplat: boolean }, loader: TLoader): (context: unknown) => Promise<Awaited<ReturnType<TLoader>>>;',
     '  export const modernTanstackRouterFastDefaults: Record<string, unknown>;',
     '}',
+    ...(i18nRuntimeModule
+      ? [
+          `declare module '${i18nRuntimeModule}' { export interface UltramodernCanonicalRoutes {} }`,
+        ]
+      : []),
   ];
-  if (i18nRuntimeModule) {
-    runtimeDeclaration.push(
-      `declare module '${i18nRuntimeModule}' { export interface UltramodernCanonicalRoutes {} }`,
-    );
-  }
   await fs.outputFile(
     path.join(srcDirectory, 'generated-runtime-shim.d.ts'),
     runtimeDeclaration.join('\n'),
   );
 
-  const contractLines = [
-    `import type { Register } from '${runtimeModule}';`,
-    ...entries.map(
-      (entry, index) =>
-        `import { router as router${index} } from './${generatedDirName}/${entry}/router.gen';`,
-    ),
-    ...entries.map(
-      (_, index) =>
-        `const registeredRouter${index}: Register['router'] = router${index};`,
-    ),
-    ...entries.map((_, index) => `void registeredRouter${index};`),
-    ...canonicalTypeChecks,
-  ];
   await fs.outputFile(
     path.join(srcDirectory, 'registration-contract.ts'),
-    contractLines.join('\n'),
+    [
+      `import type { Register } from '${runtimeModule}';`,
+      ...entries.flatMap((entry, index) => [
+        `import { router as router${index} } from './${generatedDirName}/${entry}/router.gen';`,
+        `const registeredRouter${index}: Register['router'] = router${index};`,
+        `void registeredRouter${index};`,
+      ]),
+      ...canonicalTypeChecks,
+    ].join('\n'),
   );
   await fs.outputJSON(path.join(projectDirectory, 'tsconfig.json'), {
     extends: strictestTsconfigPath,
@@ -109,26 +111,16 @@ async function typecheckGeneratedRegistration(options: {
     await execFileAsync(
       process.platform === 'win32' ? 'tsgo.cmd' : 'tsgo',
       ['-p', 'tsconfig.json'],
-      {
-        cwd: projectDirectory,
-        shell: process.platform === 'win32',
-      },
+      { cwd: projectDirectory, shell: process.platform === 'win32' },
     );
-  } catch (error) {
-    if (
-      error &&
-      typeof error === 'object' &&
-      'stdout' in error &&
-      typeof error.stdout === 'string'
-    ) {
-      throw new Error(error.stdout, { cause: error });
-    }
-    throw error;
+  } catch (error: any) {
+    throw typeof error?.stdout === 'string'
+      ? new Error(error.stdout, { cause: error })
+      : error;
   }
 }
 
 const runtimeCliMocks = {
-  handleFileChange: rstest.fn(),
   handleGeneratorEntryCode: rstest.fn(),
 };
 
@@ -151,40 +143,14 @@ rstest.mock('@modern-js/runtime/cli', () => {
         : null),
     getEntrypointRoutesOwner: (entrypoint: any) =>
       entrypoint.__modernRoutesOwner || null,
-    // Forward through arrows: the mock factory is hoisted above the
+    // Forward through an arrow: the mock factory is hoisted above the
     // `runtimeCliMocks` initializer, so it must not dereference it eagerly.
-    handleFileChange: (...args: unknown[]) =>
-      runtimeCliMocks.handleFileChange(...args),
     handleGeneratorEntryCode: (...args: unknown[]) =>
       runtimeCliMocks.handleGeneratorEntryCode(...args),
-    handleModifyEntrypoints: async (
-      entrypoints: Entrypoint[],
-      routesDir = 'routes',
-    ) =>
-      entrypoints.map(entrypoint => {
-        const routesEntry = path.join(entrypoint.absoluteEntryDir!, routesDir);
-        return {
-          ...entrypoint,
-          nestedRoutesEntry: routesEntry,
-          [routesDirMetaKey]: routesDir,
-        };
-      }),
-    isRouteEntry: (dir: string, routesDir = 'routes') => {
-      const routesEntry = path.join(dir, routesDir);
-      return fs.existsSync(routesEntry) ? routesEntry : false;
-    },
-    updateNestedRoutesSpec: async (
-      specPath: string,
-      nextRoutes: Record<string, unknown>,
-    ) => {
-      const existingRoutes = fs.existsSync(specPath)
-        ? await fs.readJSON(specPath)
-        : {};
-      await fs.outputJSON(specPath, {
-        ...existingRoutes,
-        ...nextRoutes,
-      });
-    },
+    handleFileChange: async () => {},
+    handleModifyEntrypoints: async (entrypoints: Entrypoint[]) => entrypoints,
+    isRouteEntry: () => false,
+    updateNestedRoutesSpec: async () => {},
   };
 });
 
@@ -192,264 +158,95 @@ describe('tanstack router cli plugin', () => {
   let tempDir: string | undefined;
 
   afterEach(async () => {
-    runtimeCliMocks.handleFileChange.mockReset();
     runtimeCliMocks.handleGeneratorEntryCode.mockReset();
-
     if (tempDir) {
       await rm(tempDir, { recursive: true, force: true });
       tempDir = undefined;
     }
   });
 
-  test('typechecks plugin-owned routers and register metadata under strictest', async () => {
-    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-cli-'));
-    const srcDirectory = path.join(tempDir, 'src');
-    await mkdir(srcDirectory, { recursive: true });
-
-    await writeTanstackRouterTypesForEntries({
-      appContext: {
-        srcDirectory,
-        internalSrcAlias: '@/_',
-        entrypoints: [
-          { entryName: 'dashboard', isMainEntry: false },
-          { entryName: 'main', isMainEntry: true },
-        ],
-      } as any,
-      generatedDirName: 'generated-router',
-      routesByEntry: {
-        dashboard: [
-          {
-            type: 'nested',
-            id: 'layout',
-            isRoot: true,
-            children: [{ type: 'nested', id: 'page', index: true }],
-          },
-        ],
-        main: [
-          {
-            type: 'nested',
-            id: 'layout',
-            isRoot: true,
-            children: [{ type: 'nested', id: 'page', index: true }],
-          },
-        ],
-      },
-    });
-
-    await typecheckGeneratedRegistration({
-      entries: ['main', 'dashboard'],
-      generatedDirName: 'generated-router',
-      srcDirectory,
-    });
-  });
-
-  test('typechecks register metadata for custom entry lists without routes', async () => {
-    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-cli-'));
-    const srcDirectory = path.join(tempDir, 'src');
-
-    await writeTanstackRegisterFile({
-      entries: ['main'],
-      generatedDirName: 'tanstack',
-      srcDirectory,
-    });
-
-    await typecheckGeneratedRegistration({
-      entries: ['main'],
-      generatedDirName: 'tanstack',
-      srcDirectory,
-    });
-  });
-
-  test('exposes canonical route params through plugin-i18n types', async () => {
-    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-cli-'));
-    const srcDirectory = path.join(tempDir, 'src');
-
-    await writeTanstackRegisterFile({
-      entries: ['main'],
-      generatedDirName: 'tanstack',
-      srcDirectory,
-      canonicalRoutes: {
-        '/': 'Record<string, never>',
-        '/products/$slug': '{ "slug": string }',
-      },
-    });
-
-    await typecheckGeneratedRegistration({
-      entries: ['main'],
-      generatedDirName: 'tanstack',
-      srcDirectory,
-      i18nRuntimeModule: '@modern-js/plugin-i18n/runtime',
-      canonicalTypeChecks: [
-        "import type { UltramodernCanonicalRoutes } from '@modern-js/plugin-i18n/runtime';",
-        "const rootParams: UltramodernCanonicalRoutes['/'] = {};",
-        "const productParams: UltramodernCanonicalRoutes['/products/$slug'] = { slug: 'tractor' };",
-        'void rootParams;',
-        'void productParams;',
-      ],
-    });
-  });
-
-  test('typechecks a plain TanStack register without plugin-i18n installed', async () => {
-    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-cli-'));
-    const srcDirectory = path.join(tempDir, 'src');
-
-    await writeTanstackRegisterFile({
-      entries: ['main'],
-      generatedDirName: 'tanstack',
-      srcDirectory,
-    });
-
-    await typecheckGeneratedRegistration({
-      entries: ['main'],
-      generatedDirName: 'tanstack',
-      srcDirectory,
-    });
-  });
-
-  test('typechecks custom runtime module augmentations', async () => {
-    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-cli-'));
+  test('excludes its generated declaration from server roots only when installed', async () => {
+    tempDir = await fs.realpath(
+      await mkdtemp(path.join(tmpdir(), 'tanstack-server-roots-')),
+    );
     const srcDirectory = path.join(tempDir, 'src');
-
-    await writeTanstackRegisterFile({
-      entries: ['main'],
-      generatedDirName: 'tanstack',
-      runtimeModule: '@my-org/tanstack/runtime',
+    const declaration = path.join(
       srcDirectory,
-      canonicalRoutes: {
-        '/talks': 'Record<string, never>',
-      },
-      i18nRuntimeModule: '@my-org/i18n/runtime',
-    });
-
-    await typecheckGeneratedRegistration({
-      entries: ['main'],
-      generatedDirName: 'tanstack',
-      srcDirectory,
-      runtimeModule: '@my-org/tanstack/runtime',
-      i18nRuntimeModule: '@my-org/i18n/runtime',
-      canonicalTypeChecks: [
-        "import type { UltramodernCanonicalRoutes } from '@my-org/i18n/runtime';",
-        "const talksParams: UltramodernCanonicalRoutes['/talks'] = {};",
-        'void talksParams;',
-      ],
+      'modern-tanstack',
+      'register.gen.d.ts',
+    );
+    const apiDirectory = path.join(tempDir, 'api');
+    const compileOptions = {
+      sourceDirs: [apiDirectory],
+      distDir: path.join(tempDir, 'dist'),
+      tsconfigPath: path.join(tempDir, 'tsconfig.json'),
+      throwErrorInsteadOfExit: true,
+    };
+    await fs.outputJSON(compileOptions.tsconfigPath, {
+      compilerOptions: {
+        module: 'commonjs',
+        target: 'ES2022',
+        types: [],
+        noEmitOnError: true,
+        skipLibCheck: false,
+      },
+      include: ['api', 'src'],
     });
-  });
+    await fs.outputFile(
+      path.join(apiDirectory, 'index.ts'),
+      'export const server = true;\n',
+    );
+    await fs.outputFile(
+      path.join(srcDirectory, 'routes/page.tsx'),
+      "import type { Missing } from 'missing-browser-only-types';\nexport const page: Missing = undefined;\n",
+    );
+    await fs.outputFile(
+      path.join(srcDirectory, 'modern-tanstack', 'main/router.gen.ts'),
+      "import { page } from '../../routes/page';\nexport const router = { page };\n",
+    );
+    await writeTanstackRegisterFile({ entries: ['main'], srcDirectory });
 
-  test('claims custom routes, injects runtime plugin, and merges route specs', async () => {
-    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-cli-'));
-    const srcDirectory = path.join(tempDir, 'src');
-    const distDirectory = path.join(tempDir, 'dist');
-    const entryDir = path.join(srcDirectory, 'main');
-    const viewsDir = path.join(entryDir, 'views');
-    await mkdir(viewsDir, { recursive: true });
+    await expect(compile(tempDir, {}, compileOptions)).rejects.toThrow(
+      /missing-browser-only-types/,
+    );
 
-    const taps: Record<string, any> = {};
+    const previousExclusions = [path.join(tempDir, 'other-client.d.ts')];
     const api = {
-      getAppContext: () => ({
+      ...createAppContextApi({
         srcDirectory,
-        distDirectory,
-        metaName: 'modern-js',
-        serverRoutes: [{ entryName: 'main', urlPath: '/dashboard' }],
+        serverCompileExcludedFiles: previousExclusions,
       }),
-      _internalRuntimePlugins: (tap: any) => {
-        taps.internalRuntimePlugins = tap;
-      },
-      checkEntryPoint: (tap: any) => {
-        taps.checkEntryPoint = tap;
-      },
-      config: (tap: any) => {
-        taps.config = tap;
-      },
-      modifyEntrypoints: (tap: any) => {
-        taps.modifyEntrypoints = tap;
-      },
-      generateEntryCode: (tap: any) => {
-        taps.generateEntryCode = tap;
-      },
-      onFileChanged: (tap: any) => {
-        taps.onFileChanged = tap;
-      },
-      modifyFileSystemRoutes: (tap: any) => {
-        taps.modifyFileSystemRoutes = tap;
-      },
-      onBeforeGenerateRoutes: (tap: any) => {
-        taps.onBeforeGenerateRoutes = tap;
-      },
+      _internalRuntimePlugins: () => {},
+      checkEntryPoint: () => {},
+      config: () => {},
+      modifyEntrypoints: () => {},
+      generateEntryCode: () => {},
+      onFileChanged: () => {},
+      modifyFileSystemRoutes: () => {},
+      onBeforeGenerateRoutes: () => {},
     };
-
-    tanstackRouterPlugin({ routesDir: 'views' }).setup!(api as any);
-
-    expect(taps.checkEntryPoint({ path: entryDir, entry: false })).toEqual({
-      path: entryDir,
-      entry: viewsDir,
-    });
-
-    const { entrypoints } = await taps.modifyEntrypoints({
-      entrypoints: [
-        {
-          entryName: 'main',
-          entry: entryDir,
-          absoluteEntryDir: entryDir,
-          isAutoMount: true,
-          isMainEntry: true,
-        } as Entrypoint,
-      ],
-    });
-    const [entrypoint] = entrypoints;
-    expect(entrypoint.nestedRoutesEntry).toBe(viewsDir);
-
+    tanstackRouterPlugin().setup!(api as never);
+    const excludeFiles = api.getAppContext().serverCompileExcludedFiles;
+    expect(excludeFiles).toEqual([...previousExclusions, declaration]);
+    await compile(tempDir, {}, { ...compileOptions, excludeFiles });
     expect(
-      taps.internalRuntimePlugins({ entrypoint, plugins: [] }).plugins,
-    ).toEqual([
-      {
-        name: 'tanstackRouter',
-        path: '@modern-js/plugin-tanstack/runtime',
-        config: { serverBase: ['/dashboard'] },
-      },
-    ]);
-
-    expect(taps.config()).toMatchObject({
-      output: {
-        splitRouteChunks: true,
-      },
-    });
-
-    const specPath = path.join(distDirectory, NESTED_ROUTE_SPEC_FILE);
-    await fs.outputJSON(specPath, {
-      existing: [{ id: 'keep-me' }],
-    });
-
-    await taps.modifyFileSystemRoutes({
-      entrypoint,
-      routes: [
-        {
-          id: 'main-route',
-          type: 'nested',
-          origin: 'file-system',
-        },
-      ],
-    });
-    await taps.onBeforeGenerateRoutes({ entrypoint, code: '' });
-
-    expect(await fs.readJSON(specPath)).toEqual({
-      existing: [{ id: 'keep-me' }],
-      main: [
-        {
-          id: 'main-route',
-          type: 'nested',
-          origin: 'file-system',
-        },
-      ],
-    });
+      await fs.pathExists(path.join(compileOptions.distDir, 'api/index.js')),
+    ).toBe(true);
+    expect(await fs.pathExists(path.join(compileOptions.distDir, 'src'))).toBe(
+      false,
+    );
   });
 
-  test('injects the framework-resolving router wrapper for non-file-route entrypoints', async () => {
+  test('installs the TanStack router only for entrypoints it owns', () => {
     const taps: Record<string, any> = {};
     const api = {
-      getAppContext: () => ({
+      ...createAppContextApi({
         srcDirectory: '/tmp/app/src',
         metaName: 'modern-js',
-        serverRoutes: [{ entryName: 'custom', urlPath: '/' }],
+        serverRoutes: [
+          { entryName: 'custom', urlPath: '/' },
+          { entryName: 'home', urlPath: '/' },
+        ],
       }),
       _internalRuntimePlugins: (tap: any) => {
         taps.internalRuntimePlugins = tap;
@@ -463,168 +260,70 @@ describe('tanstack router cli plugin', () => {
       onBeforeGenerateRoutes: () => {},
     };
 
-    tanstackRouterPlugin().setup!(api as any);
+    tanstackRouterPlugin({ routesDir: 'ts-routes' }).setup!(api as any);
 
     // Custom entry without a routes dir (e.g. `createRoutes` in
-    // modern.runtime.ts): installing the plugin is the explicit opt-in, no
-    // source sniffing — the wrapper plus the provider registration is
-    // injected through the package's own runtime/router module.
+    // modern.runtime.ts): installing the plugin is the explicit opt-in, so
+    // the wrapper plus the provider registration is injected through the
+    // package's own runtime/router module.
     const customEntrypoint = {
       entryName: 'custom',
       isAutoMount: true,
     } as Entrypoint;
+    const tanstackRouterEntry = {
+      name: 'router',
+      path: '@modern-js/plugin-tanstack/runtime/router',
+      config: { serverBase: ['/'] },
+    };
     expect(
       taps.internalRuntimePlugins({ entrypoint: customEntrypoint, plugins: [] })
         .plugins,
-    ).toEqual([
-      {
-        name: 'router',
-        path: '@modern-js/plugin-tanstack/runtime/router',
-        config: { serverBase: ['/'] },
-      },
-    ]);
+    ).toEqual([tanstackRouterEntry]);
 
     // If the built-in router CLI already installed the internal router for
     // this custom entry (explicit `runtime.router` config), only the module
-    // path is redirected so the TanStack provider registration is
-    // value-imported with it.
-    const existingRouterPlugin = {
+    // path is redirected — pushing a second entry installs two routers.
+    const builtInPlugin = {
       name: 'router',
       path: '@modern-js/runtime/router/internal',
       config: { serverBase: ['/'] },
     };
-    const { plugins } = taps.internalRuntimePlugins({
-      entrypoint: customEntrypoint,
-      plugins: [existingRouterPlugin],
-    });
-    expect(plugins).toHaveLength(1);
-    expect(plugins[0]).toEqual({
-      name: 'router',
-      path: '@modern-js/plugin-tanstack/runtime/router',
-      config: { serverBase: ['/'] },
-    });
-  });
-
-  test('leaves built-in and foreign-owned route entrypoints to their own router', () => {
-    const taps: Record<string, any> = {};
-    const api = {
-      getAppContext: () => ({
-        srcDirectory: '/tmp/app/src',
-        metaName: 'modern-js',
-        serverRoutes: [{ entryName: 'home', urlPath: '/' }],
-      }),
-      _internalRuntimePlugins: (tap: any) => {
-        taps.internalRuntimePlugins = tap;
-      },
-      checkEntryPoint: () => {},
-      config: () => {},
-      modifyEntrypoints: () => {},
-      generateEntryCode: () => {},
-      onFileChanged: () => {},
-      modifyFileSystemRoutes: () => {},
-      onBeforeGenerateRoutes: () => {},
-    };
-
-    tanstackRouterPlugin({ routesDir: 'ts-routes' }).setup!(api as any);
+    expect(
+      taps.internalRuntimePlugins({
+        entrypoint: customEntrypoint,
+        plugins: [builtInPlugin],
+      }).plugins,
+    ).toEqual([tanstackRouterEntry]);
 
     // A classic react-router file-route entry (src/<entry>/routes) living
     // next to the TanStack entries: its internal router plugin must be left
-    // untouched — redirecting it through the TanStack wrapper would pull
-    // @tanstack/react-router into a pure react-router bundle.
-    const builtInEntrypoint = {
-      entryName: 'home',
-      isAutoMount: true,
-      nestedRoutesEntry: '/tmp/app/src/home/routes',
-      __modernRoutesDir: 'routes',
-    } as Entrypoint;
-    const { plugins: builtInPlugins } = taps.internalRuntimePlugins({
-      entrypoint: builtInEntrypoint,
-      plugins: [
-        {
-          name: 'router',
-          path: '@modern-js/runtime/router/internal',
-          config: { serverBase: ['/'] },
-        },
-      ],
-    });
-    expect(builtInPlugins).toEqual([
-      {
-        name: 'router',
-        path: '@modern-js/runtime/router/internal',
-        config: { serverBase: ['/'] },
-      },
-    ]);
+    // untouched — redirecting it would pull @tanstack/react-router into a
+    // pure react-router bundle.
+    expect(
+      taps.internalRuntimePlugins({
+        entrypoint: {
+          entryName: 'home',
+          isAutoMount: true,
+          nestedRoutesEntry: '/tmp/app/src/home/routes',
+          __modernRoutesDir: 'routes',
+        } as Entrypoint,
+        plugins: [builtInPlugin],
+      }).plugins,
+    ).toEqual([builtInPlugin]);
 
     // An entry tagged by another routes-owner plugin: nothing is pushed.
-    // The replaced sniffing path in @modern-js/runtime excluded
-    // plugin-owned entrypoints for the same reason — pushing a second
-    // `router` plugin can install two routers for one entry.
-    const foreignEntrypoint = {
-      entryName: 'home',
-      isAutoMount: true,
-      nestedRoutesEntry: '/tmp/app/src/home/acme-routes',
-      __modernRoutesDir: 'acme-routes',
-      __modernRoutesOwner: '@acme/plugin-file-router',
-    } as Entrypoint;
     expect(
       taps.internalRuntimePlugins({
-        entrypoint: foreignEntrypoint,
+        entrypoint: {
+          entryName: 'home',
+          isAutoMount: true,
+          nestedRoutesEntry: '/tmp/app/src/home/acme-routes',
+          __modernRoutesDir: 'acme-routes',
+          __modernRoutesOwner: '@acme/plugin-file-router',
+        } as Entrypoint,
         plugins: [],
       }).plugins,
     ).toEqual([]);
-
-    // The built-in pages/ convention is foreign too.
-    const pagesEntrypoint = {
-      entryName: 'home',
-      isAutoMount: true,
-      pageRoutesEntry: '/tmp/app/src/home/pages',
-    } as Entrypoint;
-    expect(
-      taps.internalRuntimePlugins({ entrypoint: pagesEntrypoint, plugins: [] })
-        .plugins,
-    ).toEqual([]);
-  });
-
-  test('source.include covers the package dist and TanStack runtime deps without string surgery', () => {
-    const taps: Record<string, any> = {};
-    const api = {
-      getAppContext: () => ({
-        srcDirectory: '/tmp/app/src',
-        serverRoutes: [],
-      }),
-      _internalRuntimePlugins: () => {},
-      checkEntryPoint: () => {},
-      config: (tap: any) => {
-        taps.config = tap;
-      },
-      modifyEntrypoints: () => {},
-      generateEntryCode: () => {},
-      onFileChanged: () => {},
-      modifyFileSystemRoutes: () => {},
-      onBeforeGenerateRoutes: () => {},
-    };
-
-    tanstackRouterPlugin().setup!(api as any);
-
-    const include = taps.config().source.include as Array<RegExp | string>;
-    const regexes = include.filter(
-      (entry): entry is RegExp => entry instanceof RegExp,
-    );
-    for (const dep of ['react-router', 'router-core', 'react-store']) {
-      const sample = `/repo/node_modules/@tanstack/${dep}/dist/esm/index.js`;
-      expect(regexes.some(regex => regex.test(sample))).toBe(true);
-    }
-
-    const stringEntries = include.filter(
-      (entry): entry is string => typeof entry === 'string',
-    );
-    expect(stringEntries).toHaveLength(1);
-    // The include must point at the package root (two levels above the cli
-    // build dir) so dist/esm, dist/esm-node and dist/cjs are all covered —
-    // the old `.replace('cjs', 'esm')` never matched the bundled dist/esm
-    // runtime when the CLI was loaded through the ESM condition.
-    expect(stringEntries[0]).toBe(path.resolve(__dirname, '..', '..'));
-    expect(stringEntries[0]).not.toContain('esm');
   });
 
   test('emits the plugin-i18n augmentation only when plugin-i18n is registered', async () => {
@@ -666,7 +365,7 @@ describe('tanstack router cli plugin', () => {
 
       const taps: Record<string, any> = {};
       const api = {
-        getAppContext: () => ({
+        ...createAppContextApi({
           srcDirectory,
           internalSrcAlias: '@/_',
           entrypoints: [entrypoint],
@@ -718,379 +417,4 @@ describe('tanstack router cli plugin', () => {
       { name: '@modern-js/plugin-i18n' },
     ]);
   });
-
-  test('generates plugin-owned TanStack route files through core route generation', async () => {
-    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-cli-'));
-    const srcDirectory = path.join(tempDir, 'src');
-    const entryDir = path.join(srcDirectory, 'main');
-    const viewsDir = path.join(entryDir, 'views');
-    await mkdir(path.join(viewsDir, 'mf'), { recursive: true });
-    await fs.outputFile(
-      path.join(viewsDir, 'mf', 'page.data.ts'),
-      [
-        'export const loader = () => ({ count: 0 });',
-        'export const action = () => Response.json({ count: 1 });',
-      ].join('\n'),
-    );
-
-    const entrypoint = {
-      entryName: 'main',
-      entry: entryDir,
-      absoluteEntryDir: entryDir,
-      isAutoMount: true,
-      isMainEntry: true,
-      nestedRoutesEntry: viewsDir,
-      __modernRoutesDir: 'views',
-    } as Entrypoint;
-    runtimeCliMocks.handleGeneratorEntryCode.mockResolvedValue({
-      main: [
-        {
-          type: 'nested',
-          id: 'layout',
-          isRoot: true,
-          children: [
-            {
-              type: 'nested',
-              id: 'mf/page',
-              path: 'mf',
-              data: '@/_/main/views/mf/page.data',
-              action: '@/_/main/views/mf/page.data',
-            },
-          ],
-        },
-      ],
-    });
-
-    const taps: Record<string, any> = {};
-    const api = {
-      getAppContext: () => ({
-        srcDirectory,
-        internalSrcAlias: '@/_',
-        entrypoints: [entrypoint],
-      }),
-      _internalRuntimePlugins: () => {},
-      checkEntryPoint: (tap: any) => {
-        taps.checkEntryPoint = tap;
-      },
-      config: (tap: any) => {
-        taps.config = tap;
-      },
-      modifyEntrypoints: (tap: any) => {
-        taps.modifyEntrypoints = tap;
-      },
-      generateEntryCode: (tap: any) => {
-        taps.generateEntryCode = tap;
-      },
-      onFileChanged: (tap: any) => {
-        taps.onFileChanged = tap;
-      },
-      modifyFileSystemRoutes: (tap: any) => {
-        taps.modifyFileSystemRoutes = tap;
-      },
-      onBeforeGenerateRoutes: (tap: any) => {
-        taps.onBeforeGenerateRoutes = tap;
-      },
-    };
-
-    tanstackRouterPlugin({
-      generatedDirName: 'tanstack-generated',
-      routesDir: 'views',
-    }).setup!(api as any);
-
-    await taps.generateEntryCode({ entrypoints: [entrypoint] });
-
-    expect(runtimeCliMocks.handleGeneratorEntryCode).toHaveBeenCalledWith(
-      api,
-      [entrypoint],
-      {
-        entrypointsKey: '@modern-js/plugin-tanstack',
-        hydrateRscClientRoutes: true,
-        includeRouteServerLoadersInSsrEntry: false,
-        isolateRouteDataInRscLayer: true,
-        serverRoutesFileName: 'tanstack-routes.server.js',
-      },
-    );
-
-    await typecheckGeneratedRegistration({
-      entries: ['main'],
-      generatedDirName: 'tanstack-generated',
-      srcDirectory,
-    });
-  });
-
-  test('regenerates plugin-owned TanStack files for scoped file changes', async () => {
-    const regenerateEvent = {
-      eventType: 'add',
-      filename: 'src/main/views/page.tsx',
-    };
-    const entrypoint = {
-      entryName: 'main',
-      __modernRoutesDir: 'views',
-    } as any as Entrypoint;
-    const api = {
-      getAppContext: () => ({
-        srcDirectory: '/tmp/app/src',
-        internalSrcAlias: '@/_',
-        entrypoints: [entrypoint],
-      }),
-      _internalRuntimePlugins: () => {},
-      checkEntryPoint: () => {},
-      config: () => {},
-      modifyEntrypoints: () => {},
-      generateEntryCode: () => {},
-      onFileChanged: (tap: any) => {
-        api.onFileChangedTap = tap;
-      },
-      modifyFileSystemRoutes: () => {},
-      onBeforeGenerateRoutes: () => {},
-      onFileChangedTap: undefined as any,
-    };
-
-    tanstackRouterPlugin({ routesDir: 'views' }).setup!(api as any);
-
-    runtimeCliMocks.handleFileChange.mockImplementationOnce(
-      async (_api, _event, options) => {
-        expect(options.entrypointsKey).toBe('@modern-js/plugin-tanstack');
-        expect(options.includeEntry(entrypoint)).toBe(true);
-        expect(
-          options.includeEntry({
-            ...entrypoint,
-            __modernRoutesDir: 'routes',
-          }),
-        ).toBe(false);
-        expect(typeof options.regenerate).toBe('function');
-      },
-    );
-
-    await api.onFileChangedTap(regenerateEvent);
-
-    expect(runtimeCliMocks.handleFileChange).toHaveBeenCalledWith(
-      api,
-      regenerateEvent,
-      expect.objectContaining({
-        entrypointsKey: '@modern-js/plugin-tanstack',
-      }),
-    );
-  });
-
-  test('can opt out of Modern-owned route code splitting', async () => {
-    const taps: Record<string, any> = {};
-    const api = {
-      getAppContext: () => ({
-        srcDirectory: '/tmp/app/src',
-        serverRoutes: [],
-      }),
-      _internalRuntimePlugins: () => {},
-      checkEntryPoint: () => {},
-      config: (tap: any) => {
-        taps.config = tap;
-      },
-      modifyEntrypoints: () => {},
-      generateEntryCode: () => {},
-      onFileChanged: () => {},
-      modifyFileSystemRoutes: () => {},
-      onBeforeGenerateRoutes: () => {},
-    };
-
-    tanstackRouterPlugin({ routeCodeSplitting: false }).setup!(api as any);
-
-    expect(taps.config()).toMatchObject({
-      output: {
-        splitRouteChunks: false,
-      },
-    });
-  });
-
-  test('route splitting profile carries only the rsbuild config production consumes', () => {
-    expect(createTanstackRsbuildRouteSplittingProfile({})).toEqual({
-      defaultConfig: {
-        output: {
-          splitRouteChunks: true,
-        },
-      },
-    });
-    expect(
-      createTanstackRsbuildRouteSplittingProfile({ routeCodeSplitting: false }),
-    ).toEqual({
-      defaultConfig: {
-        output: {
-          splitRouteChunks: false,
-        },
-      },
-    });
-  });
-
-  test('preserves user-selected route and builder chunk splitting modes', () => {
-    const pluginDefaults = createTanstackRsbuildRouteSplittingProfile(
-      {},
-    ).defaultConfig;
-    const chunkSplits = [
-      { strategy: 'split-by-module' },
-      { strategy: 'split-by-experience' },
-      { strategy: 'all-in-one' },
-      { strategy: 'single-vendor' },
-      { strategy: 'split-by-size', minSize: 10_000, maxSize: 60_000 },
-      {
-        strategy: 'custom',
-        splitChunks: {
-          chunks: 'all',
-          cacheGroups: {
-            tractors: {
-              name: 'tractors',
-              test: /tractors/u,
-            },
-          },
-        },
-      },
-    ];
-
-    for (const chunkSplit of chunkSplits) {
-      expect(
-        mergeConfig([
-          pluginDefaults,
-          {
-            output: {
-              splitRouteChunks: false,
-            },
-            performance: {
-              chunkSplit,
-            },
-            splitChunks: false,
-          },
-        ]),
-      ).toMatchObject({
-        output: {
-          splitRouteChunks: false,
-        },
-        performance: {
-          chunkSplit,
-        },
-        splitChunks: false,
-      });
-    }
-
-    const pageSplitWithManualAsyncChunks = mergeConfig([
-      pluginDefaults,
-      {
-        performance: {
-          chunkSplit: {
-            strategy: 'custom',
-            splitChunks: {
-              chunks: 'async',
-            },
-          },
-        },
-      },
-    ]);
-
-    expect(pageSplitWithManualAsyncChunks).toMatchObject({
-      output: {
-        splitRouteChunks: true,
-      },
-      performance: {
-        chunkSplit: {
-          strategy: 'custom',
-          splitChunks: {
-            chunks: 'async',
-          },
-        },
-      },
-    });
-  });
-
-  test('keeps custom cache group details intact', () => {
-    const pluginDefaults = createTanstackRsbuildRouteSplittingProfile(
-      {},
-    ).defaultConfig;
-
-    const mergedConfig = mergeConfig([
-      pluginDefaults,
-      {
-        performance: {
-          chunkSplit: {
-            strategy: 'custom',
-            splitChunks: {
-              chunks: 'all',
-              cacheGroups: {
-                tractors: {
-                  name: 'tractors',
-                  test: /tractors/u,
-                },
-              },
-            },
-          },
-        },
-      },
-    ]);
-
-    expect(
-      (
-        mergedConfig as {
-          performance?: {
-            chunkSplit?: {
-              splitChunks?: {
-                cacheGroups?: {
-                  tractors?: {
-                    test?: RegExp;
-                  };
-                };
-              };
-            };
-          };
-        }
-      ).performance?.chunkSplit?.splitChunks?.cacheGroups?.tractors?.test,
-    ).toEqual(/tractors/u);
-    expect(mergedConfig).toMatchObject({
-      output: {
-        splitRouteChunks: true,
-      },
-      performance: {
-        chunkSplit: {
-          strategy: 'custom',
-          splitChunks: {
-            chunks: 'all',
-            cacheGroups: {
-              tractors: {
-                name: 'tractors',
-              },
-            },
-          },
-        },
-      },
-    });
-  });
-
-  test('plugin opt-out can still combine with manual builder chunking', () => {
-    const pluginDefaults = createTanstackRsbuildRouteSplittingProfile({
-      routeCodeSplitting: false,
-    }).defaultConfig;
-
-    expect(
-      mergeConfig([
-        pluginDefaults,
-        {
-          performance: {
-            chunkSplit: {
-              strategy: 'single-vendor',
-            },
-          },
-        },
-      ]),
-    ).toMatchObject({
-      output: {
-        splitRouteChunks: false,
-      },
-      performance: {
-        chunkSplit: {
-          strategy: 'single-vendor',
-        },
-      },
-    });
-  });
-});
-
-describe('generateTanstackRouteArtifacts export', () => {
-  test('is exported as a function', () => {
-    expect(typeof generateTanstackRouteArtifacts).toBe('function');
-  });
 });