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

package/dist/cjs/exports/tanstack-router.js

@@ -28,324 +28,55 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    Asset: ()=>react_router_namespaceObject.Asset,
-    Await: ()=>react_router_namespaceObject.Await,
-    Block: ()=>react_router_namespaceObject.Block,
-    CatchBoundary: ()=>react_router_namespaceObject.CatchBoundary,
-    CatchNotFound: ()=>react_router_namespaceObject.CatchNotFound,
-    ClientOnly: ()=>react_router_namespaceObject.ClientOnly,
-    DEFAULT_PROTOCOL_ALLOWLIST: ()=>react_router_namespaceObject.DEFAULT_PROTOCOL_ALLOWLIST,
-    DefaultGlobalNotFound: ()=>react_router_namespaceObject.DefaultGlobalNotFound,
-    ErrorComponent: ()=>react_router_namespaceObject.ErrorComponent,
-    FileRoute: ()=>react_router_namespaceObject.FileRoute,
-    FileRouteLoader: ()=>react_router_namespaceObject.FileRouteLoader,
-    Form: ()=>dataMutation_js_namespaceObject.Form,
-    HeadContent: ()=>react_router_namespaceObject.HeadContent,
-    LazyRoute: ()=>react_router_namespaceObject.LazyRoute,
-    Link: ()=>prefetchLink_js_namespaceObject.Link,
-    Match: ()=>react_router_namespaceObject.Match,
-    MatchRoute: ()=>react_router_namespaceObject.MatchRoute,
-    Matches: ()=>react_router_namespaceObject.Matches,
-    NavLink: ()=>prefetchLink_js_namespaceObject.NavLink,
-    Navigate: ()=>react_router_namespaceObject.Navigate,
-    NotFoundRoute: ()=>react_router_namespaceObject.NotFoundRoute,
-    Outlet: ()=>outlet_js_namespaceObject.Outlet,
-    RootRoute: ()=>react_router_namespaceObject.RootRoute,
-    Route: ()=>react_router_namespaceObject.Route,
-    RouteActionResponseError: ()=>dataMutation_js_namespaceObject.RouteActionResponseError,
-    RouteApi: ()=>react_router_namespaceObject.RouteApi,
-    Router: ()=>react_router_namespaceObject.Router,
-    RouterContextProvider: ()=>react_router_namespaceObject.RouterContextProvider,
-    RouterProvider: ()=>react_router_namespaceObject.RouterProvider,
-    ScriptOnce: ()=>react_router_namespaceObject.ScriptOnce,
-    Scripts: ()=>react_router_namespaceObject.Scripts,
-    ScrollRestoration: ()=>react_router_namespaceObject.ScrollRestoration,
-    SearchParamError: ()=>react_router_namespaceObject.SearchParamError,
-    cleanPath: ()=>react_router_namespaceObject.cleanPath,
-    composeRewrites: ()=>react_router_namespaceObject.composeRewrites,
-    createBrowserHistory: ()=>react_router_namespaceObject.createBrowserHistory,
-    createControlledPromise: ()=>react_router_namespaceObject.createControlledPromise,
-    createFileRoute: ()=>react_router_namespaceObject.createFileRoute,
-    createHashHistory: ()=>react_router_namespaceObject.createHashHistory,
-    createHistory: ()=>react_router_namespaceObject.createHistory,
-    createLazyFileRoute: ()=>react_router_namespaceObject.createLazyFileRoute,
-    createLazyRoute: ()=>react_router_namespaceObject.createLazyRoute,
-    createLink: ()=>react_router_namespaceObject.createLink,
-    createMemoryHistory: ()=>react_router_namespaceObject.createMemoryHistory,
-    createRootRoute: ()=>react_router_namespaceObject.createRootRoute,
-    createRootRouteWithContext: ()=>react_router_namespaceObject.createRootRouteWithContext,
-    createRoute: ()=>react_router_namespaceObject.createRoute,
-    createRouteMask: ()=>react_router_namespaceObject.createRouteMask,
-    createRouter: ()=>react_router_namespaceObject.createRouter,
-    createRouterConfig: ()=>react_router_namespaceObject.createRouterConfig,
-    createSerializationAdapter: ()=>react_router_namespaceObject.createSerializationAdapter,
-    deepEqual: ()=>react_router_namespaceObject.deepEqual,
-    defaultParseSearch: ()=>react_router_namespaceObject.defaultParseSearch,
-    defaultStringifySearch: ()=>react_router_namespaceObject.defaultStringifySearch,
-    defer: ()=>react_router_namespaceObject.defer,
-    functionalUpdate: ()=>react_router_namespaceObject.functionalUpdate,
-    getRouteApi: ()=>react_router_namespaceObject.getRouteApi,
-    interpolatePath: ()=>react_router_namespaceObject.interpolatePath,
-    isMatch: ()=>react_router_namespaceObject.isMatch,
-    isNotFound: ()=>react_router_namespaceObject.isNotFound,
-    isPlainArray: ()=>react_router_namespaceObject.isPlainArray,
-    isPlainObject: ()=>react_router_namespaceObject.isPlainObject,
-    isRedirect: ()=>react_router_namespaceObject.isRedirect,
-    joinPaths: ()=>react_router_namespaceObject.joinPaths,
-    lazyFn: ()=>react_router_namespaceObject.lazyFn,
-    lazyRouteComponent: ()=>react_router_namespaceObject.lazyRouteComponent,
-    linkOptions: ()=>react_router_namespaceObject.linkOptions,
-    notFound: ()=>react_router_namespaceObject.notFound,
-    parseSearchWith: ()=>react_router_namespaceObject.parseSearchWith,
-    reactUse: ()=>react_router_namespaceObject.reactUse,
-    redirect: ()=>react_router_namespaceObject.redirect,
-    replaceEqualDeep: ()=>react_router_namespaceObject.replaceEqualDeep,
-    resolvePath: ()=>react_router_namespaceObject.resolvePath,
-    retainSearchParams: ()=>react_router_namespaceObject.retainSearchParams,
-    rootRouteId: ()=>react_router_namespaceObject.rootRouteId,
-    rootRouteWithContext: ()=>react_router_namespaceObject.rootRouteWithContext,
-    stringifySearchWith: ()=>react_router_namespaceObject.stringifySearchWith,
-    stripSearchParams: ()=>react_router_namespaceObject.stripSearchParams,
-    trimPath: ()=>react_router_namespaceObject.trimPath,
-    trimPathLeft: ()=>react_router_namespaceObject.trimPathLeft,
-    trimPathRight: ()=>react_router_namespaceObject.trimPathRight,
-    useAwaited: ()=>react_router_namespaceObject.useAwaited,
-    useBlocker: ()=>react_router_namespaceObject.useBlocker,
-    useCanGoBack: ()=>react_router_namespaceObject.useCanGoBack,
-    useChildMatches: ()=>react_router_namespaceObject.useChildMatches,
-    useElementScrollRestoration: ()=>react_router_namespaceObject.useElementScrollRestoration,
-    useFetcher: ()=>dataMutation_js_namespaceObject.useFetcher,
-    useHydrated: ()=>react_router_namespaceObject.useHydrated,
-    useLayoutEffect: ()=>react_router_namespaceObject.useLayoutEffect,
-    useLinkProps: ()=>react_router_namespaceObject.useLinkProps,
-    useLoaderData: ()=>react_router_namespaceObject.useLoaderData,
-    useLoaderDeps: ()=>react_router_namespaceObject.useLoaderDeps,
-    useLocation: ()=>react_router_namespaceObject.useLocation,
-    useMatch: ()=>react_router_namespaceObject.useMatch,
-    useMatchRoute: ()=>react_router_namespaceObject.useMatchRoute,
-    useMatches: ()=>react_router_namespaceObject.useMatches,
-    useNavigate: ()=>react_router_namespaceObject.useNavigate,
-    useParams: ()=>react_router_namespaceObject.useParams,
-    useParentMatches: ()=>react_router_namespaceObject.useParentMatches,
-    useRouteContext: ()=>react_router_namespaceObject.useRouteContext,
-    useRouter: ()=>react_router_namespaceObject.useRouter,
-    useRouterState: ()=>react_router_namespaceObject.useRouterState,
-    useSearch: ()=>react_router_namespaceObject.useSearch,
-    useTags: ()=>react_router_namespaceObject.useTags
+    Form: ()=>Form,
+    Link: ()=>Link,
+    NavLink: ()=>NavLink,
+    Outlet: ()=>Outlet,
+    RouteActionResponseError: ()=>RouteActionResponseError,
+    useFetcher: ()=>useFetcher
+});
+const external_react_namespaceObject = require("react");
+const COMPAT_BINDINGS_SLOT = Symbol.for('@modern-js/plugin-tanstack:runtime-compat-bindings');
+function readCompatBindings() {
+    return globalThis[COMPAT_BINDINGS_SLOT];
+}
+function resolveCompatBindings(exportName) {
+    const bindings = readCompatBindings();
+    if (void 0 === bindings) throw new Error(`[@modern-js/runtime] '${exportName}' from the deprecated '@modern-js/runtime/tanstack-router' alias is provided by @modern-js/plugin-tanstack. Install @modern-js/plugin-tanstack, add \`tanstackRouterPlugin()\` to the \`plugins\` array in modern.config.ts, and make sure '@modern-js/plugin-tanstack/runtime' is imported (e.g. in modern.runtime.ts) before '${exportName}' is used. Prefer importing '${exportName}' from '@modern-js/plugin-tanstack/runtime' directly.`);
+    return bindings;
+}
+const Link = (props)=>(0, external_react_namespaceObject.createElement)(resolveCompatBindings('Link').Link, props);
+const NavLink = (props)=>(0, external_react_namespaceObject.createElement)(resolveCompatBindings('NavLink').NavLink, props);
+const Outlet = ()=>(0, external_react_namespaceObject.createElement)(resolveCompatBindings('Outlet').Outlet);
+const Form = (props)=>(0, external_react_namespaceObject.createElement)(resolveCompatBindings('Form').Form, props);
+function useFetcher() {
+    return resolveCompatBindings('useFetcher').useFetcher();
+}
+function RouteActionResponseErrorPlaceholder() {}
+const RouteActionResponseError = new Proxy(RouteActionResponseErrorPlaceholder, {
+    construct (_target, args) {
+        const RealError = resolveCompatBindings('RouteActionResponseError').RouteActionResponseError;
+        return new RealError(...args);
+    },
+    get (target, property, receiver) {
+        const RealError = readCompatBindings()?.RouteActionResponseError;
+        if (void 0 !== RealError) return Reflect.get(RealError, property);
+        return Reflect.get(target, property, receiver);
+    }
 });
