@bleedingdev/modern-js-runtime 3.2.0-ultramodern.120 → 3.2.0-ultramodern.121

package/dist/types/core/context/extensions.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Fork-owned runtime-context extension mechanism.
+ *
+ * Plugins must not add ad-hoc fields to `TRuntimeContext` /
+ * `TInternalRuntimeContext`. Instead they store state in a single internal
+ * slot (a `Map` keyed by symbol) attached to the context object under a
+ * symbol property, so nothing leaks into string-key enumeration
+ * (`Object.keys`, `JSON.stringify`, `{ ...context }` rest patterns over
+ * named keys).
+ *
+ * `Symbol.for` is used for both the slot and the extension keys so that the
+ * mechanism stays coherent even if this module is instantiated twice
+ * (e.g. esm/cjs interop in test runners).
+ */
+export interface RuntimeContextExtension<T> {
+    /** Stable identity of this extension. */
+    readonly key: symbol;
+    get(context: object): T | undefined;
+    set(context: object, value: T): void;
+    remove(context: object): void;
+}
+/**
+ * Removes the extension slot from a context object.
+ *
+ * The slot is an enumerable symbol-keyed property, so object spreads copy it
+ * onto derived objects. Call this on *copies* that form the public
+ * `RuntimeContext` value to keep internal state (router instances, helmet
+ * state, ...) unreachable from the public context object.
+ */
+export declare function stripRuntimeContextExtensions(context: object): void;
+/**
+ * Creates a typed accessor pair over the shared extension slot.
+ *
+ * The `id` must be globally unique (it is interned via `Symbol.for`); use a
+ * package-prefixed name such as `@modern-js/plugin-tanstack:router-state`.
+ */
+export declare function createRuntimeContextExtension<T>(id: string): RuntimeContextExtension<T>;

package/dist/types/core/context/helmetContext.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Fork-owned helmet state, stored via the runtime-context extension slot
+ * instead of an ad-hoc `_helmetContext` field on `TInternalRuntimeContext`.
+ */
+import type { HelmetServerState } from 'react-helmet-async';
+export interface HelmetContextSlot {
+    helmet?: HelmetServerState | null;
+}
+export declare function getHelmetContext(context: object): HelmetContextSlot | undefined;
+export declare function ensureHelmetContext(context: object): HelmetContextSlot;

package/dist/types/core/context/index.d.ts

@@ -3,6 +3,12 @@ import type { NestedRoute, PageRoute } from '@modern-js/types';
 import type React from 'react';
 import type { RuntimeExtends } from '../plugin/types';
 import type { ServerPayload } from './serverPayload/index';
