@bleedingdev/modern-js-plugin-tanstack 3.5.0-ultramodern.9 → 3.5.0-ultramodern.91

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

@@ -0,0 +1,76 @@
+import type { RouteObject } from '@modern-js/runtime-utils/router';
+import type { AnyRoute, RootRoute as TanstackRootRoute } from '@tanstack/react-router';
+export type RouteParams = Record<string, string>;
+type ModernLoader = (args: {
+    request: Request;
+    params: RouteParams;
+    context?: unknown;
+}) => unknown | Promise<unknown>;
+export type ModernShouldRevalidate = (args: {
+    currentParams: RouteParams;
+    currentUrl: URL;
+    nextParams: RouteParams;
+    nextUrl: URL;
+    defaultShouldRevalidate?: boolean;
+}) => boolean | undefined;
+export type TanstackLoaderContext = {
+    abortController?: AbortController;
+    cause?: string;
+    signal?: AbortSignal;
+    context?: {
+        request?: Request;
+        requestContext?: unknown;
+    };
+    location?: string | {
+        publicHref?: string;
+        href?: string;
+        url?: {
+            href?: string;
+        };
+    };
+    params?: RouteParams;
+    route?: {
+        id?: string;
+    };
+};
+export type RouteRevalidationState = {
+    currentParams?: RouteParams;
+    currentUrl?: URL;
+};
+export type ModernRouteObject = RouteObject & {
+    ErrorBoundary?: unknown;
+    HydrateFallback?: unknown;
+    action?: unknown;
+    clientData?: unknown;
+    component?: unknown;
+    config?: {
+        handle?: Record<string, unknown>;
+    } | unknown;
+    file?: string;
+    handle?: Record<string, unknown>;
+    hasAction?: boolean;
+    hasClientLoader?: boolean;
+    hasLoader?: boolean;
+    inValidSSRRoute?: boolean;
+    isClientComponent?: boolean;
+    lazyImport?: () => unknown;
+    loader?: ModernLoader;
+    loaderDeps?: unknown;
+    pendingComponent?: unknown;
+    shouldRevalidate?: ModernShouldRevalidate;
+    validateSearch?: unknown;
+};
+export type MutableTanstackRoute = AnyRoute & {
+    addChildren: (children: AnyRoute[]) => void;
+    id?: string;
+    options: {
+        component?: unknown;
+    };
+};
+export type TanstackRouteOptions = Record<string, unknown>;
+export type TanstackRootRouteOptions = Record<string, unknown>;
+export type ModernTanstackRootRoute = TanstackRootRoute;
+export type RouteTreeOptions = {
+    rscPayloadRouter?: boolean;
+};
+export {};

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

@@ -1,9 +1 @@
-import type { RouteObject } from '@modern-js/runtime-utils/router';
-import type { AnyRouter, RootRoute as TanstackRootRoute } from '@tanstack/react-router';
-type ModernTanstackRootRoute = TanstackRootRoute;
-type RouteTreeOptions = {
-    rscPayloadRouter?: boolean;
-};
-export declare function createRouteTreeFromRouteObjects(routes: RouteObject[], options?: RouteTreeOptions): ModernTanstackRootRoute;
-export declare function getModernRouteIdsFromMatches(router: AnyRouter): string[];
-export {};
+export { createRouteTreeFromRouteObjects, getModernRouteIdsFromMatches, pickRouteModuleComponent, } from './routeTree/index';

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

@@ -4,11 +4,10 @@
  * `router: { framework: 'tanstack', createRoutes }` in modern.runtime.ts).
  *
  * The CLI plugin injects `{ name: 'router', path: '<pkg>/runtime/router' }`
- * for those entries, so the generated entry code value-imports `routerPlugin`
- * from here. That single import both installs the framework-resolving router
- * plugin of @modern-js/runtime AND registers the TanStack router provider
- * (the './register' side effect) — the registration can therefore never be
- * tree-shaken away from the entry that needs it.
+ * for those entries. This module creates a framework-resolving wrapper whose
+ * app-owned provider realm contains this module graph's TanStack factory.
  */
-import './register';
-export { routerPlugin } from '@modern-js/runtime/router/internal';
+import * as runtimeRouter from '@modern-js/runtime/router/internal';
+type LegacyRouterPlugin = (typeof runtimeRouter)['routerPlugin'];
+export declare const routerPlugin: LegacyRouterPlugin;
+export {};

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

@@ -1,3 +1,2 @@
-import type React from 'react';
 import { type AnyCompositeComponent, type CompositeComponentProps } from './symbols';
-export declare function CompositeComponent<TComp extends AnyCompositeComponent>(props: CompositeComponentProps<TComp>): React.JSX.Element;
+export declare function CompositeComponent<TComp extends AnyCompositeComponent>(props: CompositeComponentProps<TComp>): import("react").JSX.Element;

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