-const react_router_namespaceObject = require("@tanstack/react-router");
-const dataMutation_js_namespaceObject = require("../router/runtime/tanstack/dataMutation.js");
-const outlet_js_namespaceObject = require("../router/runtime/tanstack/outlet.js");
-const prefetchLink_js_namespaceObject = require("../router/runtime/tanstack/prefetchLink.js");
-exports.Asset = __webpack_exports__.Asset;
-exports.Await = __webpack_exports__.Await;
-exports.Block = __webpack_exports__.Block;
-exports.CatchBoundary = __webpack_exports__.CatchBoundary;
-exports.CatchNotFound = __webpack_exports__.CatchNotFound;
-exports.ClientOnly = __webpack_exports__.ClientOnly;
-exports.DEFAULT_PROTOCOL_ALLOWLIST = __webpack_exports__.DEFAULT_PROTOCOL_ALLOWLIST;
-exports.DefaultGlobalNotFound = __webpack_exports__.DefaultGlobalNotFound;
-exports.ErrorComponent = __webpack_exports__.ErrorComponent;
-exports.FileRoute = __webpack_exports__.FileRoute;
-exports.FileRouteLoader = __webpack_exports__.FileRouteLoader;
 exports.Form = __webpack_exports__.Form;
-exports.HeadContent = __webpack_exports__.HeadContent;
-exports.LazyRoute = __webpack_exports__.LazyRoute;
 exports.Link = __webpack_exports__.Link;