+export { DefaultNotFound } from '../../router/runtime/DefaultNotFound';
+export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter, type RouterExtendsHooks, } from '../../router/runtime/hooks';
+export { applyRouterRuntimeState, applyRouterServerPrepareResult, cleanupRouterRuntimeState, createRouterRuntimeState, createRouterServerSnapshot, getRouterHydrationScripts, getRouterMatchedRouteIds, getRouterRuntimeState, getRouterServerSnapshot, type RouterLifecycleContext, type RouterLifecyclePhase, } from '../../router/runtime/lifecycle';
+export { type RouterProviderFactory, type RouterProviderPlugin, registerRouterProvider, resolveRouterProvider, routerProviderRegistryHooks, } from '../../router/runtime/provider';
+export type { BuiltInRouterFramework, InternalRouterRuntimeState, InternalRouterServerSnapshot, RouterFramework, RouterRouteMatchSnapshot, RouterServerPrepareResult, } from '../../router/runtime/types';
+export { createRuntimeContextExtension, type RuntimeContextExtension, } from './extensions';
 export { getInitialContext, InternalRuntimeContext, RuntimeContext, type TInternalRuntimeContext, type TRuntimeContext, } from './runtime';
 export type { PayloadRoute, ServerPayload } from './serverPayload/index';
 interface GlobalContext {

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

@@ -1,12 +1,10 @@
 import type { RouteObject, StaticHandlerContext } from '@modern-js/runtime-utils/router';
-import type { HelmetServerState } from 'react-helmet-async';
-import type { InternalRouterRuntimeState, InternalRouterServerSnapshot, RouteManifest, RouterFramework } from '../../router/runtime/types';
+import type { RouteManifest } from '../../router/runtime/types';
 import type { RequestContext, SSRServerContext } from '../types';
 export interface TRuntimeContext {
     initialData?: Record<string, unknown>;
     isBrowser: boolean;
     routes?: RouteObject[];
-    routerFramework?: RouterFramework;
     requestContext: RequestContext;
     /**
      * @deprecated Use `requestContext` instead
@@ -19,19 +17,11 @@ export interface TRuntimeContext {
  */
 export interface TInternalRuntimeContext extends TRuntimeContext {
     routeManifest?: RouteManifest;
-    routerRuntime?: InternalRouterRuntimeState;
-    routerInstance?: unknown;
-    routerHydrationScript?: string;
-    routerMatchedRouteIds?: string[];
-    routerServerSnapshot?: InternalRouterServerSnapshot;
     routerContext?: StaticHandlerContext;
     unstable_getBlockNavState?: () => boolean;
     ssrContext?: SSRServerContext;
     _internalContext?: any;
     _internalRouterBaseName?: any;
-    _helmetContext?: {
-        helmet?: HelmetServerState | null;
-    };
 }
 export declare const InternalRuntimeContext: import("react").Context<TInternalRuntimeContext>;
 export declare const RuntimeContext: import("react").Context<TRuntimeContext>;

package/dist/types/core/server/routerCleanup.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Fork-owned helper for the per-request router runtime cleanup.
+ *
+ * Router providers (react-router, @modern-js/plugin-tanstack, ...) register a
+ * `cleanup` callback in the router runtime state. For streamed SSR the
+ * Response is returned at shell-ready while React is still rendering into the
+ * body, so the cleanup must not run until the body finishes — otherwise it
+ * can dispose router state that the in-flight render is still using. Cleanup
+ * failures are reported through the request's `onError` instead of being
+ * swallowed.
+ */
+import type { OnError } from '@modern-js/app-tools';
+import type { TInternalRuntimeContext } from '../context';
+export declare const ROUTER_CLEANUP_ERROR = "An error occurs during router runtime cleanup";
+export type RouterCleanup = {
+    /** True once the cleanup has been tied to a streamed response body. */
+    readonly deferred: boolean;
+    /** Runs the router cleanup at most once; reports failures via `onError`. */
+    run: () => Promise<void>;
+    /**
+     * Ties the cleanup to the completion (close, error or cancellation) of the
+     * response body when it is a stream. Responses without a streaming body are
+     * returned as-is and the caller is expected to invoke `run()` itself.
+     */
+    deferUntilBodyDone: (response: Response) => Response;
+};
+export declare function withRouterCleanup<T>(runtimeContext: TInternalRuntimeContext, onError: OnError, callback: (routerCleanup: RouterCleanup) => Promise<T>): Promise<T>;
+export declare function createRouterCleanup(runtimeContext: TInternalRuntimeContext, onError: OnError): RouterCleanup;

package/dist/types/core/server/scriptOrder.d.ts

@@ -1 +1,25 @@
+import type { TInternalRuntimeContext } from '../context';
+type RouteAssetManifest = {
+    assets?: string[];
+};
+type RouteManifestLike = {
+    routeAssets?: Record<string, RouteAssetManifest | undefined>;
+};
+type ScriptChunkLike = {
+    filename?: string;
+    url?: string;
+};
+export declare function getMatchedRouteAssets(runtimeContext: TInternalRuntimeContext, routeManifest?: RouteManifestLike): string[];
+export declare const orderHydrationScriptChunks: <T extends ScriptChunkLike>({ asyncEntryChunks, collectedChunks, matchedRouteChunks, entryName, }: {
+    asyncEntryChunks: T[];
+    collectedChunks: T[];
+    matchedRouteChunks: T[];
+    entryName: string;
+}) => T[];
 export declare function injectBeforeHydrationEntryScript(template: string, scripts: string, entryName?: string): string;
+export declare function replaceChunkJsPlaceholder(template: string, scripts: string, entryName?: string, placeholder?: string): string;
+export declare function createRouteHydrationScriptTags(runtimeContext: TInternalRuntimeContext, entryName: string, options?: {
+    nonce?: string;
+    template?: string;
+}): string;
+export {};

package/dist/types/core/server/string/loadable.d.ts

@@ -1,19 +1,13 @@
-import { type Chunk } from '@loadable/server';
 import type { ReactElement } from 'react';
 import type { TInternalRuntimeContext } from '../../context';
 import type { ChunkSet, Collector } from './types';
+export { orderHydrationScriptChunks } from '../scriptOrder';
 declare module '@loadable/server' {
     interface ChunkExtractor {
         chunks: string[];
         getChunkAssets: (chunks: string[]) => Chunk[];
     }
 }
-export declare const orderHydrationScriptChunks: ({ asyncEntryChunks, collectedChunks, matchedRouteChunks, entryName, }: {
-    asyncEntryChunks: Chunk[];
-    collectedChunks: Chunk[];
-    matchedRouteChunks: Chunk[];
-    entryName: string;
-}) => Chunk[];
 export interface LoadableCollectorOptions {
     nonce?: string;
     stats?: Record<string, any>;

package/dist/types/core/server/utils.d.ts

@@ -24,6 +24,7 @@ export declare function getSSRConfigByEntry(entryName: string, ssr?: ServerUserC
     inlineScript?: boolean;
     disablePrerender?: boolean;
     unsafeHeaders?: string[];
+    loaderFailureMode?: 'clientRender' | 'errorBoundary';
     moduleFederationAppSSR?: boolean;
 };
 export declare function getSSRMode(ssrConfig?: SSRConfig): 'string' | 'stream' | false;

package/dist/types/exports/tanstack-router.d.ts

@@ -1,7 +1,88 @@
-export type * from '@tanstack/react-router';
-export { Asset, Await, Block, CatchBoundary, CatchNotFound, ClientOnly, cleanPath, composeRewrites, createBrowserHistory, createControlledPromise, createFileRoute, createHashHistory, createHistory, createLazyFileRoute, createLazyRoute, createLink, createMemoryHistory, createRootRoute, createRootRouteWithContext, createRoute, createRouteMask, createRouter, createRouterConfig, createSerializationAdapter, DEFAULT_PROTOCOL_ALLOWLIST, DefaultGlobalNotFound, deepEqual, defaultParseSearch, defaultStringifySearch, defer, ErrorComponent, FileRoute, FileRouteLoader, functionalUpdate, getRouteApi, HeadContent, interpolatePath, isMatch, isNotFound, isPlainArray, isPlainObject, isRedirect, joinPaths, LazyRoute, lazyFn, lazyRouteComponent, linkOptions, Match, Matches, MatchRoute, Navigate, NotFoundRoute, notFound, parseSearchWith, RootRoute, Route, RouteApi, Router, RouterContextProvider, RouterProvider, reactUse, redirect, replaceEqualDeep, resolvePath, retainSearchParams, rootRouteId, rootRouteWithContext, ScriptOnce, Scripts, ScrollRestoration, SearchParamError, stringifySearchWith, stripSearchParams, trimPath, trimPathLeft, trimPathRight, useAwaited, useBlocker, useCanGoBack, useChildMatches, useElementScrollRestoration, useHydrated, useLayoutEffect, useLinkProps, useLoaderData, useLoaderDeps, useLocation, useMatch, useMatches, useMatchRoute, useNavigate, useParams, useParentMatches, useRouteContext, useRouter, useRouterState, useSearch, useTags, } from '@tanstack/react-router';
-export type { Fetcher, FetcherState, FetcherSubmitOptions, FormProps, SubmitOptions, } from '../router/runtime/tanstack/dataMutation';
-export { Form, RouteActionResponseError, useFetcher, } from '../router/runtime/tanstack/dataMutation';
-export { Outlet } from '../router/runtime/tanstack/outlet';
-export type { LinkProps, NavLinkProps, PrefetchBehavior, } from '../router/runtime/tanstack/prefetchLink';
-export { Link, NavLink } from '../router/runtime/tanstack/prefetchLink';
+/**
+ * @deprecated Legacy alias kept so the published `@modern-js/runtime/tanstack-router`
+ * subpath keeps resolving. Use `@modern-js/plugin-tanstack/runtime` instead.
+ *
+ * Only the Modern.js specific `Link`, `NavLink`, `Outlet`, `Form`,
+ * `useFetcher` and `RouteActionResponseError` bindings are still exported from
+ * here for compatibility. They are thin delegates: the real implementations
+ * live in `@modern-js/plugin-tanstack` and are looked up at use time through a
+ * `Symbol.for` slot that '@modern-js/plugin-tanstack/runtime' populates on
+ * import. (`@modern-js/runtime` cannot import `@modern-js/plugin-tanstack`
+ * directly — the package dependency points the other way.)
+ */
+import type React from 'react';
+export type PrefetchBehavior = 'intent' | 'render' | 'viewport' | 'none';
+export type LinkProps<_TRouter = unknown, TFrom extends string = string, TTo extends string | undefined = '.', TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, 'href'> & {
+    prefetch?: PrefetchBehavior;
+    from?: TFrom;
+    mask?: {
+        from?: TMaskFrom;
+        to?: TMaskTo;
+    };
+    params?: unknown;
+    search?: unknown;
+    to?: TTo;
+};
+export type NavLinkProps<TRouter = unknown, TFrom extends string = string, TTo extends string | undefined = '.', TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = LinkProps<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>;
+type LinkComponent = <TRouter = unknown, const TFrom extends string = string, const TTo extends string | undefined = undefined, const TMaskFrom extends string = TFrom, const TMaskTo extends string = ''>(props: LinkProps<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>) => React.ReactElement;
+export type SubmitOptions = {
+    action?: string;
+    method?: string;
+    encType?: string;
+};
+export type FetcherState = 'idle' | 'submitting' | 'loading';
+export type FetcherSubmitOptions = SubmitOptions;
+export type FormProps = Omit<React.FormHTMLAttributes<HTMLFormElement>, 'onSubmit' | 'action'> & {
+    action?: string;
+    onSubmit?: React.FormEventHandler<HTMLFormElement>;
+    reloadDocument?: boolean;
+};
+type SubmitTarget = HTMLFormElement | FormData | URLSearchParams | Record<string, string | number | boolean | null | undefined>;
+export type Fetcher = {
+    state: FetcherState;
+    data: unknown;
+    error: unknown;
+    Form: React.ComponentType<FormProps>;
+    submit: (target: SubmitTarget, options?: FetcherSubmitOptions) => Promise<void>;
+};
+export interface RouteActionResponseError<TData = unknown> extends Error {
+    readonly response: Response;
+    readonly data: TData;
+}
+interface RouteActionResponseErrorConstructor {
+    new <TData = unknown>(response: Response, data: TData): RouteActionResponseError<TData>;
+    readonly prototype: RouteActionResponseError<unknown>;
+}
+/**
+ * @deprecated Import `Link` from `@modern-js/plugin-tanstack/runtime` instead.
+ */
+export declare const Link: LinkComponent;
+/**
+ * @deprecated Import `NavLink` from `@modern-js/plugin-tanstack/runtime` instead.
+ */
+export declare const NavLink: LinkComponent;
+/**
+ * @deprecated Import `Outlet` from `@modern-js/plugin-tanstack/runtime` instead.
+ */
+export declare const Outlet: React.ComponentType;
+/**
+ * @deprecated Import `Form` from `@modern-js/plugin-tanstack/runtime` instead.
+ */
+export declare const Form: React.ComponentType<FormProps>;
+/**
+ * @deprecated Import `useFetcher` from `@modern-js/plugin-tanstack/runtime`
+ * instead.
+ */
+export declare function useFetcher(): Fetcher;
+/**
+ * @deprecated Import `RouteActionResponseError` from
+ * `@modern-js/plugin-tanstack/runtime` instead.
+ *
+ * Delegates to the real class registered by '@modern-js/plugin-tanstack/runtime'
+ * so that `instanceof` checks observe the same class identity. Before the
+ * registration happens no instance can exist, so `instanceof` is gracefully
+ * `false`; constructing without @modern-js/plugin-tanstack installed throws an
+ * actionable error.
+ */
+export declare const RouteActionResponseError: RouteActionResponseErrorConstructor;
+export {};

package/dist/types/module-federation/index.d.ts

@@ -0,0 +1,65 @@
+export declare const MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT = "modernjs:mf-runtime-fallback";
+export declare const MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT = "modernjs:mf-runtime-recovery";
+export declare const DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT = "/_modern/contract-gates/runtime-fallback";
+export declare const DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER = "x-modernjs-runtime-signal-token";
+export type ModuleFederationFallbackClassification = 'timeout' | 'network' | 'contract' | 'version-skew' | 'remote-unavailable';
+export type ModuleFederationFallbackStatus = 'degraded' | 'failed' | 'recovered';
+export type ModuleFederationFallbackTelemetryInput = {
+    appName: string;
+    classification: ModuleFederationFallbackClassification;
+    entry?: string;
+    error?: unknown;
+    eventName?: string;
+    exportName?: string;
+    metadata?: Record<string, unknown>;
+    phase: 'discovery' | 'load' | 'mount' | 'hydrate' | 'recover';
+    remote: string;
+    runtimeDigest?: string;
+    status?: ModuleFederationFallbackStatus;
+};
+export type ModuleFederationFallbackTelemetryPayload = {
+    appName: string;
+    entry?: string;
+    eventName: string;
+    phase: ModuleFederationFallbackTelemetryInput['phase'];
+    reason: ModuleFederationFallbackClassification;
+    runtimeDigest?: string;
+    schemaVersion: 1;
+    metadata: {
+        classification: ModuleFederationFallbackClassification;
+        errorMessage?: string;
+        errorName?: string;
+        exportName?: string;
+        remote: string;
+        runtimeDigest?: string;
+        status: ModuleFederationFallbackStatus;
+    } & Record<string, unknown>;
+};
+export type ModuleFederationFallbackTelemetryEmitOptions = {
+    authHeaderName?: string;
+    authToken?: string;
+    endpoint?: string;
+    fetchImpl?: typeof fetch;
+    postSignal?: boolean;
+};
+export type ModuleFederationFallbackTelemetryEmitResult = {
+    dispatched: boolean;
+    posted: boolean;
+    postStatus?: number;
+};
+export declare class ModuleFederationRemoteLoadTimeoutError extends Error {
+    constructor(remote: string, timeoutMs: number);
+}
+export declare class ModuleFederationRemoteLoadError extends Error {
+    readonly remote: string;
+    readonly attempts: number;
+    readonly causeError: Error;
+    constructor(remote: string, attempts: number, causeError: Error);
+}
+export declare class ModuleFederationRemoteComponentContractError extends Error {
+    constructor(remote: string, exportName: string);
+}
+export declare function classifyModuleFederationFallback(error: unknown): ModuleFederationFallbackClassification;
+export declare function createModuleFederationFallbackTelemetry(input: ModuleFederationFallbackTelemetryInput): ModuleFederationFallbackTelemetryPayload;
+export declare function toModuleFederationFallbackAttributes(payload: ModuleFederationFallbackTelemetryPayload): Record<string, string>;
+export declare function emitModuleFederationFallbackTelemetry(input: ModuleFederationFallbackTelemetryInput, options?: ModuleFederationFallbackTelemetryEmitOptions): Promise<ModuleFederationFallbackTelemetryEmitResult>;

package/dist/types/router/cli/code/index.d.ts

@@ -5,8 +5,6 @@ import type { Entrypoint, NestedRouteForCli, PageRoute } from '@modern-js/types'
  * Generate routing information for a single entry point (can be reused by the routes inspect feature)
  */
 export declare function generateRoutesForEntry(entrypoint: Entrypoint, appContext: AppToolsContext): Promise<NestedRouteForCli[]>;
-export declare const generateCode: (appContext: AppToolsContext, config: AppNormalizedConfig, entrypoints: Entrypoint[], api: CLIPluginAPI<AppTools>, options?: {
-    enableTanstackTypes?: boolean;
-}) => Promise<Record<string, (NestedRouteForCli | PageRoute)[]>>;
+export declare const generateCode: (appContext: AppToolsContext, config: AppNormalizedConfig, entrypoints: Entrypoint[], api: CLIPluginAPI<AppTools>) => Promise<Record<string, (NestedRouteForCli | PageRoute)[]>>;
 export declare function generatorRegisterCode(internalDirectory: string, entryName: string, code: string): void;
 export declare function generatorServerRegisterCode(internalDirectory: string, entryName: string, code: string): void;

package/dist/types/router/cli/handler.d.ts

@@ -10,9 +10,6 @@ type RegenerateRoutesFn = (params: {
 }) => Promise<void>;
 type HandleGeneratorEntryCodeOptions = {
     entrypointsKey?: string;
-    generateCodeOptions?: {
-        enableTanstackTypes?: boolean;
-    };
 };
 type HandleFileChangeOptions = {
     includeEntry?: (entrypoint: Entrypoint) => boolean;

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

@@ -7,5 +7,6 @@ export declare const routerPlugin: (userConfig?: Partial<RouterConfig>) => Runti
 export default routerPlugin;
 export type { RouterExtendsHooks } from './hooks';
 export { modifyRoutes } from './plugin';
+export { type RouterProviderFactory, type RouterProviderPlugin, registerRouterProvider, resolveRouterProvider, } from './provider';
 export { renderRoutes } from './utils';
 export type { RouterConfig, SingleRouteConfig };

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

@@ -1,6 +1,8 @@
 import type { RouteObject } from '@modern-js/runtime-utils/router';
 import type { TInternalRuntimeContext } from '../../core/context/runtime';
 import type { InternalRouterRuntimeState, InternalRouterServerSnapshot, RouterFramework, RouterRouteMatchSnapshot, RouterServerPrepareResult } from './types';
+export declare function getRouterRuntimeState(runtimeContext: object): InternalRouterRuntimeState | undefined;
+export declare function getRouterServerSnapshot(runtimeContext: object): InternalRouterServerSnapshot | undefined;
 export type RouterLifecyclePhase = 'ssr-prepare' | 'client-create' | 'hydrate';
 export type RouterLifecycleContext = {
     framework: RouterFramework;

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

@@ -1,5 +1,5 @@
 import { type RuntimePlugin } from '../../core';
-import { type RouterExtendsHooks } from './hooks';
+import type { RouterExtendsHooks } from './hooks';
 import type { RouterConfig, Routes } from './types';
 export declare let finalRouteConfig: RouterConfig['routesConfig'];
 export declare let beforeCreateRouter: boolean;

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

@@ -1,5 +1,5 @@
 import type { RuntimePlugin } from '../../core';
-import { type RouterExtendsHooks } from './hooks';
+import type { RouterExtendsHooks } from './hooks';
 import type { RouterConfig } from './types';
 export declare const routerPlugin: (userConfig?: Partial<RouterConfig>) => RuntimePlugin<{
     extendHooks: RouterExtendsHooks;

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

@@ -0,0 +1,61 @@
+/**
+ * Fork-owned router-provider registry.
+ *
+ * `runtime.router.framework` selects the router implementation used by the
+ * built-in router runtime plugin (`@modern-js/runtime/router/internal`).
+ * Instead of hardcoding every implementation there, providers register
+ * themselves here:
+ *
+ * - `react-router` registers itself as the default provider when the
+ *   built-in router plugin module is loaded.
+ * - `@modern-js/plugin-tanstack` registers the `tanstack` provider when its
+ *   runtime entry is imported.
+ */
+import type { RuntimePlugin } from '../../core';
+import type { RouterExtendsHooks } from './hooks';
+import type { RouterConfig } from './types';
+/**
+ * The single declaration source for the router hook registry. Every router
+ * provider (built-in react-router, @modern-js/plugin-tanstack, ...) and the
+ * framework-resolving wrapper plugin register exactly these instances, so the
+ * hook set is defined once and providers cannot drift apart.
+ */
+export declare const routerProviderRegistryHooks: RouterExtendsHooks;
+export type RouterProviderPlugin = RuntimePlugin<{
+    extendHooks: RouterExtendsHooks;
+}>;
+/**
+ * Guard for the wrapper plugin (`router/internal`): a resolved provider is
+ * only invoked through `setup`, so registry hooks outside the canonical
+ * router hook contract cannot be registered for it. Returns the offending
+ * hook names and warns once so they are surfaced instead of silently dropped.
+ */
+export declare function reportUnsupportedProviderRegistryHooks(providerPlugin: {
+    name?: string;
+    registryHooks?: Record<string, unknown>;
+}): string[];
+export type RouterProviderFactory = (userConfig: Partial<RouterConfig>) => RouterProviderPlugin;
+export declare function registerRouterProvider(name: string, factory: RouterProviderFactory, options?: {
+    isDefault?: boolean;
+}): void;
+export declare function resolveRouterProvider(framework?: RouterConfig['framework'], options?: {
+    /**
+     * The resolving module's own copy of a provider. The registry is
+     * realm-global with keep-first semantics, so in a page hosting several
+     * independent Modern.js apps (Module Federation app-level remotes) the
+     * first-loaded copy of a provider would otherwise win for *every* app —
+     * a foreign factory closes over the foreign app's global context (routes,
+     * App, runtime hooks) and renders the wrong app inside the resolving one.
+     * When the resolved name matches `localDefault.name`, the local factory
+     * is returned instead of whatever copy registered first.
+     */
+    localDefault?: {
+        name: string;
+        factory: RouterProviderFactory;
+    };
+}): RouterProviderFactory;
+/**
+ * Test-only escape hatch: the registry lives on `globalThis`, so unit tests
+ * need a way to restore a pristine state between cases.
+ */
+export declare function unsafe_resetRouterProvidersForTesting(): void;

package/package.json

@@ -17,7 +17,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.2.0-ultramodern.120",
+  "version": "3.2.0-ultramodern.121",
   "engines": {
     "node": ">=20"
   },
@@ -67,6 +67,10 @@
       "types": "./dist/types/boundary-debugger/index.d.ts",
       "default": "./dist/esm/boundary-debugger/index.mjs"
     },
+    "./module-federation": {
+      "types": "./dist/types/module-federation/index.d.ts",
+      "default": "./dist/esm/module-federation/index.mjs"
+    },
     "./ssr": {
       "types": "./dist/types/core/server/index.d.ts",
       "default": "./dist/esm/core/server/index.mjs"
@@ -175,6 +179,9 @@
       "boundary-debugger": [
         "./dist/types/boundary-debugger/index.d.ts"
       ],
+      "module-federation": [
+        "./dist/types/module-federation/index.d.ts"
+      ],
       "document": [
         "./dist/types/document/index.d.ts"
       ],
@@ -222,8 +229,6 @@
     "@swc/core": "1.15.41",
     "@swc/helpers": "^0.5.23",
     "@swc/plugin-loadable-components": "^11.12.0",
-    "@tanstack/react-router": "1.170.15",
-    "@tanstack/router-core": "1.171.13",
     "@types/loadable__component": "^5.13.10",
     "cookie": "1.1.1",
     "entities": "^8.0.0",
@@ -233,12 +238,12 @@
     "isbot": "5.1.42",
     "react-helmet-async": "3.0.0",
     "react-is": "^19.2.7",
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.2.0-ultramodern.120",
-    "@modern-js/plugin-data-loader": "npm:@bleedingdev/modern-js-plugin-data-loader@3.2.0-ultramodern.120",
-    "@modern-js/render": "npm:@bleedingdev/modern-js-render@3.2.0-ultramodern.120",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.2.0-ultramodern.120",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.2.0-ultramodern.120",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.2.0-ultramodern.120"
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.2.0-ultramodern.121",
+    "@modern-js/render": "npm:@bleedingdev/modern-js-render@3.2.0-ultramodern.121",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.2.0-ultramodern.121",
+    "@modern-js/plugin-data-loader": "npm:@bleedingdev/modern-js-plugin-data-loader@3.2.0-ultramodern.121",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.2.0-ultramodern.121",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.2.0-ultramodern.121"
   },
   "peerDependencies": {
     "react": "^19.2.7",
@@ -248,7 +253,6 @@
     "@remix-run/web-fetch": "^4.4.2",
     "@rsbuild/core": "2.0.11",
     "@rslib/core": "0.22.0",
-    "@tanstack/history": "1.162.0",
     "@testing-library/dom": "^10.4.1",
     "@testing-library/react": "^16.3.2",
     "@types/invariant": "^2.2.37",
@@ -257,7 +261,7 @@
     "@typescript/native-preview": "7.0.0-dev.20260610.1",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
-    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.2.0-ultramodern.120",
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.2.0-ultramodern.121",
     "@scripts/rstest-config": "2.66.0"
   },
   "sideEffects": false,

package/rstest.config.mts

@@ -23,9 +23,8 @@ export default {
       name: 'plugin-runtime-node',
       testEnvironment: 'node',
       exclude: [
+        'tests/boundary-debugger/client.test.tsx',
         'tests/router/prefetch.test.tsx',
-        'tests/router/tanstackPrefetchLink.test.tsx',
-        'tests/router/dataMutation.test.tsx',
       ],
       extends: commonConfig,
       plugins: [
@@ -51,9 +50,8 @@ export default {
       name: 'plugin-runtime-client',
       testEnvironment: 'happy-dom',
       include: [
+        'tests/boundary-debugger/client.test.tsx',
         'tests/router/prefetch.test.tsx',
-        'tests/router/tanstackPrefetchLink.test.tsx',
-        'tests/router/dataMutation.test.tsx',
       ],
       extends: commonConfig,
       plugins: [