@@ -1,7 +1,7 @@
-export interface ReplayableStreamOptions {
+interface ReplayableStreamOptions {
     signal?: AbortSignal;
 }
-export declare const REPLAYABLE_STREAM_MARKER: unique symbol;
+declare const REPLAYABLE_STREAM_MARKER: unique symbol;
 export declare class ReplayableStream<T = Uint8Array> {
     private source;
     private options;
@@ -22,3 +22,4 @@ export declare class ReplayableStream<T = Uint8Array> {
     isReleased(): boolean;
     createReplayStream(): ReadableStream<T>;
 }
+export {};

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

@@ -1,5 +1,4 @@
-import type React from 'react';
-import { type AnyRenderableServerComponent } from './symbols';
+import type { AnyRenderableServerComponent } from './symbols';
 export declare function RscNodeRenderer({ data, }: {
     data: AnyRenderableServerComponent;
-}): React.JSX.Element;
+}): import("react").JSX.Element;

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

@@ -1,5 +1,5 @@
 import type React from 'react';
-export type SlotImplementations = Record<string, unknown>;
+type SlotImplementations = Record<string, unknown>;
 export declare function useSlotContext(): {
     implementations: SlotImplementations;
     strict: boolean;
@@ -9,3 +9,4 @@ export declare function SlotProvider({ children, implementations, strict, }: {
     implementations: SlotImplementations;
     strict?: boolean;
 }): React.JSX.Element;
+export {};

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

@@ -1,4 +1,5 @@
 import { CompositeComponent } from './CompositeComponent';
+import type { SerializedTanstackRscFlightValue } from './shared';
 import type { AnyCompositeComponent, RscSlotUsageEvent } from './symbols';
 export type { AnyCompositeComponent, AnyRenderableServerComponent, CompositeComponentProps, } from './symbols';
 export { CompositeComponent };
@@ -7,5 +8,6 @@ type SerializedRsc = {
     stream: ReadableStream<Uint8Array>;
     slotUsagesStream?: ReadableStream<RscSlotUsageEvent>;
 };
+export declare function createTanstackRscValueFromFlight(serialized: SerializedTanstackRscFlightValue): AnyCompositeComponent;
 export declare function getTanstackRscSerializationAdapters(): import("@tanstack/router-core").SerializationAdapter<AnyCompositeComponent<Record<string, unknown>, import("react").ReactNode>, SerializedRsc, never>[];
 export declare const rscSerializationAdapter: typeof getTanstackRscSerializationAdapters;

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

@@ -0,0 +1,3 @@
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+export declare function serializeTanstackRscFlightValues(value: unknown, seen?: WeakMap<object, unknown>): unknown;
+export declare function reviveTanstackRscFlightValues(value: unknown, seen?: WeakMap<object, unknown>): Promise<unknown>;

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

@@ -0,0 +1,6 @@
+import type { ServerPayload } from '@modern-js/runtime/context';
+export declare function shouldRedactServerError(status?: number): boolean;
+export declare function serializePayloadError(error: unknown): unknown;
+export declare function isSerializedNotFound(value: unknown): boolean;
+export declare function toRouteErrors(payload: ServerPayload): Record<string, unknown>;
+export declare function toRouteLoaderData(payload: ServerPayload): Record<string, unknown>;

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

@@ -0,0 +1,8 @@
+import type { ServerPayload } from '@modern-js/runtime/context';
+import { isAbsoluteUrl } from '../shared/isAbsoluteUrl';
+export { isAbsoluteUrl };
+type PayloadDecoder = (stream: ReadableStream<Uint8Array>) => Promise<unknown>;
+export declare const payloadFetchCache: Map<string, Promise<ServerPayload>>;
+export declare function createPayloadFetchKey(request: Request): string;
+export declare function fetchTanstackRscPayload(request: Request): Promise<ServerPayload>;
+export declare function __setTanstackRscPayloadDecoderForTests(decoder?: PayloadDecoder): void;

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+export declare function isAbsoluteUrl(value: string): boolean;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/package.json

@@ -18,7 +18,7 @@
     "modern.js",
     "tanstack-router"
   ],
-  "version": "3.5.0-ultramodern.9",
+  "version": "3.5.0-ultramodern.91",
   "engines": {
     "node": ">=20"
   },
@@ -55,6 +55,20 @@
         "module": "./dist/esm/runtime/router.mjs"
       },
       "default": "./dist/esm/runtime/router.mjs"