-exports.Match = __webpack_exports__.Match;
-exports.MatchRoute = __webpack_exports__.MatchRoute;
-exports.Matches = __webpack_exports__.Matches;
 exports.NavLink = __webpack_exports__.NavLink;
-exports.Navigate = __webpack_exports__.Navigate;
-exports.NotFoundRoute = __webpack_exports__.NotFoundRoute;
 exports.Outlet = __webpack_exports__.Outlet;
-exports.RootRoute = __webpack_exports__.RootRoute;
-exports.Route = __webpack_exports__.Route;
 exports.RouteActionResponseError = __webpack_exports__.RouteActionResponseError;
-exports.RouteApi = __webpack_exports__.RouteApi;
-exports.Router = __webpack_exports__.Router;
-exports.RouterContextProvider = __webpack_exports__.RouterContextProvider;
-exports.RouterProvider = __webpack_exports__.RouterProvider;
-exports.ScriptOnce = __webpack_exports__.ScriptOnce;
-exports.Scripts = __webpack_exports__.Scripts;
-exports.ScrollRestoration = __webpack_exports__.ScrollRestoration;
-exports.SearchParamError = __webpack_exports__.SearchParamError;
-exports.cleanPath = __webpack_exports__.cleanPath;
-exports.composeRewrites = __webpack_exports__.composeRewrites;
-exports.createBrowserHistory = __webpack_exports__.createBrowserHistory;
-exports.createControlledPromise = __webpack_exports__.createControlledPromise;
-exports.createFileRoute = __webpack_exports__.createFileRoute;
-exports.createHashHistory = __webpack_exports__.createHashHistory;
-exports.createHistory = __webpack_exports__.createHistory;
-exports.createLazyFileRoute = __webpack_exports__.createLazyFileRoute;
-exports.createLazyRoute = __webpack_exports__.createLazyRoute;
-exports.createLink = __webpack_exports__.createLink;
-exports.createMemoryHistory = __webpack_exports__.createMemoryHistory;
-exports.createRootRoute = __webpack_exports__.createRootRoute;
-exports.createRootRouteWithContext = __webpack_exports__.createRootRouteWithContext;
-exports.createRoute = __webpack_exports__.createRoute;
-exports.createRouteMask = __webpack_exports__.createRouteMask;
-exports.createRouter = __webpack_exports__.createRouter;
-exports.createRouterConfig = __webpack_exports__.createRouterConfig;
-exports.createSerializationAdapter = __webpack_exports__.createSerializationAdapter;
-exports.deepEqual = __webpack_exports__.deepEqual;
-exports.defaultParseSearch = __webpack_exports__.defaultParseSearch;
-exports.defaultStringifySearch = __webpack_exports__.defaultStringifySearch;
-exports.defer = __webpack_exports__.defer;
-exports.functionalUpdate = __webpack_exports__.functionalUpdate;
-exports.getRouteApi = __webpack_exports__.getRouteApi;
-exports.interpolatePath = __webpack_exports__.interpolatePath;
-exports.isMatch = __webpack_exports__.isMatch;
-exports.isNotFound = __webpack_exports__.isNotFound;
-exports.isPlainArray = __webpack_exports__.isPlainArray;
-exports.isPlainObject = __webpack_exports__.isPlainObject;
-exports.isRedirect = __webpack_exports__.isRedirect;
-exports.joinPaths = __webpack_exports__.joinPaths;
-exports.lazyFn = __webpack_exports__.lazyFn;
-exports.lazyRouteComponent = __webpack_exports__.lazyRouteComponent;
-exports.linkOptions = __webpack_exports__.linkOptions;
-exports.notFound = __webpack_exports__.notFound;
-exports.parseSearchWith = __webpack_exports__.parseSearchWith;
-exports.reactUse = __webpack_exports__.reactUse;
-exports.redirect = __webpack_exports__.redirect;
-exports.replaceEqualDeep = __webpack_exports__.replaceEqualDeep;
-exports.resolvePath = __webpack_exports__.resolvePath;
-exports.retainSearchParams = __webpack_exports__.retainSearchParams;
-exports.rootRouteId = __webpack_exports__.rootRouteId;
-exports.rootRouteWithContext = __webpack_exports__.rootRouteWithContext;
-exports.stringifySearchWith = __webpack_exports__.stringifySearchWith;
-exports.stripSearchParams = __webpack_exports__.stripSearchParams;
-exports.trimPath = __webpack_exports__.trimPath;
-exports.trimPathLeft = __webpack_exports__.trimPathLeft;
-exports.trimPathRight = __webpack_exports__.trimPathRight;
-exports.useAwaited = __webpack_exports__.useAwaited;
-exports.useBlocker = __webpack_exports__.useBlocker;
-exports.useCanGoBack = __webpack_exports__.useCanGoBack;
-exports.useChildMatches = __webpack_exports__.useChildMatches;
-exports.useElementScrollRestoration = __webpack_exports__.useElementScrollRestoration;
 exports.useFetcher = __webpack_exports__.useFetcher;
