@bleedingdev/modern-js-plugin-tanstack 3.9.0-ultramodern.3 → 3.9.0-ultramodern.5

package/tests/router/cli.test.ts

@@ -4,6 +4,7 @@ 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 {
@@ -20,6 +21,16 @@ 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 };
+    },
+  };
+}
+
 async function typecheckGeneratedRegistration(options: {
   entries: string[];
   generatedDirName: string;
@@ -201,6 +212,92 @@ describe('tanstack router cli plugin', () => {
     }
   });
 
+  test.each([
+    { sourceDirectory: 'src', generatedDirName: undefined },
+    { sourceDirectory: 'client', generatedDirName: 'routing-types' },
+  ])('excludes its generated declaration from server roots only when installed: %s', async ({
+    sourceDirectory,
+    generatedDirName,
+  }) => {
+    tempDir = await fs.realpath(
+      await mkdtemp(path.join(tmpdir(), 'tanstack-server-roots-')),
+    );
+    const srcDirectory = path.join(tempDir, sourceDirectory);
+    const generatedDirectory = generatedDirName ?? 'modern-tanstack';
+    const declaration = path.join(
+      srcDirectory,
+      generatedDirectory,
+      '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', sourceDirectory],
+    });
+    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, generatedDirectory, 'main/router.gen.ts'),
+      "import { page } from '../../routes/page';\nexport const router = { page };\n",
+    );
+    await writeTanstackRegisterFile({
+      entries: ['main'],
+      srcDirectory,
+      generatedDirName,
+    });
+
+    await expect(compile(tempDir, {}, compileOptions)).rejects.toThrow(
+      /missing-browser-only-types/,
+    );
+
+    const previousExclusions = [path.join(tempDir, 'other-client.d.ts')];
+    const api = {
+      ...createAppContextApi({
+        srcDirectory,
+        serverCompileExcludedFiles: previousExclusions,
+      }),
+      _internalRuntimePlugins: () => {},
+      checkEntryPoint: () => {},
+      config: () => {},
+      modifyEntrypoints: () => {},
+      generateEntryCode: () => {},
+      onFileChanged: () => {},
+      modifyFileSystemRoutes: () => {},
+      onBeforeGenerateRoutes: () => {},
+    };
+    tanstackRouterPlugin({ generatedDirName }).setup!(api as never);
+    const excludeFiles = api.getAppContext().serverCompileExcludedFiles;
+    expect(excludeFiles).toEqual([...previousExclusions, declaration]);
+    expect(previousExclusions).toEqual([
+      path.join(tempDir, 'other-client.d.ts'),
+    ]);
+    await compile(tempDir, {}, { ...compileOptions, excludeFiles });
+    expect(
+      await fs.pathExists(path.join(compileOptions.distDir, 'api/index.js')),
+    ).toBe(true);
+    expect(
+      await fs.pathExists(path.join(compileOptions.distDir, sourceDirectory)),
+    ).toBe(false);
+  });
+
   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');