+    },
+    "./runtime/rsc/client": {
+      "types": "./dist/types/runtime/rsc/client.d.ts",
+      "node": {
+        "module": "./dist/esm/runtime/rsc/client.mjs"
+      },
+      "default": "./dist/esm/runtime/rsc/client.mjs"
+    },
+    "./runtime/rsc/server": {
+      "types": "./dist/types/runtime/rsc/server.d.ts",
+      "node": {
+        "module": "./dist/esm/runtime/rsc/server.mjs"
+      },
+      "default": "./dist/esm/runtime/rsc/server.mjs"
     }
   },
   "typesVersions": {
@@ -70,37 +84,44 @@
       ],
       "runtime/router": [
         "./dist/types/runtime/router.d.ts"
+      ],
+      "runtime/rsc/client": [
+        "./dist/types/runtime/rsc/client.d.ts"
+      ],
+      "runtime/rsc/server": [
+        "./dist/types/runtime/rsc/server.d.ts"
       ]
     }
   },
   "dependencies": {
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.5.0-ultramodern.91",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.5.0-ultramodern.91",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.91",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.91",
     "@swc/helpers": "^0.5.23",
-    "@tanstack/react-router": "1.170.16",
-    "@tanstack/router-core": "1.171.13",
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.5.0-ultramodern.9",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.5.0-ultramodern.9",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.9",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.9"
+    "@tanstack/react-router": "1.170.17",
+    "@tanstack/router-core": "1.171.14",
+    "react-server-dom-rspack": "0.0.2"
   },
   "peerDependencies": {
-    "@modern-js/runtime": "3.5.0-ultramodern.9",
+    "@modern-js/app-tools": "3.5.0-ultramodern.91",
+    "@modern-js/runtime": "3.5.0-ultramodern.91",
     "react": "^19.2.7",
     "react-dom": "^19.2.7"
   },
   "devDependencies": {
-    "@rslib/core": "0.23.1",
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.5.0-ultramodern.91",
+    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.5.0-ultramodern.91",
+    "@rslib/core": "0.23.2",
+    "@scripts/rstest-config": "2.66.0",
     "@tanstack/history": "1.162.0",
-    "@testing-library/dom": "^10.4.1",
     "@testing-library/react": "^16.3.2",
-    "@types/node": "^26.0.1",
+    "@types/node": "^26.1.1",
     "@types/react": "^19.2.17",
     "@types/react-dom": "^19.2.3",
-    "@typescript/native-preview": "7.0.0-dev.20260628.1",
+    "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "react": "^19.2.7",
-    "react-dom": "^19.2.7",
-    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.5.0-ultramodern.9",
-    "@scripts/rstest-config": "2.66.0",
-    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.5.0-ultramodern.9"
+    "react-dom": "^19.2.7"
   },
   "sideEffects": [
     "./src/runtime/register.ts",
@@ -117,7 +138,6 @@
     "./dist/cjs/runtime/router.js"
   ],
   "publishConfig": {
-    "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
   "scripts": {

package/rstest.config.mts

@@ -1,3 +1,4 @@
+import path from 'node:path';
 import type { ProjectConfig } from '@rstest/core';
 import { withTestPreset } from '@scripts/rstest-config';
 
@@ -23,27 +24,49 @@ export default {
       name: 'plugin-tanstack-node',
       testEnvironment: 'node',
       include: [
+        'tests/realm-isolation.test.ts',
         'tests/router/cli.test.ts',
         'tests/router/fastDefaults.test.ts',
+        'tests/router/flightSerialization.roundtrip.test.tsx',
+        'tests/router/generateRouteArtifacts.test.ts',
         'tests/router/hooks.test.ts',
         'tests/router/loaderBridge.test.ts',
         'tests/router/packageSurface.test.ts',
         'tests/router/preloadRedirect.test.ts',
         'tests/router/register.test.ts',
         'tests/router/routeHooks.test.ts',
+        'tests/router/rscPayloadRouterMatrix.test.ts',
         'tests/router/rsc.test.tsx',
+        'tests/router/slotUsageSanitizer.test.ts',
+        'tests/router/ssrPreload.test.ts',
         'tests/router/tanstackTypes.test.ts',
         'tests/router/routeTree.test.ts',
       ],
       extends: commonConfig,
     }),
+    withTestPreset({
+      name: 'plugin-tanstack-router-compatibility',
+      testEnvironment: 'node',
+      include: ['tests/router/routerCompatibility.test.ts'],
+      resolve: {
+        alias: {
+          '@modern-js/runtime/router/internal': path.resolve(
+            __dirname,
+            'tests/router/fixtures/legacyRuntimeRouter.ts',
+          ),
+        },
+      },
+      extends: commonConfig,
+    }),
     withTestPreset({
       name: 'plugin-tanstack-client',
       testEnvironment: 'happy-dom',
       include: [
+        'tests/router/clientHydration.test.tsx',
         'tests/router/dataMutation.test.tsx',
         'tests/router/hydrationBoundary.test.tsx',
         'tests/router/prefetchLink.test.tsx',
+        'tests/router/prefetchLinkPreload.test.tsx',
       ],
       extends: commonConfig,
     }),