-exports.useHydrated = __webpack_exports__.useHydrated;
-exports.useLayoutEffect = __webpack_exports__.useLayoutEffect;
-exports.useLinkProps = __webpack_exports__.useLinkProps;
-exports.useLoaderData = __webpack_exports__.useLoaderData;
-exports.useLoaderDeps = __webpack_exports__.useLoaderDeps;
-exports.useLocation = __webpack_exports__.useLocation;
-exports.useMatch = __webpack_exports__.useMatch;
-exports.useMatchRoute = __webpack_exports__.useMatchRoute;
-exports.useMatches = __webpack_exports__.useMatches;
-exports.useNavigate = __webpack_exports__.useNavigate;
-exports.useParams = __webpack_exports__.useParams;
-exports.useParentMatches = __webpack_exports__.useParentMatches;
-exports.useRouteContext = __webpack_exports__.useRouteContext;
-exports.useRouter = __webpack_exports__.useRouter;
-exports.useRouterState = __webpack_exports__.useRouterState;
-exports.useSearch = __webpack_exports__.useSearch;
-exports.useTags = __webpack_exports__.useTags;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "Asset",
-    "Await",
-    "Block",
-    "CatchBoundary",
-    "CatchNotFound",
-    "ClientOnly",
-    "DEFAULT_PROTOCOL_ALLOWLIST",
-    "DefaultGlobalNotFound",
-    "ErrorComponent",
-    "FileRoute",
-    "FileRouteLoader",
     "Form",