@@ -345,7 +442,7 @@ describe('tanstack router cli plugin', () => {
 
     const taps: Record<string, any> = {};
     const api = {
-      getAppContext: () => ({
+      ...createAppContextApi({
         srcDirectory,
         distDirectory,
         metaName: 'modern-js',
@@ -446,7 +543,7 @@ describe('tanstack router cli plugin', () => {
   test('injects the framework-resolving router wrapper for non-file-route entrypoints', async () => {
     const taps: Record<string, any> = {};
     const api = {
-      getAppContext: () => ({
+      ...createAppContextApi({
         srcDirectory: '/tmp/app/src',
         metaName: 'modern-js',
         serverRoutes: [{ entryName: 'custom', urlPath: '/' }],
@@ -508,7 +605,7 @@ describe('tanstack router cli plugin', () => {
   test('leaves built-in and foreign-owned route entrypoints to their own router', () => {
     const taps: Record<string, any> = {};
     const api = {
-      getAppContext: () => ({
+      ...createAppContextApi({
         srcDirectory: '/tmp/app/src',
         metaName: 'modern-js',
         serverRoutes: [{ entryName: 'home', urlPath: '/' }],
@@ -588,7 +685,7 @@ describe('tanstack router cli plugin', () => {
   test('source.include covers the package dist and TanStack runtime deps without string surgery', () => {
     const taps: Record<string, any> = {};
     const api = {
-      getAppContext: () => ({
+      ...createAppContextApi({
         srcDirectory: '/tmp/app/src',
         serverRoutes: [],
       }),
@@ -624,7 +721,9 @@ describe('tanstack router cli plugin', () => {
     // 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');
+    expect(stringEntries[0]).not.toMatch(
+      /[\\/]dist[\\/]esm(?:-node)?(?:[\\/]|$)/,
+    );
   });
 
   test('emits the plugin-i18n augmentation only when plugin-i18n is registered', async () => {
@@ -666,7 +765,7 @@ describe('tanstack router cli plugin', () => {
 
       const taps: Record<string, any> = {};
       const api = {
-        getAppContext: () => ({
+        ...createAppContextApi({
           srcDirectory,
           internalSrcAlias: '@/_',
           entrypoints: [entrypoint],
@@ -763,7 +862,7 @@ describe('tanstack router cli plugin', () => {
 
     const taps: Record<string, any> = {};
     const api = {
-      getAppContext: () => ({
+      ...createAppContextApi({
         srcDirectory,
         internalSrcAlias: '@/_',
         entrypoints: [entrypoint],
@@ -828,7 +927,7 @@ describe('tanstack router cli plugin', () => {
       __modernRoutesDir: 'views',
     } as any as Entrypoint;
     const api = {
-      getAppContext: () => ({
+      ...createAppContextApi({
         srcDirectory: '/tmp/app/src',
         internalSrcAlias: '@/_',
         entrypoints: [entrypoint],
@@ -876,7 +975,7 @@ describe('tanstack router cli plugin', () => {
   test('can opt out of Modern-owned route code splitting', async () => {
     const taps: Record<string, any> = {};
     const api = {
-      getAppContext: () => ({
+      ...createAppContextApi({
         srcDirectory: '/tmp/app/src',
         serverRoutes: [],
       }),

package/tests/router/dataMutation.test.tsx

@@ -105,54 +105,14 @@ describe('tanstack data mutation fetcher', () => {
     states.length = 0;
   });
 
-  test('tracks submitting and loading phases for mutation submit', async () => {
-    const actionResult = createDeferred<Response>();
-    const invalidateResult = createDeferred<void>();
-
-    currentRouter = createRouter({
-      action: async () => actionResult.promise,
-      invalidate: async () => invalidateResult.promise,
-    });
-
-    render(<FetcherHarness />);
-    expect(screen.getByTestId('state').textContent).toBe('idle');
-
-    let submitPromise: Promise<void> | undefined;
-    act(() => {
-      submitPromise = latestFetcher!.submit(
-        { amount: 2 },
-        { method: 'post', action: '/mutation' },
-      );
-    });
-
-    await waitFor(() => {
-      expect(screen.getByTestId('state').textContent).toBe('submitting');
-    });
-
-    actionResult.resolve(
-      new Response(JSON.stringify({ count: 2 }), {
-        headers: {
-          'Content-Type': 'application/json',
-        },
-      }),
-    );
-
-    await waitFor(() => {
-      expect(screen.getByTestId('state').textContent).toBe('loading');
-    });
-
-    invalidateResult.resolve();
-
-    await act(async () => {
-      await submitPromise;
-    });
-
-    expect(screen.getByTestId('state').textContent).toBe('idle');
-    expect(screen.getByTestId('data').textContent).toBe('{"count":2}');
-    expect(states).toEqual(['idle', 'submitting', 'loading', 'idle']);
-  });
-
-  test('defaults fetcher submit without method to mutation state', async () => {
+  test.each([
+    { amount: 2, count: 2, method: 'post' as const, name: 'explicit method' },
+    { amount: 1, count: 1, method: undefined, name: 'default method' },
+  ])('tracks submitting/loading phases with the $name', async ({
+    amount,
+    count,
+    method,
+  }) => {
     const actionResult = createDeferred<Response>();
     const invalidateResult = createDeferred<void>();
     const action = rstest.fn(async () => actionResult.promise);
@@ -170,8 +130,11 @@ describe('tanstack data mutation fetcher', () => {
     let submitPromise: Promise<void> | undefined;
     act(() => {
       submitPromise = latestFetcher!.submit(
-        { amount: 1 },
-        { action: '/mutation' },
+        { amount },
+        {
+          ...(method === undefined ? {} : { method }),
+          action: '/mutation',
+        },
       );
     });
 
@@ -182,7 +145,7 @@ describe('tanstack data mutation fetcher', () => {
     expect(loader).not.toHaveBeenCalled();
 
     actionResult.resolve(
-      new Response(JSON.stringify({ count: 1 }), {
+      new Response(JSON.stringify({ count }), {
         headers: {
           'Content-Type': 'application/json',
         },
@@ -200,44 +163,10 @@ describe('tanstack data mutation fetcher', () => {
     });
 
     expect(screen.getByTestId('state').textContent).toBe('idle');
-    expect(screen.getByTestId('data').textContent).toBe('{"count":1}');
-    expect(states).toEqual(['idle', 'submitting', 'loading', 'idle']);
-  });
-
-  test('passes built href and matched route params to mutation actions', async () => {
-    const action = rstest.fn(
-      async ({ request, params }: Parameters<RouteHandler>[0]) => ({
-        params,
-        requestUrl: request.url,
-      }),
+    expect(screen.getByTestId('data').textContent).toBe(
+      JSON.stringify({ count }),
     );
-    currentRouter = createRouter({
-      action,
-      params: { userId: '42' },
-    });
-
-    render(<FetcherHarness />);
-
-    await act(async () => {
-      await latestFetcher!.submit(
-        { amount: 2 },
-        {
-          method: 'post',
-          action: '/users/42?tab=edit#details',
-        },
-      );
-    });
-
-    expect(action).toHaveBeenCalledTimes(1);
-    const actionArgs = action.mock.calls[0][0];
-    const expectedRequestUrl = `${window.location.origin}/users/42?tab=edit#details`;
-    expect(actionArgs.params).toEqual({ userId: '42' });
-    expect(actionArgs.request.url).toBe(expectedRequestUrl);
-    expect(latestFetcher?.data).toEqual({
-      params: { userId: '42' },
-      requestUrl: expectedRequestUrl,
-    });
-    expect(currentRouter.invalidate).toHaveBeenCalledTimes(1);
+    expect(states).toEqual(['idle', 'submitting', 'loading', 'idle']);
   });
 
   test('surfaces non-2xx action responses as fetcher errors', async () => {
@@ -460,37 +389,4 @@ describe('tanstack data mutation fetcher', () => {
       globalThis.FormData = NativeFormData;
     }
   });
-
-  test('does not throw for Form submit with non-2xx response and still invalidates', async () => {
-    const action = rstest.fn(
-      async () =>
-        new Response(JSON.stringify({ message: 'invalid amount' }), {
-          status: 422,
-          headers: {
-            'Content-Type': 'application/json',
-          },
-        }),
-    );
-    currentRouter = createRouter({
-      action,
-    });
-
-    render(
-      <Form method="post" action="/mutation">
-        <button type="submit">submit</button>
-      </Form>,
-    );
-
-    const form = document.querySelector('form');
-    expect(form).toBeTruthy();
-
-    await act(async () => {
-      fireEvent.submit(form!);
-    });
-
-    await waitFor(() => {
-      expect(action).toHaveBeenCalledTimes(1);
-      expect(currentRouter.invalidate).toHaveBeenCalledTimes(1);
-    });
-  });
 });

package/tests/router/flightSerialization.roundtrip.test.tsx

@@ -45,21 +45,22 @@ test('round-trips TanStack RSC flight values across supported value types', asyn
   const circular: Record<string, unknown> = { marker: 'circular' };
   circular.self = circular;
 
+  const rscProxy = createRscProxy(() => ({ slot: 'server' }), {
+    renderable: true,
+    stream: createStream(),
+  }) as React.ReactElement & Record<PropertyKey, unknown>;
+
   const mapValue = new Map<unknown, unknown>([
     ['primitive', 1],
     ['shared', shared],
     [shared, circular],
+    ['rscProxy', rscProxy],
   ]);
   mapValue.set('self', mapValue);
 
-  const setValue = new Set<unknown>(['set-item', shared, circular]);
+  const setValue = new Set<unknown>(['set-item', shared, circular, rscProxy]);
   setValue.add(setValue);
 
-  const rscProxy = createRscProxy(() => ({ slot: 'server' }), {
-    renderable: true,
-    stream: createStream(),
-  }) as React.ReactElement & Record<PropertyKey, unknown>;
-
   const fixture: RoundTripFixture = {
     bigintValue: 9007199254740993n,
     booleanValue: true,
@@ -115,12 +116,14 @@ test('round-trips TanStack RSC flight values across supported value types', asyn
   expect(revived.mapValue.get('shared')).toBe(revived.sharedA);
   expect(revived.mapValue.get(revived.sharedA)).toBe(revived.circular);
   expect(revived.mapValue.get('self')).toBe(revived.mapValue);
+  expect(isValidElement(revived.mapValue.get('rscProxy'))).toBe(true);
 
   expect(revived.setValue).toBeInstanceOf(Set);
   expect(revived.setValue).not.toBe(setValue);
   expect(revived.setValue.has('set-item')).toBe(true);
   expect(revived.setValue.has(revived.sharedA)).toBe(true);
   expect(revived.setValue.has(revived.circular)).toBe(true);
+  expect([...revived.setValue].some(value => isValidElement(value))).toBe(true);
   expect(revived.setValue.has(revived.setValue)).toBe(true);
 
   expect(serialized.rscProxy).not.toBe(rscProxy);

package/tests/router/generateRouteArtifacts.test.ts

@@ -1,19 +1,11 @@
-// Behavioral coverage for the headless routes-generate entry point: the
-// export-shape test in cli.test.ts would pass even if the body were
-// reverted, so this file pins the actual prepare-only drive contract —
-// createRunOptions against the app dir, cli.init with build-command
-// semantics, the MODERN_ARGV gate that makes analyze.onPrepare fire
-// generateEntryCode, and the absolute config-file resolution that keeps
-// headless runs (cwd != appDirectory) from feeding `false` into node's
-// path APIs.
+// The headless entry must drive the real TanStack artifact writer. Checking
+// only the createRunOptions/cli.init choreography would allow a no-op CLI to
+// pass while leaving router.gen.ts stale or missing.
 const createRunOptionsMock = rstest.fn(async (options: unknown) => ({
   mockRunOptions: true,
   received: options,
 }));
-const cliInitMock = rstest.fn(async (options: unknown) => ({
-  appContext: {},
-  received: options,
-}));
+const cliInitMock = rstest.fn(async () => ({ appContext: {} }));
 
 rstest.mock('@modern-js/app-tools/cli/run', () => ({
   createRunOptions: createRunOptionsMock,
@@ -26,7 +18,10 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { INTERNAL_RUNTIME_PLUGINS } from '@modern-js/utils';
-import { generateTanstackRouteArtifacts } from '../../src/cli';
+import {
+  generateTanstackRouteArtifacts,
+  writeTanstackRouterTypesForEntries,
+} from '../../src/cli';
 
 function makeAppDir(withConfig: boolean): string {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'tanstack-routes-gen-'));
@@ -46,9 +41,55 @@ describe('generateTanstackRouteArtifacts (headless routes-generate)', () => {
     cliInitMock.mockClear();
   });
 
-  it('drives a prepare-only cli.init with build-command semantics', async () => {
+  it('writes a real route artifact through the prepare-only CLI drive', async () => {
     const previousArgv = process.env.MODERN_ARGV;
     const appDirectory = makeAppDir(true);
+    const srcDirectory = path.join(appDirectory, 'src');
+    const componentPath = path.join(srcDirectory, 'routes', 'page.tsx');
+    fs.mkdirSync(path.dirname(componentPath), { recursive: true });
+    fs.writeFileSync(
+      componentPath,
+      'export default function Page() { return null; }\n',
+      'utf-8',
+    );
+
+    const runOptions = {
+      cwd: appDirectory,
+      version: '9.9.9-test',
+      internalPlugins: INTERNAL_RUNTIME_PLUGINS,
+      configFile: path.resolve(appDirectory, 'modern.config'),
+    };
+    createRunOptionsMock.mockResolvedValue({
+      mockRunOptions: true,
+      received: runOptions,
+    });
+    cliInitMock.mockImplementation(async () => {
+      await writeTanstackRouterTypesForEntries({
+        appContext: {
+          srcDirectory,
+          internalSrcAlias: '@/_',
+          entrypoints: [{ entryName: 'main', isMainEntry: true }],
+        } as any,
+        routesByEntry: {
+          main: [
+            {
+              type: 'nested',
+              id: 'layout',
+              isRoot: true,
+              children: [
+                {
+                  type: 'nested',
+                  id: 'page',
+                  index: true,
+                  _component: '@/_/routes/page',
+                },
+              ],
+            },
+          ] as any,
+        },
+      });
+      return { appContext: {} };
+    });
 
     try {
       await generateTanstackRouteArtifacts({
@@ -61,26 +102,25 @@ describe('generateTanstackRouteArtifacts (headless routes-generate)', () => {
         string,
         unknown
       >;
-      expect(runOptionsArg.cwd).toBe(appDirectory);
-      expect(runOptionsArg.version).toBe('9.9.9-test');
-      expect(runOptionsArg.internalPlugins).toBe(INTERNAL_RUNTIME_PLUGINS);
-
-      // The config file is resolved to an absolute base path against the app
-      // directory (not process.cwd()). Without this, a headless run from a
-      // different cwd finds no config, `findExists` returns `false`, and that
-      // boolean reaches `path.isAbsolute` deep inside plugin/cli.
-      expect(runOptionsArg.configFile).toBe(
-        path.resolve(appDirectory, 'modern.config'),
-      );
+      expect(runOptionsArg).toEqual(runOptions);
 
       expect(cliInitMock).toHaveBeenCalledTimes(1);
       const initArg = cliInitMock.mock.calls[0][0] as Record<string, unknown>;
       expect(initArg.command).toBe('build');
       expect(initArg.mockRunOptions).toBe(true);
-
-      // checkIsBuildCommands() resolves the command from MODERN_ARGV — this
-      // is what lets analyze.onPrepare fire generateEntryCode headlessly.
       expect(process.env.MODERN_ARGV).toBe('node modern build');
+
+      const routerArtifact = fs.readFileSync(
+        path.join(srcDirectory, 'modern-tanstack', 'main', 'router.gen.ts'),
+        'utf-8',
+      );
+      const registerArtifact = fs.readFileSync(
+        path.join(srcDirectory, 'modern-tanstack', 'register.gen.d.ts'),
+        'utf-8',
+      );
+      expect(routerArtifact).toContain('createRootRouteWithContext');
+      expect(routerArtifact).toContain('routeTree');
+      expect(registerArtifact).toContain('./main/router.gen');
     } finally {
       fs.rmSync(appDirectory, { force: true, recursive: true });
       if (previousArgv === undefined) {
@@ -91,7 +131,7 @@ describe('generateTanstackRouteArtifacts (headless routes-generate)', () => {
     }
   });
 
-  it('throws a clear error (never a boolean path crash) when no config file exists', async () => {
+  it('throws a clear error when no config file exists', async () => {
     const appDirectory = makeAppDir(false);
 
     try {

package/tests/router/hooks.test.ts

@@ -3,13 +3,11 @@ import {
   routerProviderRegistryHooks,
 } from '@modern-js/runtime/context';
 import * as tanstackHooks from '../../src/runtime/hooks';
-import { applyRouterRuntimeState } from '../../src/runtime/lifecycle';
 import { tanstackRouterPlugin as browserPlugin } from '../../src/runtime/plugin';
 import { tanstackRouterPlugin as nodePlugin } from '../../src/runtime/plugin.node';
-import { getTanstackRouterState } from '../../src/runtime/state';
 
 describe('tanstack router hooks single declaration source', () => {
-  test('re-exports the canonical hook instances owned by @modern-js/runtime', () => {
+  test('re-exports and registers the canonical hook instances', () => {
     // Identity matters: separate instances would split the hook registry
     // between the built-in router wrapper and this provider.
     expect(tanstackHooks.modifyRoutes).toBe(canonicalModifyRoutes);
@@ -19,22 +17,7 @@ describe('tanstack router hooks single declaration source', () => {
     expect(tanstackHooks.modifyRoutes).toBe(
       routerProviderRegistryHooks.modifyRoutes,
     );
-  });
-
-  test('both runtime plugins register the canonical hook registry object', () => {
     expect(browserPlugin().registryHooks).toBe(routerProviderRegistryHooks);
     expect(nodePlugin().registryHooks).toBe(routerProviderRegistryHooks);
   });
 });
-
-describe('tanstack router runtime state accessor', () => {
-  test('returns undefined before a tanstack router instance is created', () => {
-    const context = {};
-
-    applyRouterRuntimeState(context as never, {
-      framework: 'tanstack',
-    });
-
-    expect(getTanstackRouterState(context)).toBeUndefined();
-  });
-});

package/tests/router/loaderBridge.test.ts

@@ -1,8 +1,5 @@
 import { isNotFound, isRedirect } from '@tanstack/react-router';
 import {
-  createRouteStaticData,
-  isAbsoluteUrl,
-  mapSplatParamsForModernLoader,
   modernLoaderToTanstack,
   throwTanstackRedirect,
 } from '../../src/runtime/loaderBridge';
@@ -23,73 +20,6 @@ function catchThrown(fn: () => unknown): unknown {
   throw new Error('expected the function to throw');
 }
 
-describe('throwTanstackRedirect', () => {
-  test('absolute URLs redirect via href (external), not via to', () => {
-    // The old inline codegen handler threw `redirect({ href })` INSIDE a
-    // try block whose catch replaced it with `redirect({ to: absoluteUrl })`,
-    // making TanStack treat the absolute URL as an internal path.
-    const thrown = catchThrown(() =>
-      throwTanstackRedirect('https://example.com/external'),
-    ) as RedirectLike;
-
-    expect(isRedirect(thrown)).toBe(true);
-    expect(thrown.options?.href).toBe('https://example.com/external');
-    expect(thrown.options?.to).toBeUndefined();
-  });
-
-  test('relative paths redirect via to so the basepath rewrite applies', () => {
-    const thrown = catchThrown(() =>
-      throwTanstackRedirect('/dashboard'),
-    ) as RedirectLike;
-
-    expect(isRedirect(thrown)).toBe(true);
-    expect(thrown.options?.to).toBe('/dashboard');
-    expect(thrown.options?.href).toBeUndefined();
-  });
-
-  test('empty location falls back to /', () => {
-    const thrown = catchThrown(() => throwTanstackRedirect('')) as RedirectLike;
-    expect(thrown.options?.to).toBe('/');
-  });
-});
-
-describe('isAbsoluteUrl', () => {
-  test('detects absolute and relative URLs', () => {
-    expect(isAbsoluteUrl('https://example.com/a')).toBe(true);
-    expect(isAbsoluteUrl('mailto:x@example.com')).toBe(true);
-    expect(isAbsoluteUrl('/internal/path')).toBe(false);
-    expect(isAbsoluteUrl('relative')).toBe(false);
-  });
-});
-
-describe('mapSplatParamsForModernLoader', () => {
-  test('maps TanStack _splat to React Router * only for splat routes', () => {
-    expect(
-      mapSplatParamsForModernLoader({ _splat: 'a/b', id: '1' }, true),
-    ).toEqual({ '*': 'a/b', id: '1' });
-    expect(
-      mapSplatParamsForModernLoader({ _splat: 'a/b', id: '1' }, false),
-    ).toEqual({ _splat: 'a/b', id: '1' });
-    expect(mapSplatParamsForModernLoader({ id: '1' }, true)).toEqual({
-      id: '1',
-    });
-  });
-});
-
-describe('createRouteStaticData', () => {
-  test('drops empty fields', () => {
-    const loader = () => null;
-    expect(createRouteStaticData({})).toEqual({});
-    expect(createRouteStaticData({ modernRouteId: '' })).toEqual({});
-    expect(
-      createRouteStaticData({
-        modernRouteId: 'page',
-        modernRouteLoader: loader,
-      }),
-    ).toEqual({ modernRouteId: 'page', modernRouteLoader: loader });
-  });
-});
-
 describe('modernLoaderToTanstack', () => {
   const baseCtx = {
     location: { href: 'http://localhost/products/1' },
@@ -189,13 +119,6 @@ describe('modernLoaderToTanstack', () => {
     expect(isNotFound(thrown)).toBe(true);
   });
 
-  test('preserves returned non-404 error Responses as loader results', async () => {
-    const response = new Response('loader exploded', { status: 500 });
-    const loader = modernLoaderToTanstack({ hasSplat: false }, () => response);
-
-    await expect(loader(baseCtx)).resolves.toBe(response);
-  });
-
   test('translates redirect Responses thrown synchronously by the loader', () => {
     const loader = modernLoaderToTanstack({ hasSplat: false }, () => {
       throw new Response(null, {