@bleedingdev/modern-js-plugin-tanstack 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

package/tests/router/tanstackTypes.test.ts

@@ -1,50 +1,22 @@
 import { execFile } from 'node:child_process';
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { mkdir, mkdtemp, rm, symlink, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
+import { pathToFileURL } from 'node:url';
 import { promisify } from 'node:util';
-
-const resolverDelays = new Map<string, number>();
-
-rstest.mock('../../src/cli/tanstackTypes/shared', () => {
-  const actual = rstest.requireActual(
-    '../../src/cli/tanstackTypes/shared',
-  ) as typeof import('../../src/cli/tanstackTypes/shared');
-
-  return {
-    ...actual,
-    resolveFileNoExt: async (inputNoExtPath: string) => {
-      const normalized = inputNoExtPath.replaceAll('\\', '/');
-      const delay =
-        [...resolverDelays.entries()].find(([suffix]) =>
-          normalized.endsWith(suffix),
-        )?.[1] ?? 0;
-
-      if (delay > 0) {
-        await new Promise(resolve => setTimeout(resolve, delay));
-      }
-
-      return actual.resolveFileNoExt(inputNoExtPath);
-    },
-  };
-});
-
+import { applyLocalisedUrlsToRoutes } from '@modern-js/i18n-runtime-extensions';
+import { createMemoryHistory, createRouter } from '@tanstack/react-router';
 import { writeTanstackRegisterFile } from '../../src/cli/artifacts';
 import {
   collectCanonicalRoutesForEntry,
   generateTanstackRouterTypesSourceForEntry,
 } from '../../src/cli/tanstackTypes';
+import { createModernBasepathRewrite } from '../../src/runtime/basepathRewrite';
+import { createRouteTreeFromRouteObjects } from '../../src/runtime/routeTree';
+import { createTanstackRouteObjectsFromConfig } from '../../src/runtime/utils';
+import { navigateOnClient } from './clientNavigation';
 
 const execFileAsync = promisify(execFile);
-const routerGenOxlintConfigPath = path.join(
-  __dirname,
-  'fixtures',
-  'router-gen.oxlint.json',
-);
-const oxlintCliPath = path.resolve(
-  __dirname,
-  '../../../../toolkit/code-tools/node_modules/oxlint/bin/oxlint',
-);
 const strictestTsconfigPath = path.resolve(
   __dirname,
   '../../node_modules/@tsconfig/strictest/tsconfig.json',
@@ -54,195 +26,51 @@ const installedReactRouterPath = path.resolve(
   '../../node_modules/@tanstack/react-router',
 );
 
-async function writeRuntimeTestPackage(projectDirectory: string) {
-  const runtimePackageDirectory = path.join(
-    projectDirectory,
-    'node_modules',
-    '@modern-js',
-    'plugin-tanstack',
-  );
-  await mkdir(runtimePackageDirectory, { recursive: true });
-  await writeFile(
-    path.join(runtimePackageDirectory, 'package.json'),
-    JSON.stringify({
-      name: '@modern-js/plugin-tanstack',
-      type: 'commonjs',
-      exports: {
-        './runtime': {
-          types: './runtime.d.ts',
-          default: './runtime.js',
-        },
-      },
-    }),
-  );
-  await writeFile(
-    path.join(runtimePackageDirectory, 'runtime.d.ts'),
-    [
-      'export type ModernRouterContext = { request?: Request; requestContext?: unknown };',
-      'export type ModernRouteStaticData = { modernRouteId?: string; modernRouteAction?: unknown; modernRouteLoader?: unknown };',
-      'export type RouteOptions = {',
-      '  component?: unknown;',
-      '  getParentRoute?: (...args: never[]) => unknown;',
-      '  id?: string;',
-      '  loader?: (...args: never[]) => unknown;',
-      '  loaderDeps?: (...args: never[]) => unknown;',
-      '  path?: string;',
-      '  staticData?: ModernRouteStaticData;',
-      '  validateSearch?: (...args: never[]) => unknown;',
-      '};',
-      'export type Route<TOptions extends RouteOptions = RouteOptions> = {',
-      '  options: TOptions;',
-      '  addChildren<const TChildren extends readonly unknown[]>(children: TChildren): Route<TOptions> & { children: TChildren };',
-      '};',
-      'export const runtimeState: { adapterCalls: Array<{ hasSplat: boolean; modernLoader: unknown }> };',
-      'export function createMemoryHistory<TOptions>(options: TOptions): TOptions;',
-      'export const modernTanstackRouterFastDefaults: { defaultPreload: "intent" };',
-      'export function createRootRouteWithContext<TContext extends ModernRouterContext>(): <const TOptions extends RouteOptions>(options: TOptions) => Route<TOptions>;',
-      'export function createRoute<const TOptions extends RouteOptions>(options: TOptions): Route<TOptions>;',
-      'export function createRouter<const TOptions extends { context: ModernRouterContext; history: unknown; routeTree: unknown }>(options: TOptions): TOptions;',
-      'export function createRouteStaticData<const TData extends ModernRouteStaticData>(data: TData): TData;',
-      'export function modernLoaderToTanstack<TLoader extends (...args: never[]) => unknown>(options: { hasSplat: boolean }, modernLoader: TLoader): (context: unknown) => Promise<Awaited<ReturnType<TLoader>>>;',
-    ].join('\n'),
-  );
-  await writeFile(
-    path.join(runtimePackageDirectory, 'runtime.js'),
-    [
-      'const runtimeState = { adapterCalls: [] };',
-      'const createRouteRecord = options => ({',
-      '  options,',
-      '  addChildren(children) {',
-      '    this.children = children;',
-      '    return this;',
-      '  },',
-      '});',
-      'const createMemoryHistory = options => options;',
-      'const modernTanstackRouterFastDefaults = { defaultPreload: "intent" };',
-      'const createRootRouteWithContext = () => options => createRouteRecord(options);',
-      'const createRoute = options => createRouteRecord(options);',
-      'const createRouter = options => options;',
-      'const createRouteStaticData = data => data;',
-      'const modernLoaderToTanstack = (options, modernLoader) => {',
-      '  runtimeState.adapterCalls.push({ ...options, modernLoader });',
-      '  return async context => modernLoader(context);',
-      '};',
-      'module.exports = { createMemoryHistory, createRootRouteWithContext, createRoute, createRouter, createRouteStaticData, modernLoaderToTanstack, modernTanstackRouterFastDefaults, runtimeState };',
-    ].join('\n'),
-  );
-}
-
-async function writeInstalledRouterRuntimeTestPackage(
+async function writeTsconfig(
   projectDirectory: string,
+  compilerOptions: Record<string, unknown>,
 ) {
-  const runtimePackageDirectory = path.join(
-    projectDirectory,
-    'node_modules',
-    '@modern-js',
-    'plugin-tanstack',
-  );
-  await mkdir(runtimePackageDirectory, { recursive: true });
-  await writeFile(
-    path.join(runtimePackageDirectory, 'package.json'),
-    JSON.stringify({
-      name: '@modern-js/plugin-tanstack',
-      type: 'commonjs',
-      exports: {
-        './runtime': {
-          types: './runtime.d.ts',
-          default: './runtime.js',
-        },
-      },
-    }),
-  );
-  await writeFile(
-    path.join(runtimePackageDirectory, 'runtime.d.ts'),
-    [
-      "export { createMemoryHistory, createRootRouteWithContext, createRoute, createRouter } from '@tanstack/react-router';",
-      'export type ModernRouterContext = { request?: Request; requestContext?: unknown };',
-      'export const modernTanstackRouterFastDefaults: { readonly defaultStructuralSharing: true };',
-      'export function createRouteStaticData<TData extends { modernRouteId?: string; modernRouteAction?: unknown; modernRouteLoader?: unknown }>(data: TData): TData;',
-      'export function modernLoaderToTanstack<TLoader extends (...args: any[]) => any>(options: { hasSplat: boolean }, modernLoader: TLoader): (context: unknown) => Promise<Awaited<ReturnType<TLoader>>>;',
-    ].join('\n'),
-  );
-}
-
-async function compileAndRunGeneratedRouter(options: {
-  projectDirectory: string;
-  routerGenTs: string;
-  runtimeCheck: string;
-}) {
-  const { projectDirectory, routerGenTs, runtimeCheck } = options;
-  const generatedDirectory = path.join(
-    projectDirectory,
-    'src',
-    'modern-tanstack',
-    'index',
-  );
-  await mkdir(generatedDirectory, { recursive: true });
-  await writeFile(path.join(generatedDirectory, 'router.gen.ts'), routerGenTs);
-  await writeFile(
-    path.join(projectDirectory, 'src', 'runtime-check.ts'),
-    runtimeCheck,
-  );
-  await writeRuntimeTestPackage(projectDirectory);
-  await writeFile(
-    path.join(projectDirectory, 'package.json'),
-    JSON.stringify({ private: true, type: 'commonjs' }),
-  );
   await writeFile(
     path.join(projectDirectory, 'tsconfig.json'),
     JSON.stringify(
       {
         extends: strictestTsconfigPath,
         compilerOptions: {
-          lib: ['ESNext', 'DOM'],
           jsx: 'react-jsx',
-          module: 'Node16',
-          moduleResolution: 'Node16',
-          outDir: 'dist',
-          rootDir: 'src',
-          target: 'ES2022',
+          lib: ['ESNext', 'DOM'],
+          noEmit: true,
+          target: 'ESNext',
           types: [],
-          verbatimModuleSyntax: false,
+          ...compilerOptions,
         },
-        include: ['src/**/*.ts', 'src/**/*.tsx'],
+        include: ['src/**/*.ts', 'src/**/*.tsx', 'src/**/*.d.ts'],
       },
       null,
       2,
     ),
   );
+}
 
+/** Runs the same compiler a consumer build runs; surfaces its diagnostics. */
+async function runTsgo(projectDirectory: string) {
   try {
     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') {
-      const stdout =
-        'stdout' in error && typeof error.stdout === 'string'
-          ? error.stdout
-          : '';
-      const stderr =
-        'stderr' in error && typeof error.stderr === 'string'
-          ? error.stderr
-          : '';
-      if (stdout || stderr) {
-        throw new Error([stdout, stderr].filter(Boolean).join('\n'), {
-          cause: error,
-        });
-      }
+    const { stdout, stderr } = (error ?? {}) as {
+      stdout?: string;
+      stderr?: string;
+    };
+    if (stdout || stderr) {
+      throw new Error([stdout, stderr].filter(Boolean).join('\n'), {
+        cause: error,
+      });
     }
     throw error;
   }
-  await execFileAsync(
-    process.execPath,
-    [path.join(projectDirectory, 'dist', 'runtime-check.js')],
-    { cwd: projectDirectory },
-  );
 }
 
 async function compileGeneratedRouterAgainstInstalledDeclarations(options: {
@@ -258,63 +86,48 @@ async function compileGeneratedRouterAgainstInstalledDeclarations(options: {
   );
   await mkdir(generatedDirectory, { recursive: true });
   await writeFile(path.join(generatedDirectory, 'router.gen.ts'), routerGenTs);
-  await writeInstalledRouterRuntimeTestPackage(projectDirectory);
-  await writeFile(
-    path.join(projectDirectory, 'package.json'),
-    JSON.stringify({ private: true, type: 'commonjs' }),
+
+  // The runtime package re-exports the *installed* @tanstack/react-router
+  // declarations, so the generated file is checked against the real router
+  // types a consumer resolves — not a stand-in.
+  const runtimePackageDirectory = path.join(
+    projectDirectory,
+    'node_modules',
+    '@modern-js',
+    'plugin-tanstack',
   );
+  await mkdir(runtimePackageDirectory, { recursive: true });
   await writeFile(
-    path.join(projectDirectory, 'tsconfig.json'),
-    JSON.stringify(
-      {
-        extends: strictestTsconfigPath,
-        compilerOptions: {
-          jsx: 'react-jsx',
-          lib: ['ESNext', 'DOM'],
-          module: 'Node16',
-          moduleResolution: 'Node16',
-          noEmit: true,
-          paths: {
-            '@tanstack/react-router': [installedReactRouterPath],
-          },
-          target: 'ES2022',
-          types: [],
-          verbatimModuleSyntax: false,
-        },
-        include: ['src/**/*.ts', 'src/**/*.tsx'],
+    path.join(runtimePackageDirectory, 'package.json'),
+    JSON.stringify({
+      name: '@modern-js/plugin-tanstack',
+      type: 'commonjs',
+      exports: {
+        './runtime': { types: './runtime.d.ts', default: './runtime.js' },
       },
-      null,
-      2,
-    ),
+    }),
   );
-
-  try {
-    await execFileAsync(
-      process.platform === 'win32' ? 'tsgo.cmd' : 'tsgo',
-      ['-p', 'tsconfig.json'],
-      {
-        cwd: projectDirectory,
-        shell: process.platform === 'win32',
-      },
-    );
-  } catch (error) {
-    if (error && typeof error === 'object') {
-      const stdout =
-        'stdout' in error && typeof error.stdout === 'string'
-          ? error.stdout
-          : '';
-      const stderr =
-        'stderr' in error && typeof error.stderr === 'string'
-          ? error.stderr
-          : '';
-      if (stdout || stderr) {
-        throw new Error([stdout, stderr].filter(Boolean).join('\n'), {
-          cause: error,
-        });
-      }
-    }
-    throw error;
-  }
+  await writeFile(
+    path.join(runtimePackageDirectory, 'runtime.d.ts'),
+    [
+      "export { createMemoryHistory, createRootRouteWithContext, createRoute, createRouter } from '@tanstack/react-router';",
+      'export type ModernRouterContext = { request?: Request; requestContext?: unknown };',
+      'export const modernTanstackRouterFastDefaults: { readonly defaultStructuralSharing: true };',
+      'export function createRouteStaticData<TData extends { modernRouteId?: string; modernRouteAction?: unknown; modernRouteLoader?: unknown }>(data: TData): TData;',
+      'export function modernLoaderToTanstack<TLoader extends (...args: any[]) => any>(options: { hasSplat: boolean }, modernLoader: TLoader): (context: unknown) => Promise<Awaited<ReturnType<TLoader>>>;',
+    ].join('\n'),
+  );
+  await writeFile(
+    path.join(projectDirectory, 'package.json'),
+    JSON.stringify({ private: true, type: 'commonjs' }),
+  );
+  await writeTsconfig(projectDirectory, {
+    module: 'Node16',
+    moduleResolution: 'Node16',
+    paths: { '@tanstack/react-router': [installedReactRouterPath] },
+    verbatimModuleSyntax: false,
+  });
+  await runTsgo(projectDirectory);
 }
 
 async function typecheckCanonicalRegisterContract(options: {
@@ -324,11 +137,11 @@ async function typecheckCanonicalRegisterContract(options: {
 }) {
   const { canonicalRoutes, contractLines, projectDirectory } = options;
   const srcDirectory = path.join(projectDirectory, 'src');
-  const generatedDirectory = path.join(srcDirectory, 'modern-tanstack');
-  const routerDirectory = path.join(generatedDirectory, 'index');
-  await mkdir(routerDirectory, { recursive: true });
+  await mkdir(path.join(srcDirectory, 'modern-tanstack', 'index'), {
+    recursive: true,
+  });
   await writeFile(
-    path.join(routerDirectory, 'router.gen.ts'),
+    path.join(srcDirectory, 'modern-tanstack', 'index', 'router.gen.ts'),
     'export const router = { context: {} };',
   );
   await writeTanstackRegisterFile({
@@ -350,56 +163,14 @@ async function typecheckCanonicalRegisterContract(options: {
       ...contractLines,
     ].join('\n'),
   );
-  await writeFile(
-    path.join(projectDirectory, 'tsconfig.json'),
-    JSON.stringify(
-      {
-        extends: strictestTsconfigPath,
-        compilerOptions: {
-          lib: ['ESNext', 'DOM'],
-          module: 'Preserve',
-          moduleResolution: 'Bundler',
-          noEmit: true,
-          target: 'ESNext',
-          types: [],
-        },
-        include: ['src/**/*.ts', 'src/**/*.d.ts'],
-      },
-      null,
-      2,
-    ),
-  );
-
-  try {
-    await execFileAsync(
-      process.platform === 'win32' ? 'tsgo.cmd' : 'tsgo',
-      ['-p', 'tsconfig.json'],
-      {
-        cwd: projectDirectory,
-        shell: process.platform === 'win32',
-      },
-    );
-  } catch (error) {
-    if (error && typeof error === 'object') {
-      const stdout =
-        'stdout' in error && typeof error.stdout === 'string'
-          ? error.stdout
-          : '';
-      const stderr =
-        'stderr' in error && typeof error.stderr === 'string'
-          ? error.stderr
-          : '';
-      if (stdout || stderr) {
-        throw new Error([stdout, stderr].filter(Boolean).join('\n'), {
-          cause: error,
-        });
-      }
-    }
-    throw error;
-  }
+  await writeTsconfig(projectDirectory, {
+    module: 'Preserve',
+    moduleResolution: 'Bundler',
+  });
+  await runTsgo(projectDirectory);
 }
 
-async function writeComprehensiveRouterFixture(srcDirectory: string) {
+async function generateComprehensiveRouterGen(srcDirectory: string) {
   const files = new Map([
     [
       'routes/(app)/layout.tsx',
@@ -428,22 +199,14 @@ async function writeComprehensiveRouterFixture(srcDirectory: string) {
       ].join('\n'),
     ],
   ]);
-
   for (const [relativePath, contents] of files) {
     const filePath = path.join(srcDirectory, relativePath);
     await mkdir(path.dirname(filePath), { recursive: true });
     await writeFile(filePath, contents);
   }
-}
-
-async function generateComprehensiveRouterGen(srcDirectory: string) {
-  await writeComprehensiveRouterFixture(srcDirectory);
 
   const { routerGenTs } = await generateTanstackRouterTypesSourceForEntry({
-    appContext: {
-      srcDirectory,
-      internalSrcAlias: '@/_',
-    } as any,
+    appContext: { srcDirectory, internalSrcAlias: '@/_' } as any,
     entryName: 'golden',
     routes: [
       {
@@ -486,402 +249,138 @@ describe('tanstack router type generation', () => {
   let tempDir: string | undefined;
 
   afterEach(async () => {
-    resolverDelays.clear();
     if (tempDir) {
       await rm(tempDir, { recursive: true, force: true });
       tempDir = undefined;
     }
   });
 
-  test('strictly compiles and executes a loader-free conventional route tree', async () => {
+  test('strictly compiles generated routes against installed router declarations', async () => {
     tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-types-'));
-    const srcDirectory = path.join(tempDir, 'src');
-    const files = new Map([
-      [
-        'routes/layout.tsx',
-        'export default function Layout() { return null; }',
-      ],
-      ['routes/page.tsx', 'export default function Home() { return null; }'],
-      [
-        'routes/reviews/[scanId]/page.tsx',
-        'export default function Review() { return null; }',
-      ],
-    ]);
-
-    for (const [relativePath, contents] of files) {
-      const filePath = path.join(srcDirectory, relativePath);
-      await mkdir(path.dirname(filePath), { recursive: true });
-      await writeFile(filePath, contents);
-    }
-
-    const { routerGenTs } = await generateTanstackRouterTypesSourceForEntry({
-      appContext: {
-        srcDirectory,
-        internalSrcAlias: '@/_',
-      } as any,
-      entryName: 'index',
-      routes: [
-        {
-          type: 'nested',
-          id: 'layout',
-          isRoot: true,
-          _component: '@/_/routes/layout',
-          children: [
-            {
-              type: 'nested',
-              id: 'page',
-              index: true,
-              _component: '@/_/routes/page',
-            },
-            {
-              type: 'nested',
-              id: 'reviews/(scanId)/page',
-              path: 'reviews/:scanId',
-              _component: '@/_/routes/reviews/[scanId]/page',
-            },
-          ],
-        },
-      ] as any,
-    });
+    const routerGenTs = await generateComprehensiveRouterGen(
+      path.join(tempDir, 'src'),
+    );
 
-    await compileAndRunGeneratedRouter({
+    await compileGeneratedRouterAgainstInstalledDeclarations({
       projectDirectory: tempDir,
       routerGenTs,
-      runtimeCheck: [
-        "import { runtimeState } from '@modern-js/plugin-tanstack/runtime';",
-        "import Layout from './routes/layout';",
-        "import Home from './routes/page';",
-        "import Review from './routes/reviews/[scanId]/page';",
-        "import { rootRoute, routeTree, router } from './modern-tanstack/index/router.gen';",
-        '',
-        'if (runtimeState.adapterCalls.length !== 0) throw new Error("loader adapter registered without a loader");',
-        'if (Object.keys(router.context).length !== 0) throw new Error("router context is not empty");',
-        'if (rootRoute.options.component !== Layout) throw new Error("root component was not wired");',
-        'const [homeRoute, reviewRoute] = routeTree.children;',
-        'if (homeRoute.options.component !== Home) throw new Error("index component was not wired");',
-        'if (reviewRoute.options.component !== Review) throw new Error("review component was not wired");',
-        'if (reviewRoute.options.path !== "reviews/$scanId") throw new Error("route params were not translated");',
-      ].join('\n'),
     });
   });
 
-  test('executes generated loader and action wiring through route static data', async () => {
-    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-types-'));
-    const srcDirectory = path.join(tempDir, 'src');
-    const routeDir = path.join(srcDirectory, 'routes', 'mf');
-    await mkdir(routeDir, { recursive: true });
-    await writeFile(
-      path.join(routeDir, 'page.data.ts'),
+  test('generated and runtime trees agree on localized splats, root siblings, layouts and params', async () => {
+    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-parity-'));
+    const localized = applyLocalisedUrlsToRoutes(
       [
-        'export const loader = () => ({ count: 0 });',
-        'export const action = () => Response.json({ count: 1 });',
-      ].join('\n'),
-    );
-
-    const { routerGenTs } = await generateTanstackRouterTypesSourceForEntry({
-      appContext: {
-        srcDirectory,
-        internalSrcAlias: '@/_',
-      } as any,
-      entryName: 'index',
-      routes: [
         {
           type: 'nested',
-          id: 'layout',
-          isRoot: true,
+          id: 'lang',
+          path: ':lang',
           children: [
             {
               type: 'nested',
-              id: 'mf/page',
-              path: 'mf',
-              data: '@/_/routes/mf/page.data',
-              action: '@/_/routes/mf/page.data',
+              id: 'products',
+              path: 'products',
+              children: [{ type: 'nested', id: 'product-files', path: '*' }],
             },
+            { type: 'nested', id: 'fallback', path: '*' },
           ],
         },
-      ] as any,
+      ],
+      ['en', 'cs'],
+      { '/products': { en: '/products', cs: '/produkty' } },
+      'canonical',
+    );
+    const routes = [
+      {
+        type: 'nested',
+        id: 'layout',
+        isRoot: true,
+        children: [
+          ...localized,
+          {
+            type: 'nested',
+            children: [{ type: 'nested', path: 'one/:id?', index: false }],
+          },
+          { type: 'nested', children: [{ type: 'nested', path: 'two/*' }] },
+          { type: 'nested', id: 'index', index: true },
+        ],
+      },
+      { type: 'nested', id: 'sibling', path: 'outside/:lang' },
+    ] as any;
+    const { routerGenTs } = await generateTanstackRouterTypesSourceForEntry({
+      appContext: {
+        srcDirectory: path.join(tempDir, 'src'),
+        internalSrcAlias: '@/_',
+      } as any,
+      entryName: 'parity',
+      routes,
     });
-
-    await compileAndRunGeneratedRouter({
+    const generated = path.join(tempDir, 'router.gen.ts');
+    await writeFile(generated, routerGenTs);
+    const modules = path.join(tempDir, 'node_modules', '@modern-js');
+    await mkdir(modules, { recursive: true });
+    await symlink(
+      path.resolve(__dirname, '../..'),
+      path.join(modules, 'plugin-tanstack'),
+      'junction',
+    );
+    const { stdout } = await execFileAsync(process.execPath, [
+      '--input-type=module',
+      '--eval',
+      `
+      import { router } from ${JSON.stringify(pathToFileURL(generated).href)};
+      import { createModernBasepathRewrite } from ${JSON.stringify(pathToFileURL(path.resolve(__dirname, '../../dist/esm/runtime/basepathRewrite.mjs')).href)};
+      router.update({ rewrite: createModernBasepathRewrite('/base', false, ${JSON.stringify(routes)}) });
+      router.history.push(router.buildLocation({ to: '/cs/produkty/a/b', search: { q: 'tractor' }, hash: 'files' }).publicHref); router.updateLatestLocation(); await router.load();
+      console.log(JSON.stringify({ ids: Object.keys(router.routesById).sort(), match: router.state.matches.at(-1).routeId, params: router.state.matches.at(-1).params, href: router.history.location.href }));
+    `,
+    ]);
+    const routeObjects = createTanstackRouteObjectsFromConfig({
+      routesConfig: { routes },
+    })!;
+    const runtime = createRouter({
+      routeTree: createRouteTreeFromRouteObjects(routeObjects),
+      history: createMemoryHistory({
+        initialEntries: ['/base/cs/produkty/a/b?q=tractor#files'],
+      }),
+      rewrite: createModernBasepathRewrite('/base', false, routeObjects),
+    });
+    await runtime.load();
+    expect(JSON.parse(stdout)).toEqual({
+      ids: Object.keys(runtime.routesById).sort(),
+      match: runtime.state.matches.at(-1)?.routeId,
+      params: runtime.state.matches.at(-1)?.params,
+      href: runtime.history.location.href,
+    });
+    expect(runtime.state.matches.at(-1)?.routeId).toBe('/$lang/products/$');
+    expect(runtime.state.matches.at(-1)?.params).toMatchObject({
+      lang: 'cs',
+      _splat: 'a/b',
+    });
+    await navigateOnClient(runtime, { to: '/cs/missing/path' });
+    expect(runtime.state.matches.at(-1)?.routeId).toBe('/$lang/$');
+    expect(runtime.state.matches.at(-1)?.params).toMatchObject({
+      lang: 'cs',
+      _splat: 'missing/path',
+    });
+    await navigateOnClient(runtime, { to: '/outside/cs' });
+    expect(runtime.state.matches.at(-1)?.params).toEqual({ lang: 'cs' });
+    const canonicalRoutes = collectCanonicalRoutesForEntry(localized as any)!;
+    expect(Object.keys(canonicalRoutes)).toEqual(['/$', '/products/$']);
+    await typecheckCanonicalRegisterContract({
       projectDirectory: tempDir,
-      routerGenTs,
-      runtimeCheck: [
-        "import { runtimeState } from '@modern-js/plugin-tanstack/runtime';",
-        "import { action, loader } from './routes/mf/page.data';",
-        "import { routeTree } from './modern-tanstack/index/router.gen';",
-        '',
-        'async function main() {',
-        'const [mfRoute] = routeTree.children;',
-        'if (runtimeState.adapterCalls.length !== 1) throw new Error("loader adapter was not registered exactly once");',
-        'if (runtimeState.adapterCalls[0]?.modernLoader !== loader) throw new Error("wrong loader was adapted");',
-        'const result = await mfRoute.options.loader({});',
-        'if (result.count !== 0) throw new Error("adapted loader returned the wrong value");',
-        'if (mfRoute.options.staticData.modernRouteLoader !== loader) throw new Error("loader static data was not wired");',
-        'if (mfRoute.options.staticData.modernRouteAction !== action) throw new Error("action static data was not wired");',
-        '}',
-        'void main();',
-      ].join('\n'),
+      canonicalRoutes,
+      contractLines: [
+        "const product: UltramodernCanonicalRoutes['/products/$'] = { _splat: 'a/b' };",
+        "const fallback: UltramodernCanonicalRoutes['/$'] = { _splat: 'unknown/path' };",
+        '// @ts-expect-error splat remains a string',
+        "const invalid: UltramodernCanonicalRoutes['/products/$'] = { _splat: 42 };",
+        'void product; void fallback; void invalid;',
+      ],
     });
   });
 
-  test('executes component sharing correctly when module resolution races', async () => {
-    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-types-'));
-    const srcDirectory = path.join(tempDir, 'src');
-
-    for (const componentFile of [
-      'routes/slow-page.tsx',
-      'routes/fast-page.tsx',
-      'routes/shared-page.tsx',
-    ]) {
-      const componentPath = path.join(srcDirectory, componentFile);
-      await mkdir(path.dirname(componentPath), { recursive: true });
-      await writeFile(
-        componentPath,
-        'export default function Page() { return null; }',
-      );
-    }
-
-    resolverDelays.set('/routes/slow-page', 25);
-    const { routerGenTs } = await generateTanstackRouterTypesSourceForEntry({
-      appContext: {
-        srcDirectory,
-        internalSrcAlias: '@/_',
-      } as any,
-      entryName: 'index',
-      routes: [
-        {
-          type: 'nested',
-          id: 'layout',
-          isRoot: true,
-          children: [
-            {
-              type: 'nested',
-              id: 'slow/page',
-              path: 'slow',
-              _component: '@/_/routes/slow-page',
-            },
-            {
-              type: 'nested',
-              id: 'fast/page',
-              path: 'fast',
-              _component: '@/_/routes/fast-page',
-            },
-            {
-              type: 'nested',
-              id: 'shared-a/page',
-              path: 'shared-a',
-              _component: '@/_/routes/shared-page',
-            },
-            {
-              type: 'nested',
-              id: 'shared-b/page',
-              path: 'shared-b',
-              _component: '@/_/routes/shared-page',
-            },
-            {
-              type: 'nested',
-              id: 'data-only/page',
-              path: 'data-only',
-            },
-          ],
-        },
-      ] as any,
-    });
-
-    await compileAndRunGeneratedRouter({
-      projectDirectory: tempDir,
-      routerGenTs,
-      runtimeCheck: [
-        "import SlowPage from './routes/slow-page';",
-        "import FastPage from './routes/fast-page';",
-        "import SharedPage from './routes/shared-page';",
-        "import { routeTree } from './modern-tanstack/index/router.gen';",
-        '',
-        'const [slowRoute, fastRoute, sharedA, sharedB, dataOnly] = routeTree.children;',
-        'if (slowRoute.options.component !== SlowPage) throw new Error("slow component was crossed during resolution");',
-        'if (fastRoute.options.component !== FastPage) throw new Error("fast component was crossed during resolution");',
-        'if (sharedA.options.component !== SharedPage || sharedB.options.component !== SharedPage) throw new Error("shared component identity was not preserved");',
-        'if (Reflect.has(dataOnly.options, "component")) throw new Error("data-only route gained a component");',
-      ].join('\n'),
-    });
-  });
-
-  test('strictly compiles and executes nested loader and search contracts', async () => {
-    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-types-'));
-    const srcDirectory = path.join(tempDir, 'src');
-    const routerGenTs = await generateComprehensiveRouterGen(srcDirectory);
-
-    await compileAndRunGeneratedRouter({
-      projectDirectory: tempDir,
-      routerGenTs,
-      runtimeCheck: [
-        "import { runtimeState } from '@modern-js/plugin-tanstack/runtime';",
-        "import { action, loader } from './routes/(app)/users/(userId)/page.data';",
-        "import { loaderDeps, validateSearch } from './routes/search.contract';",
-        "import { routeTree } from './modern-tanstack/index/router.gen';",
-        '',
-        'async function main() {',
-        'const [appRoute] = routeTree.children;',
-        'const [userRoute, docsRoute] = appRoute.children;',
-        'if (runtimeState.adapterCalls.length !== 1) throw new Error("nested loader was not adapted");',
-        'if (userRoute.options.validateSearch !== validateSearch) throw new Error("search validator was not wired");',
-        'if (userRoute.options.loaderDeps !== loaderDeps) throw new Error("loader dependencies were not wired");',
-        'if (userRoute.options.staticData.modernRouteLoader !== loader) throw new Error("nested static loader was not wired");',
-        'if (userRoute.options.staticData.modernRouteAction !== action) throw new Error("nested static action was not wired");',
-        'const user = await userRoute.options.loader({});',
-        'if (user.userId !== "42") throw new Error("nested loader result was lost");',
-        'if (userRoute.options.path !== "users/$userId") throw new Error("required route param was not translated");',
-        'if (docsRoute.options.path !== "docs/$") throw new Error("splat route was not translated");',
-        'const search = userRoute.options.validateSearch({});',
-        'if (search.tab !== "overview") throw new Error("search contract returned the wrong value");',
-        '}',
-        'void main();',
-      ].join('\n'),
-    });
-  });
-
-  test('strictly compiles generated routes against installed router declarations', async () => {
-    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-types-'));
-    const srcDirectory = path.join(tempDir, 'src');
-    const routerGenTs = await generateComprehensiveRouterGen(srcDirectory);
-
-    await compileGeneratedRouterAgainstInstalledDeclarations({
-      projectDirectory: tempDir,
-      routerGenTs,
-    });
-  });
-
-  test('passes the generated-artifact lint contract', async () => {
-    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-types-'));
-    const srcDirectory = path.join(tempDir, 'src');
-    const routerGenTs = await generateComprehensiveRouterGen(srcDirectory);
-    const routerGenPath = path.join(
-      srcDirectory,
-      'modern-tanstack',
-      'golden',
-      'router.gen.ts',
-    );
-
-    await mkdir(path.dirname(routerGenPath), { recursive: true });
-    await writeFile(routerGenPath, routerGenTs);
-
-    const { stderr, stdout } = await execFileAsync(
-      process.execPath,
-      [
-        oxlintCliPath,
-        routerGenPath,
-        '--config',
-        routerGenOxlintConfigPath,
-        '--no-ignore',
-        '--report-unused-disable-directives-severity',
-        'error',
-        '--format',
-        'unix',
-      ],
-      { cwd: tempDir },
-    );
-
-    expect(`${stdout}${stderr}`).toBe('');
-  });
-
-  test('executes localized aliases with typed children and correct parents', async () => {
-    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-types-'));
-    const srcDirectory = path.join(tempDir, 'src');
-
-    const { routerGenTs } = await generateTanstackRouterTypesSourceForEntry({
-      appContext: {
-        srcDirectory,
-        internalSrcAlias: '@/_',
-      } as any,
-      entryName: 'index',
-      routes: [
-        {
-          type: 'nested',
-          id: 'layout',
-          isRoot: true,
-          children: [
-            {
-              type: 'nested',
-              id: '(lang)/layout',
-              path: ':lang',
-              children: [
-                {
-                  type: 'nested',
-                  id: '(lang)/products/(slug)/page',
-                  path: 'products/:slug',
-                },
-                {
-                  type: 'nested',
-                  id: '(lang)/products/(slug)/page__localised_produkty_slug',
-                  path: 'produkty/:slug',
-                },
-                {
-                  type: 'nested',
-                  id: '(lang)/optional/(slug$)/page__localised_volitelne_slug',
-                  path: 'volitelne/:slug?',
-                },
-              ],
-            },
-          ],
-        },
-      ] as any,
-    });
-
-    await compileAndRunGeneratedRouter({
-      projectDirectory: tempDir,
-      routerGenTs,
-      runtimeCheck: [
-        "import { routeTree } from './modern-tanstack/index/router.gen';",
-        '',
-        'const [localeRoute] = routeTree.children;',
-        'const [productRoute, localizedProductRoute, optionalRoute] = localeRoute.children;',
-        'if (localeRoute.options.path !== "$lang") throw new Error("locale param was not translated");',
-        'if (productRoute.options.path !== "products/$slug") throw new Error("product param was not translated");',
-        'if (localizedProductRoute.options.path !== "produkty/$slug") throw new Error("localized param was not translated");',
-        'if (optionalRoute.options.path !== "volitelne/{-$slug}") throw new Error("optional param was not translated");',
-        'for (const child of localeRoute.children) {',
-        '  if (child.options.getParentRoute() !== localeRoute) throw new Error("localized child points at the wrong parent");',
-        '}',
-      ].join('\n'),
-    });
-  });
-});
-
-describe('collectCanonicalRoutesForEntry', () => {
-  let tempDir: string | undefined;
-
-  afterEach(async () => {
-    if (tempDir) {
-      await rm(tempDir, { recursive: true, force: true });
-      tempDir = undefined;
-    }
-  });
-
-  test('returns null for a route tree with no locale param and no canonical metadata', () => {
-    const result = collectCanonicalRoutesForEntry([
-      {
-        type: 'nested',
-        id: 'layout',
-        isRoot: true,
-        children: [
-          {
-            type: 'nested',
-            id: 'about/page',
-            path: 'about',
-          },
-          {
-            type: 'nested',
-            id: 'contact/page',
-            path: 'contact',
-          },
-        ],
-      },
-    ] as any);
-
-    expect(result).toBeNull();
-  });
-
-  test('ignores a leading :lang param when the locale-param heuristic is disabled (no plugin-i18n)', async () => {
+  test('maps a locale-prefixed route tree to the canonical paths consumers navigate to', () => {
     const routes = [
       {
         type: 'nested',
@@ -893,257 +392,38 @@ describe('collectCanonicalRoutesForEntry', () => {
             id: '(lang)/layout',
             path: ':lang',
             children: [
+              { type: 'nested', id: '(lang)/page', index: true },
+              { type: 'nested', id: '(lang)/about/page', path: 'about' },
               {
                 type: 'nested',
-                id: '(lang)/about/page',
-                path: 'about',
+                id: '(lang)/optional/(slug$)/page',
+                path: 'optional/:slug?',
               },
+              { type: 'nested', id: '(lang)/files/page', path: 'files/*' },
             ],
           },
         ],
       },
     ] as any;
 
-    // Without plugin-i18n, a hand-rolled `/:lang/` param must NOT trigger the
-    // i18n surface (the emitted module augmentation would break typechecking).
+    // Without plugin-i18n installed, a hand-rolled `/:lang/` param must NOT
+    // produce a canonical surface — the emitted module augmentation would
+    // break typechecking in an app that never opted into i18n.
     expect(
       collectCanonicalRoutesForEntry(routes, { localeParamHeuristic: false }),
     ).toBeNull();
-    // With plugin-i18n installed the heuristic strips the locale prefix.
-    const result = collectCanonicalRoutesForEntry(routes, {
-      localeParamHeuristic: true,
-    });
-    expect(result).not.toBeNull();
-    expect(Object.keys(result!)).toEqual(['/about']);
-
-    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-canonical-'));
-    await typecheckCanonicalRegisterContract({
-      canonicalRoutes: result!,
-      contractLines: [
-        "const aboutParams: UltramodernCanonicalRoutes['/about'] = {};",
-        '// @ts-expect-error canonical routes without params reject unexpected properties',
-        "const invalidAboutParams: UltramodernCanonicalRoutes['/about'] = { slug: 'unexpected' };",
-        'void aboutParams;',
-        'void invalidAboutParams;',
-      ],
-      projectDirectory: tempDir,
-    });
-  });
-
-  test('still honors modernCanonicalPath metadata when the heuristic is disabled', async () => {
-    const result = collectCanonicalRoutesForEntry(
-      [
-        {
-          type: 'nested',
-          id: 'layout',
-          isRoot: true,
-          children: [
-            {
-              type: 'nested',
-              id: '(lang)/products/(slug)/page',
-              path: 'products/:slug',
-              modernCanonicalPath: '/products/:slug',
-            },
-          ],
-        },
-      ] as any,
-      { localeParamHeuristic: false },
-    );
 
+    const result = collectCanonicalRoutesForEntry(routes);
     expect(result).not.toBeNull();
-    expect(Object.keys(result!)).toEqual(['/products/$slug']);
-
-    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-canonical-'));
-    await typecheckCanonicalRegisterContract({
-      canonicalRoutes: result!,
-      contractLines: [
-        "const productParams: UltramodernCanonicalRoutes['/products/$slug'] = { slug: 'tractor' };",
-        '// @ts-expect-error a required canonical route param cannot be omitted',
-        "const missingProductParams: UltramodernCanonicalRoutes['/products/$slug'] = {};",
-        '// @ts-expect-error canonical route params retain their string type',
-        "const invalidProductParams: UltramodernCanonicalRoutes['/products/$slug'] = { slug: 42 };",
-        'void productParams;',
-        'void missingProductParams;',
-        'void invalidProductParams;',
-      ],
-      projectDirectory: tempDir,
-    });
-  });
-
-  test('strips leading :lang param and maps index under :lang to "/"', async () => {
-    const result = collectCanonicalRoutesForEntry([
-      {
-        type: 'nested',
-        id: 'layout',
-        isRoot: true,
-        children: [
-          {
-            type: 'nested',
-            id: '(lang)/layout',
-            path: ':lang',
-            children: [
-              {
-                type: 'nested',
-                id: '(lang)/page',
-                index: true,
-              },
-              {
-                type: 'nested',
-                id: '(lang)/about/page',
-                path: 'about',
-              },
-            ],
-          },
-        ],
-      },
-    ] as any);
-
-    expect(result).not.toBeNull();
-    expect(Object.keys(result!)).toEqual(['/', '/about']);
-
-    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-canonical-'));
-    await typecheckCanonicalRegisterContract({
-      canonicalRoutes: result!,
-      contractLines: [
-        "const rootParams: UltramodernCanonicalRoutes['/'] = {};",
-        "const aboutParams: UltramodernCanonicalRoutes['/about'] = {};",
-        '// @ts-expect-error index canonical routes reject unexpected params',
-        "const invalidRootParams: UltramodernCanonicalRoutes['/'] = { slug: 'unexpected' };",
-        'void rootParams;',
-        'void aboutParams;',
-        'void invalidRootParams;',
-      ],
-      projectDirectory: tempDir,
-    });
-  });
-
-  test('converts :slug to $slug with required params type', async () => {
-    const result = collectCanonicalRoutesForEntry([
-      {
-        type: 'nested',
-        id: 'layout',
-        isRoot: true,
-        children: [
-          {
-            type: 'nested',
-            id: '(lang)/layout',
-            path: ':lang',
-            children: [
-              {
-                type: 'nested',
-                id: '(lang)/products/(slug)/page',
-                path: 'products/:slug',
-              },
-            ],
-          },
-        ],
-      },
-    ] as any);
-
-    expect(result).not.toBeNull();
-    expect(Object.keys(result!)).toEqual(['/products/$slug']);
-
-    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-canonical-'));
-    await typecheckCanonicalRegisterContract({
-      canonicalRoutes: result!,
-      contractLines: [
-        "const productParams: UltramodernCanonicalRoutes['/products/$slug'] = { slug: 'tractor' };",
-        '// @ts-expect-error a required slug cannot be omitted',
-        "const missingProductParams: UltramodernCanonicalRoutes['/products/$slug'] = {};",
-        'void productParams;',
-        'void missingProductParams;',
-      ],
-      projectDirectory: tempDir,
-    });
-  });
-
-  test('converts :slug? to optional {-$slug} with optional params type', async () => {
-    const result = collectCanonicalRoutesForEntry([
-      {
-        type: 'nested',
-        id: 'layout',
-        isRoot: true,
-        children: [
-          {
-            type: 'nested',
-            id: '(lang)/layout',
-            path: ':lang',
-            children: [
-              {
-                type: 'nested',
-                id: '(lang)/optional/(slug$)/page',
-                path: 'optional/:slug?',
-              },
-            ],
-          },
-        ],
-      },
-    ] as any);
-
-    expect(result).not.toBeNull();
-    expect(Object.keys(result!)).toEqual(['/optional/{-$slug}']);
-
-    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-canonical-'));
-    await typecheckCanonicalRegisterContract({
-      canonicalRoutes: result!,
-      contractLines: [
-        "const omittedOptionalParams: UltramodernCanonicalRoutes['/optional/{-$slug}'] = {};",
-        "const presentOptionalParams: UltramodernCanonicalRoutes['/optional/{-$slug}'] = { slug: 'tractor' };",
-        '// @ts-expect-error optional canonical params still retain their string type',
-        "const invalidOptionalParams: UltramodernCanonicalRoutes['/optional/{-$slug}'] = { slug: 42 };",
-        'void omittedOptionalParams;',
-        'void presentOptionalParams;',
-        'void invalidOptionalParams;',
-      ],
-      projectDirectory: tempDir,
-    });
-  });
-
-  test('converts * splat to $ with optional _splat param', async () => {
-    const result = collectCanonicalRoutesForEntry([
-      {
-        type: 'nested',
-        id: 'layout',
-        isRoot: true,
-        children: [
-          {
-            type: 'nested',
-            id: '(lang)/layout',
-            path: ':lang',
-            children: [
-              {
-                type: 'nested',
-                id: '(lang)/files/page',
-                path: 'files/*',
-              },
-            ],
-          },
-        ],
-      },
-    ] as any);
-
-    expect(result).not.toBeNull();
-    expect(Object.keys(result!)).toEqual(['/files/$']);
-
-    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-canonical-'));
-    await typecheckCanonicalRegisterContract({
-      canonicalRoutes: result!,
-      contractLines: [
-        "const emptySplatParams: UltramodernCanonicalRoutes['/files/$'] = {};",
-        "const splatParams: UltramodernCanonicalRoutes['/files/$'] = { _splat: 'guides/intro' };",
-        '// @ts-expect-error splat params retain their string type',
-        "const invalidSplatParams: UltramodernCanonicalRoutes['/files/$'] = { _splat: 42 };",
-        'void emptySplatParams;',
-        'void splatParams;',
-        'void invalidSplatParams;',
-      ],
-      projectDirectory: tempDir,
-    });
+    expect(Object.keys(result!)).toEqual([
+      '/',
+      '/about',
+      '/files/$',
+      '/optional/{-$slug}',
+    ]);
   });
 
-  test('collapses localized variants with shared modernCanonicalPath to one canonical key', async () => {
-    // This reuses the same fixture shape as the 'preserves typed child trees'
-    // test but adds modernCanonicalPath fields as plugin-i18n now emits.
+  test('collapses localized variants to one canonical key with typed params', async () => {
     const result = collectCanonicalRoutesForEntry([
       {
         type: 'nested',
@@ -1180,69 +460,44 @@ describe('collectCanonicalRoutesForEntry', () => {
     ] as any);
 
     expect(result).not.toBeNull();
-    // Two physical variants share the same canonical path — only one entry.
-    const keys = Object.keys(result!);
-    // /products/$slug and /optional/{-$slug} — exactly 2 keys with params
-    expect(keys.filter(k => k.startsWith('/products'))).toHaveLength(1);
-    expect(keys).toHaveLength(2);
-    expect(keys).toEqual(['/optional/{-$slug}', '/products/$slug']);
-    // The Czech localized path must not appear as a separate key.
+    expect(Object.keys(result!)).toEqual([
+      '/optional/{-$slug}',
+      '/products/$slug',
+    ]);
     expect('/produkty/$slug' in result!).toBe(false);
 
     tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-canonical-'));
     await typecheckCanonicalRegisterContract({
-      canonicalRoutes: result!,
+      canonicalRoutes: {
+        '/': 'Record<string, never>',
+        '/files/$': '{ _splat?: string }',
+        ...result!,
+      },
       contractLines: [
+        "const rootParams: UltramodernCanonicalRoutes['/'] = {};",
+        '// @ts-expect-error index canonical routes reject unexpected params',
+        "const invalidRootParams: UltramodernCanonicalRoutes['/'] = { slug: 'unexpected' };",
         "const productParams: UltramodernCanonicalRoutes['/products/$slug'] = { slug: 'tractor' };",
         "const optionalParams: UltramodernCanonicalRoutes['/optional/{-$slug}'] = {};",
+        "const presentOptionalParams: UltramodernCanonicalRoutes['/optional/{-$slug}'] = { slug: 'tractor' };",
+        '// @ts-expect-error optional canonical params still retain their string type',
+        "const invalidOptionalParams: UltramodernCanonicalRoutes['/optional/{-$slug}'] = { slug: 42 };",
+        "const splatParams: UltramodernCanonicalRoutes['/files/$'] = { _splat: 'guides/intro' };",
         '// @ts-expect-error localized physical variants do not become canonical keys',
         "declare const localizedParams: UltramodernCanonicalRoutes['/produkty/$slug'];",
         '// @ts-expect-error the deduplicated product route still requires its param',
         "const missingProductParams: UltramodernCanonicalRoutes['/products/$slug'] = {};",
+        'void rootParams;',
         'void productParams;',
         'void optionalParams;',
+        'void presentOptionalParams;',
+        'void splatParams;',
+        'void invalidRootParams;',
+        'void invalidOptionalParams;',
         'void localizedParams;',
         'void missingProductParams;',
       ],
       projectDirectory: tempDir,
     });
   });
-
-  test('output is sorted alphabetically by canonical key', () => {
-    const result = collectCanonicalRoutesForEntry([
-      {
-        type: 'nested',
-        id: 'layout',
-        isRoot: true,
-        children: [
-          {
-            type: 'nested',
-            id: '(lang)/layout',
-            path: ':lang',
-            children: [
-              {
-                type: 'nested',
-                id: '(lang)/products/(slug)/page',
-                path: 'products/:slug',
-              },
-              {
-                type: 'nested',
-                id: '(lang)/about/page',
-                path: 'about',
-              },
-              {
-                type: 'nested',
-                id: '(lang)/page',
-                index: true,
-              },
-            ],
-          },
-        ],
-      },
-    ] as any);
-
-    expect(result).not.toBeNull();
-    const keys = Object.keys(result!);
-    expect(keys).toEqual([...keys].sort((a, b) => a.localeCompare(b)));
-  });
 });