-    "HeadContent",
-    "LazyRoute",
     "Link",
-    "Match",
-    "MatchRoute",
-    "Matches",
     "NavLink",
-    "Navigate",
-    "NotFoundRoute",
     "Outlet",
-    "RootRoute",
-    "Route",
     "RouteActionResponseError",
-    "RouteApi",
-    "Router",
-    "RouterContextProvider",
-    "RouterProvider",
-    "ScriptOnce",
-    "Scripts",
-    "ScrollRestoration",
-    "SearchParamError",
-    "cleanPath",
-    "composeRewrites",
-    "createBrowserHistory",
-    "createControlledPromise",
-    "createFileRoute",
-    "createHashHistory",
-    "createHistory",
-    "createLazyFileRoute",
-    "createLazyRoute",
-    "createLink",
-    "createMemoryHistory",
-    "createRootRoute",
-    "createRootRouteWithContext",
-    "createRoute",
-    "createRouteMask",
-    "createRouter",
-    "createRouterConfig",
-    "createSerializationAdapter",
-    "deepEqual",
-    "defaultParseSearch",
-    "defaultStringifySearch",
-    "defer",
-    "functionalUpdate",
-    "getRouteApi",
-    "interpolatePath",
-    "isMatch",
-    "isNotFound",
-    "isPlainArray",
-    "isPlainObject",
-    "isRedirect",
-    "joinPaths",
-    "lazyFn",
-    "lazyRouteComponent",
-    "linkOptions",
-    "notFound",
-    "parseSearchWith",
-    "reactUse",
-    "redirect",
-    "replaceEqualDeep",
-    "resolvePath",
-    "retainSearchParams",
-    "rootRouteId",
-    "rootRouteWithContext",
-    "stringifySearchWith",
-    "stripSearchParams",
-    "trimPath",
-    "trimPathLeft",
-    "trimPathRight",
-    "useAwaited",
-    "useBlocker",
-    "useCanGoBack",
-    "useChildMatches",
-    "useElementScrollRestoration",
-    "useFetcher",
-    "useHydrated",
-    "useLayoutEffect",
-    "useLinkProps",
-    "useLoaderData",
-    "useLoaderDeps",
-    "useLocation",
-    "useMatch",
-    "useMatchRoute",
-    "useMatches",
-    "useNavigate",
-    "useParams",
-    "useParentMatches",
-    "useRouteContext",
-    "useRouter",
-    "useRouterState",
-    "useSearch",
-    "useTags"
+    "useFetcher"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/module-federation/index.js

@@ -0,0 +1,178 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+const MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT = 'modernjs:mf-runtime-fallback';
+const MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT = 'modernjs:mf-runtime-recovery';
+const DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT = '/_modern/contract-gates/runtime-fallback';
+const DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER = 'x-modernjs-runtime-signal-token';
+class ModuleFederationRemoteLoadTimeoutError extends Error {
+    constructor(remote, timeoutMs){
+        super(`Loading remote "${remote}" timed out after ${timeoutMs}ms`);
+        this.name = 'ModuleFederationRemoteLoadTimeoutError';
+    }
+}
+class ModuleFederationRemoteLoadError extends Error {
+    constructor(remote, attempts, causeError){
+        super(`Unable to load remote "${remote}" after ${attempts} attempt${attempts > 1 ? 's' : ''}: ${causeError.message}`);
+        this.name = 'ModuleFederationRemoteLoadError';
+        this.remote = remote;
+        this.attempts = attempts;
+        this.causeError = causeError;
+    }
+}
+class ModuleFederationRemoteComponentContractError extends Error {
+    constructor(remote, exportName){
+        super(`Remote "${remote}" export "${exportName}" is not a valid React component`);
+        this.name = 'ModuleFederationRemoteComponentContractError';
+    }
+}
+function toError(error) {
+    if (error instanceof Error) return error;
+    return new Error('string' == typeof error ? error : 'Unknown remote load error');
+}
+function classifyModuleFederationFallback(error) {
+    const normalizedError = toError(error);
+    if (normalizedError instanceof ModuleFederationRemoteLoadError) return classifyModuleFederationFallback(normalizedError.causeError);
+    if (normalizedError instanceof ModuleFederationRemoteLoadTimeoutError) return 'timeout';
+    if (normalizedError instanceof ModuleFederationRemoteComponentContractError) return 'contract';
+    const message = normalizedError.message;
+    if (/version|requiredVersion|singleton|share scope|shared module/i.test(message)) return 'version-skew';
+    if (/network|fetch|script|timeout|chunk|loading/i.test(message)) return 'network';
+    return 'remote-unavailable';
+}
+function createModuleFederationFallbackTelemetry(input) {
+    const error = void 0 !== input.error ? toError(input.error) : void 0;
+    const status = input.status ?? 'degraded';
+    const eventName = input.eventName ?? ('recovered' === status ? MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT : MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT);
+    const metadata = {
+        ...input.metadata ?? {},
+        classification: input.classification,
+        remote: input.remote,
+        status
+    };
+    if (void 0 !== input.exportName) metadata.exportName = input.exportName;
+    if (void 0 !== input.runtimeDigest) metadata.runtimeDigest = input.runtimeDigest;
+    if (void 0 !== error) {
+        metadata.errorName = error.name;
+        metadata.errorMessage = error.message;
+    }
+    const payload = {
+        appName: input.appName,
+        eventName,
+        metadata,
+        phase: input.phase,
+        reason: input.classification,
+        schemaVersion: 1
+    };
+    if (void 0 !== input.entry) payload.entry = input.entry;
+    if (void 0 !== input.runtimeDigest) payload.runtimeDigest = input.runtimeDigest;
+    return payload;
+}
+function toModuleFederationFallbackAttributes(payload) {
+    return {
+        'data-mf-fallback-app': payload.appName,
+        'data-mf-fallback-classification': payload.reason,
+        'data-mf-fallback-phase': payload.phase,
+        'data-mf-fallback-remote': String(payload.metadata.remote),
+        'data-mf-fallback-status': String(payload.metadata.status),
+        'data-mf-telemetry-event': payload.eventName
+    };
+}
+async function emitModuleFederationFallbackTelemetry(input, options = {}) {
+    const payload = createModuleFederationFallbackTelemetry(input);
+    if ("u" > typeof window && 'function' == typeof window.dispatchEvent && "u" > typeof CustomEvent) window.dispatchEvent(new CustomEvent(payload.eventName, {
+        detail: payload
+    }));
+    const shouldPost = true === options.postSignal || Boolean(options.endpoint);
+    if (!shouldPost) return {
+        dispatched: true,
+        posted: false
+    };
+    const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+    if ('function' != typeof fetchImpl) return {
+        dispatched: true,
+        posted: false
+    };
+    const headers = new Headers({
+        'content-type': 'application/json'
+    });
+    if (void 0 !== options.authToken && options.authToken.length > 0) headers.set(options.authHeaderName ?? DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER, options.authToken);
+    const response = await fetchImpl(options.endpoint ?? DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT, {
+        body: JSON.stringify(payload),
+        headers,
+        method: 'POST',
+        keepalive: true
+    });
+    return {
+        dispatched: true,
+        posted: true,
+        postStatus: response.status
+    };
+}
+__webpack_require__.d(__webpack_exports__, {
+    ModuleFederationRemoteComponentContractError: ()=>ModuleFederationRemoteComponentContractError,
+    ModuleFederationRemoteLoadError: ()=>ModuleFederationRemoteLoadError,
+    ModuleFederationRemoteLoadTimeoutError: ()=>ModuleFederationRemoteLoadTimeoutError,
+    classifyModuleFederationFallback: ()=>classifyModuleFederationFallback,
+    createModuleFederationFallbackTelemetry: ()=>createModuleFederationFallbackTelemetry,
+    emitModuleFederationFallbackTelemetry: ()=>emitModuleFederationFallbackTelemetry,
+    toModuleFederationFallbackAttributes: ()=>toModuleFederationFallbackAttributes
+}, {
+    DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER: DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER,
+    DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT: DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT,
+    MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT: MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT,
+    MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT: MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT
+});
+exports.DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER = __webpack_exports__.DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER;
+exports.DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT = __webpack_exports__.DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT;
+exports.MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT = __webpack_exports__.MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT;
+exports.MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT = __webpack_exports__.MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT;
+exports.ModuleFederationRemoteComponentContractError = __webpack_exports__.ModuleFederationRemoteComponentContractError;
+exports.ModuleFederationRemoteLoadError = __webpack_exports__.ModuleFederationRemoteLoadError;
+exports.ModuleFederationRemoteLoadTimeoutError = __webpack_exports__.ModuleFederationRemoteLoadTimeoutError;
+exports.classifyModuleFederationFallback = __webpack_exports__.classifyModuleFederationFallback;
+exports.createModuleFederationFallbackTelemetry = __webpack_exports__.createModuleFederationFallbackTelemetry;
+exports.emitModuleFederationFallbackTelemetry = __webpack_exports__.emitModuleFederationFallbackTelemetry;
+exports.toModuleFederationFallbackAttributes = __webpack_exports__.toModuleFederationFallbackAttributes;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER",
+    "DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT",
+    "MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT",
+    "MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT",
+    "ModuleFederationRemoteComponentContractError",
+    "ModuleFederationRemoteLoadError",
+    "ModuleFederationRemoteLoadTimeoutError",
+    "classifyModuleFederationFallback",
+    "createModuleFederationFallbackTelemetry",
+    "emitModuleFederationFallbackTelemetry",
+    "toModuleFederationFallbackAttributes"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router/cli/code/index.js

@@ -50,7 +50,6 @@ const constants_js_namespaceObject = require("../../../cli/constants.js");
 const mode_js_namespaceObject = require("../../../cli/ssr/mode.js");
 const external_constants_js_namespaceObject = require("../constants.js");
 const external_nestedRoutes_js_namespaceObject = require("./nestedRoutes.js");
-const external_tanstackTypes_js_namespaceObject = require("./tanstackTypes.js");
 const external_templates_js_namespaceObject = require("./templates.js");
 const external_utils_js_namespaceObject = require("./utils.js");
 async function generateRoutesForEntry(entrypoint, appContext) {
@@ -85,42 +84,11 @@ async function generateRoutesForEntry(entrypoint, appContext) {
     }
     return routes;
 }
-const generateCode = async (appContext, config, entrypoints, api, options)=>{
+const generateCode = async (appContext, config, entrypoints, api)=>{
     const { internalDirectory, srcDirectory, internalSrcAlias, packageName } = appContext;
     const hooks = api.getHooks();
-    const enableTanstackTypes = options?.enableTanstackTypes ?? await (0, external_tanstackTypes_js_namespaceObject.isTanstackRouterFrameworkEnabled)(appContext);
     const generatedRoutesByEntry = {};
     await Promise.all(entrypoints.map(generateEntryCode));
-    if (enableTanstackTypes) {
-        const allEntries = Array.from(new Set(entrypoints.map((e)=>e.entryName).filter(Boolean)));
-        const mainEntry = entrypoints.find((e)=>e.isMainEntry)?.entryName;
-        const registerEntries = allEntries.sort((a, b)=>{
-            if (mainEntry && a === mainEntry) return -1;
-            if (mainEntry && b === mainEntry) return 1;
-            return a.localeCompare(b);
-        });
-        if (registerEntries.length > 0) {
-            const registerDtsPath = external_path_default().join(srcDirectory, 'modern-tanstack', 'register.gen.d.ts');
-            const importStatements = registerEntries.map((entryName, index)=>`import type { router as router${index} } from './${entryName}/router.gen';`).join('\n');
-            const routerUnionType = registerEntries.map((_, index)=>`typeof router${index}`).join(' | ');
-            const registerContent = `// This file is auto-generated by Modern.js. Do not edit manually.
-
-${importStatements}
-
-declare module '@modern-js/runtime/tanstack-router' {
-  interface Register {
-    router: ${routerUnionType};
-  }
-}
-`;
-            try {
-                const prev = await utils_namespaceObject.fs.pathExists(registerDtsPath) ? await utils_namespaceObject.fs.readFile(registerDtsPath, 'utf-8') : null;
-                if (prev !== registerContent) await utils_namespaceObject.fs.outputFile(registerDtsPath, registerContent, 'utf-8');
-            } catch  {
-                await utils_namespaceObject.fs.outputFile(registerDtsPath, registerContent, 'utf-8');
-            }
-        }
-    }
     async function generateEntryCode(entrypoint) {
         const { entryName, isMainEntry, isAutoMount, pageRoutesEntry, nestedRoutesEntry } = entrypoint;
         const { metaName } = api.getAppContext();
@@ -202,20 +170,6 @@ declare module '@modern-js/runtime/tanstack-router' {
                     await utils_namespaceObject.fs.outputFile(serverLoaderFile, serverLoaderCombined);
                 }
                 await utils_namespaceObject.fs.outputFile(external_path_default().resolve(internalDirectory, `./${entryName}/${external_constants_js_namespaceObject.FILE_SYSTEM_ROUTES_FILE_NAME}`), code, 'utf8');
-                if (enableTanstackTypes) {
-                    const { routerGenTs } = await (0, external_tanstackTypes_js_namespaceObject.generateTanstackRouterTypesSourceForEntry)({
-                        appContext,
-                        entryName,
-                        routes: routes
-                    });
-                    const outPath = external_path_default().join(srcDirectory, 'modern-tanstack', entryName, 'router.gen.ts');
-                    try {
-                        const prev = await utils_namespaceObject.fs.pathExists(outPath) ? await utils_namespaceObject.fs.readFile(outPath, 'utf-8') : null;
-                        if (prev !== routerGenTs) await utils_namespaceObject.fs.outputFile(outPath, routerGenTs, 'utf-8');
-                    } catch  {
-                        await utils_namespaceObject.fs.outputFile(outPath, routerGenTs, 'utf-8');
-                    }
-                }
             }
         }
     }

package/dist/cjs/router/cli/code/templates.js

@@ -145,20 +145,7 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
     const loadersMapFile = external_path_default().join(internalDirectory, entryName, external_constants_js_namespaceObject.TEMP_LOADERS_DIR, 'map.json');
     const importLazyCode = `
     import { lazy } from "react";
-    import * as loadableModule from "@${metaName}/runtime/loadable"
-
-    const resolveLoadableExport = module => {
-      const candidates = [module, module.default, module.default?.default];
-      const loadable = candidates.find(candidate => typeof candidate === 'function');
-
-      if (!loadable) {
-        throw new TypeError('Modern.js runtime loadable export must resolve to a function');
-      }
-
-      return loadable;
-    };
-    const loadable = resolveLoadableExport(loadableModule);
-    const loadableLazy = loadableModule.lazy || loadableModule.default?.lazy || loadable.lazy;
+    import loadable, { lazy as loadableLazy } from "@${metaName}/runtime/loadable"
   `;
     let rootLayoutCode = "";
     const getDataLoaderPath = ({ loaderId, clientData, action, inline, routeId, inValidSSRRoute })=>{

package/dist/cjs/router/cli/handler.js

@@ -64,7 +64,7 @@ async function handleGeneratorEntryCode(api, entrypoints, options = {}) {
     const { generatorRegisterCode, generateCode, generatorServerRegisterCode } = await import("./code/index.js");
     originEntrypointsByKey.set(entrypointsKey, (0, lodash_namespaceObject.cloneDeep)(entrypoints));
     const enableRsc = resolvedConfig?.server?.rsc;
-    const routesByEntry = await generateCode(appContext, resolvedConfig, entrypoints, api, normalizedOptions.generateCodeOptions);
+    const routesByEntry = await generateCode(appContext, resolvedConfig, entrypoints, api);
     await Promise.all(entrypoints.map(async (entrypoint)=>{
         if (entrypoint.nestedRoutesEntry || entrypoint.pageRoutesEntry) {
             const route = appContext.serverRoutes.find((r)=>r.entryName === entrypoint.entryName);