@bleedingdev/modern-js-runtime 3.5.0-ultramodern.10 → 3.5.0-ultramodern.100

package/dist/types/module-federation/last-known-good.d.ts

@@ -0,0 +1,72 @@
+/**
+ * G24a/b — last-known-good (LKG) provider wrapper.
+ *
+ * RESOLUTION-0001 §2.2: the LKG cache "wraps any provider; serves the last
+ * complete record on provider failure, marked `compatibility: 'degraded'`". It
+ * is universal — no DOM/fetch/framework coupling — so the same wrapper works in
+ * the browser, Node, and Cloudflare.
+ *
+ * Rollback semantics (ADR-0019 / CONTEXT.md Rollback): the delivery UNIT is
+ * the unit of rollback. The cache stores exactly ONE whole
+ * {@link ResolvedDeliveryUnit} per (unitId, env) key — never per (ref, env) —
+ * so every surface of a unit shares one snapshot and a fresh success swaps that
+ * snapshot atomically for all of them (two surfaces can never be served from
+ * different cached build markers). It never stores or serves a partial record,
+ * and it never mixes locations across build markers — a served degraded record
+ * is a byte-for-byte prior success with only its compatibility verdict flipped
+ * to `degraded`. An `incompatible` record is never good: it is neither cached
+ * as the last-known-good snapshot nor ever served. The ref's external-major
+ * participates in lookup validation but not in the storage key.
+ */
+import { type ResolvedDeliveryUnit, type SurfaceResolutionProvider } from './surface-resolution-types';
+export declare const LAST_KNOWN_GOOD_PROVIDER_NAME = "last-known-good";
+/** One cached complete record plus the time it was stored. */
+export type LkgRecord = {
+    resolved: ResolvedDeliveryUnit;
+    storedAt: number;
+    /**
+     * External-major selector the record was resolved against. Participates in
+     * lookup validation — a cached record is only served for a matching major —
+     * but never in the storage key, which is (unitId, env) so all surfaces of a
+     * unit share one atomically-swapped record.
+     */
+    major?: number;
+};
+/**
+ * Pluggable storage hook. The default is an in-memory Map; callers may supply a
+ * durable store (KV, disk, etc). Reads/writes may be async. A store only ever
+ * receives whole records.
+ */
+export type LkgStorage = {
+    read(key: string): (LkgRecord | undefined) | Promise<LkgRecord | undefined>;
+    write(key: string, record: LkgRecord): void | Promise<void>;
+};
+export type LkgFreshnessPolicy = {
+    /**
+     * Maximum age, in ms, a stored record may be served after a provider
+     * failure. When omitted, a served record never expires by age. A record
+     * older than this yields a typed `stale-record` discovery error.
+     */
+    maxStaleMs?: number;
+};
+export type LastKnownGoodOptions = {
+    /** The wrapped provider (env/static, Zephyr, or any other). */
+    provider: SurfaceResolutionProvider;
+    /** Pluggable storage; defaults to a process-local in-memory Map. */
+    storage?: LkgStorage;
+    freshness?: LkgFreshnessPolicy;
+    /** Clock injection for deterministic freshness tests. */
+    now?: () => number;
+};
+/** Default process-local in-memory storage. */
+export declare function createInMemoryLkgStorage(): LkgStorage;
+/**
+ * Wrap a provider with a last-known-good cache. On success the whole record is
+ * cached (atomic swap). On provider failure (typed discovery error or a thrown
+ * error) the last complete record is served, marked degraded — unless it has
+ * expired per {@link LkgFreshnessPolicy}, in which case a typed `stale-record`
+ * error is returned. If there is no cached record, the original failure is
+ * passed through (a thrown error becomes a `provider-unavailable` discovery
+ * error).
+ */
+export declare function createLastKnownGoodProvider(options: LastKnownGoodOptions): SurfaceResolutionProvider;

package/dist/types/module-federation/manifest-recovery-runtime-plugin.d.ts

@@ -0,0 +1,25 @@
+type ErrorLoadRemoteArgs = {
+    id?: string;
+    error?: unknown;
+    lifecycle?: string;
+};
+export type ModuleFederationManifestRecoveryPluginOptions = {
+    attempts?: number;
+    retryDelayMs?: number;
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+    waitImpl?: (milliseconds: number) => Promise<void>;
+};
+/**
+ * Gives server-side manifest loading a small, bounded recovery window.
+ *
+ * Returning `undefined` deliberately hands control back to Module Federation:
+ * its runtime preserves the original typed RUNTIME-003 error and invalidates
+ * the rejected manifest promise. Parsed manifests are returned without schema
+ * interpretation so runtime-core remains the authority for RUNTIME-013.
+ */
+export declare const createModuleFederationManifestRecoveryPlugin: (options?: ModuleFederationManifestRecoveryPluginOptions) => {
+    name: string;
+    errorLoadRemote(args: ErrorLoadRemoteArgs): Promise<any>;
+};
+export default createModuleFederationManifestRecoveryPlugin;

package/dist/types/module-federation/surface-resolution-types.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Surface-resolution types for the module-federation runtime.
+ *
+ * Thin re-export of the canonical module in `@modern-js/utils/universal`
+ * (`packages/toolkit/utils/src/universal/surface-resolution/`,
+ * RESOLUTION-0001). Kept as a file so existing `./surface-resolution-types`
+ * imports stay stable. Only helpers the canonical module deliberately does not
+ * ship (the (ref, env) cache key) live here, implemented against canonical
+ * types.
+ */
+import { type EnvironmentId, type ParsedSurfaceRef } from '@modern-js/utils/universal';
+export { type CompatibilityStatus, type CompatibilityVerdict, createDiscoveryError, type DiscoveryError, type DiscoveryErrorCode, type DiscoveryResult, type EnvironmentId, formatSurfaceRef, type ParsedSurfaceRef, parseSurfaceRef, type ResolvedDeliveryUnit, type ResolvedSurface, type ResolvedSurfaceKind, type ResolvedSurfaceLocation, type ResolvedSurfaceLocationPlatform, type SurfaceRefParseError, type SurfaceRefParseResult, type SurfaceResolutionProvider, validateSurfaceRef, } from '@modern-js/utils/universal';
+/** Stable cache/identity key for a (ref, env) pair. */
+export declare function surfaceResolutionKey(ref: ParsedSurfaceRef, env: EnvironmentId): string;
+/**
+ * Stable cache key for a (deliveryUnit, env) pair — ONE record per unit per
+ * env (ADR-0019 atomicity). All surfaces of a unit share this key so a refresh
+ * replaces the whole unit snapshot atomically for every surface, and two
+ * surfaces of the same unit can never be served from different cached
+ * snapshots. The ref's external-major participates in lookup validation (see
+ * the LKG provider), not in this key.
+ */
+export declare function deliveryUnitResolutionKey(unitId: string, env: EnvironmentId): string;

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

@@ -18,6 +18,7 @@ export declare const NESTED_ROUTE: {
     PAGE_FILE: string;
     PAGE_CONFIG_FILE: string;
     PAGE_LOADER_FILE: string;
+    PAGE_SEARCH_FILE: string;
     PAGE_DATA_FILE: string;
     PAGE_CLIENT_LOADER: string;
     SPLATE_FILE: string;

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

@@ -1,12 +1,16 @@
 import type { RouteObject } from '@modern-js/runtime-utils/router';
 import type { TRuntimeContext } from '../../core/context/runtime';
 import type { RouterLifecycleContext } from './lifecycle';
-declare const modifyRoutes: import("@modern-js/plugin").SyncHook<(routes: RouteObject[]) => RouteObject[]>;
-declare const onBeforeCreateRoutes: import("@modern-js/plugin").SyncHook<(context: TRuntimeContext) => void>;
-declare const onBeforeCreateRouter: import("@modern-js/plugin").SyncHook<(context: RouterLifecycleContext) => void>;
-declare const onAfterCreateRouter: import("@modern-js/plugin").SyncHook<(context: RouterLifecycleContext) => void>;
-declare const onBeforeHydrateRouter: import("@modern-js/plugin").SyncHook<(context: RouterLifecycleContext) => void>;
-declare const onAfterHydrateRouter: import("@modern-js/plugin").SyncHook<(context: RouterLifecycleContext) => void>;
+export type RouterSyncHook<Handler extends (...args: any[]) => any> = {
+    call: (...args: Parameters<Handler>) => ReturnType<Handler>;
+    [key: string]: unknown;
+};
+declare const modifyRoutes: RouterSyncHook<(routes: RouteObject[]) => RouteObject[]>;
+declare const onBeforeCreateRoutes: RouterSyncHook<(context: TRuntimeContext) => void>;
+declare const onBeforeCreateRouter: RouterSyncHook<(context: RouterLifecycleContext) => void>;
+declare const onAfterCreateRouter: RouterSyncHook<(context: RouterLifecycleContext) => void>;
+declare const onBeforeHydrateRouter: RouterSyncHook<(context: RouterLifecycleContext) => void>;
+declare const onAfterHydrateRouter: RouterSyncHook<(context: RouterLifecycleContext) => void>;
 export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter, };
 export type RouterExtendsHooks = {
     modifyRoutes: typeof modifyRoutes;

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

@@ -1,12 +1,22 @@
-import type { RuntimePlugin } from '../../core';
+import type { RuntimePlugin } from '../../common';
 import type { RouterExtendsHooks } from './hooks';
+import type { RouterProviderRegistration } from './provider';
 import type { RouterConfig, SingleRouteConfig } from './types';
-export declare const routerPlugin: (userConfig?: Partial<RouterConfig>) => RuntimePlugin<{
+type LocalRouterProvider = Omit<RouterProviderRegistration, 'isDefault'>;
+export type RouterPluginFactory = (userConfig?: Partial<RouterConfig>) => RuntimePlugin<{
     extendHooks: RouterExtendsHooks;
 }>;
+/**
+ * Create one router wrapper and its provider realm for a runtime entry. Optional
+ * providers are supplied by the entry-owning integration (for example the
+ * TanStack runtime/router module), so independently bundled apps never resolve
+ * factories from another app's module graph.
+ */
+export declare const createRouterPlugin: (localProviders?: readonly LocalRouterProvider[]) => RouterPluginFactory;
+export declare const routerPlugin: RouterPluginFactory;
 export default routerPlugin;
 export type { RouterExtendsHooks } from './hooks';
 export { modifyRoutes } from './plugin';
-export { type RouterProviderFactory, type RouterProviderPlugin, registerRouterProvider, resolveRouterProvider, } from './provider';
+export { createRouterProviderRealm, type RouterProviderFactory, type RouterProviderPlugin, type RouterProviderRealm, type RouterProviderRegistration, registerRouterProvider, resolveRouterProvider, } from './provider';
 export { renderRoutes } from './utils';
 export type { RouterConfig, SingleRouteConfig };

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

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

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

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

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

@@ -11,7 +11,7 @@
  * - `@modern-js/plugin-tanstack` registers the `tanstack` provider when its
  *   runtime entry is imported.
  */
-import type { RuntimePlugin } from '../../core';
+import type { RuntimePlugin } from '../../common';
 import type { RouterExtendsHooks } from './hooks';
 import type { RouterConfig } from './types';
 /**
@@ -35,19 +35,36 @@ export declare function reportUnsupportedProviderRegistryHooks(providerPlugin: {
     registryHooks?: Record<string, unknown>;
 }): string[];
 export type RouterProviderFactory = (userConfig: Partial<RouterConfig>) => RouterProviderPlugin;
+export type RouterProviderRegistration = {
+    name: string;
+    factory: RouterProviderFactory;
+    isDefault?: boolean;
+};
+/**
+ * App-owned provider catalog. Provider factories close over their module graph,
+ * so they must be resolved from the runtime wrapper that owns the app instead
+ * of from a page-global first-registration winner.
+ */
+export type RouterProviderRealm = Readonly<{
+    defaultProvider?: string;
+    get: (name: string) => RouterProviderFactory | undefined;
+    names: () => readonly string[];
+}>;
+export declare function createRouterProviderRealm(registrations: readonly RouterProviderRegistration[]): RouterProviderRealm;
 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.
+     * Provider factories owned by the resolving app/runtime wrapper. A realm
+     * is the exclusive provider source when supplied because its factories
+     * close over the correct app module graph.
+     */
+    realm?: RouterProviderRealm;
+    /**
+     * Legacy single-provider override retained for published wrappers. New
+     * integrations should pass an app-owned `realm`, which supports every
+     * provider rather than only the default.
      */
     localDefault?: {
         name: string;
@@ -55,7 +72,7 @@ export declare function resolveRouterProvider(framework?: RouterConfig['framewor
     };
 }): RouterProviderFactory;
 /**
- * Test-only escape hatch: the registry lives on `globalThis`, so unit tests
- * need a way to restore a pristine state between cases.
+ * Test-only escape hatch: compatibility registries live on `globalThis`, so
+ * unit tests need a way to restore a pristine state between cases.
  */
 export declare function unsafe_resetRouterProvidersForTesting(): void;

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

@@ -1,6 +1,12 @@
-import type { RequestContext } from '@modern-js/runtime-utils/node';
 import type { Params, RouteObject, RouteProps } from '@modern-js/runtime-utils/router';
-import type { NestedRoute, PageRoute } from '@modern-js/types';
+export type ModernRoute = {
+    type: 'nested' | 'page';
+    path?: string;
+    id?: string;
+    component?: React.ComponentType | string;
+    children?: ModernRoute[];
+    [key: string]: any;
+};
 export type SingleRouteConfig = RouteProps & {
     redirect?: string;
     routes?: SingleRouteConfig[];
@@ -19,13 +25,13 @@ export type RouterFramework = BuiltInRouterFramework | (string & {});
 export type RouterConfig = {
     /**
      * Select the router implementation used by Modern.js conventional routing.
-     * - `react-router` (default): React Router v7 based integration
+     * - `react-router` (default): React Router based integration
      * - `tanstack`: TanStack Router integration
      */
     framework?: RouterFramework;
     routesConfig: {
         globalApp?: React.ComponentType<any>;
-        routes?: (NestedRoute | PageRoute)[];
+        routes?: ModernRoute[];
     };
     /**
      * You should not use it
@@ -108,12 +114,28 @@ export type ModernRouteObject = RouteObject & {
     component?: React.ComponentType | LazyComponentDescriptor;
     entryCssFiles?: string[];
 };
+type LoaderContextKey<T = unknown> = {
+    symbol: symbol;
+    getDefaultValue: () => T;
+};
+interface LoaderRequestGet<P extends Record<string, unknown>> {
+    <Key extends keyof P>(key: Key): P[Key];
+    <T>(key: LoaderContextKey<T>): T;
+}
+interface LoaderRequestSet<P extends Record<string, unknown>> {
+    <Key extends keyof P>(key: Key, value: P[Key]): void;
+    <T>(key: LoaderContextKey<T>, value: T): void;
+}
+type LoaderRequestContext<P extends Record<string, unknown> = {}> = {
+    get: LoaderRequestGet<P & Record<string, unknown>>;
+    set: LoaderRequestSet<P & Record<string, unknown>>;
+};
 interface DataFunctionArgs<D = any> {
     request: Request;
     params: Params;
     context?: D;
 }
-export type LoaderFunctionArgs<P extends Record<string, unknown> = Record<string, unknown>> = DataFunctionArgs<RequestContext<P>>;
+export type LoaderFunctionArgs<P extends Record<string, unknown> = Record<string, unknown>> = DataFunctionArgs<LoaderRequestContext<P>>;
 declare type DataFunctionValue = Response | NonNullable<unknown> | null;
 export type LoaderFunction = <P extends Record<string, unknown> = Record<string, unknown>>(args: LoaderFunctionArgs<P>) => Promise<DataFunctionValue> | DataFunctionValue;
 export {};

package/package.json

@@ -17,7 +17,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.5.0-ultramodern.10",
+  "version": "3.5.0-ultramodern.100",
   "engines": {
     "node": ">=20"
   },
@@ -55,6 +55,12 @@
       "types": "./dist/types/core/browser/index.d.ts",
       "default": "./dist/esm/core/browser/index.mjs"
     },
+    "./registry": {
+      "types": "./dist/types/cli/registry.d.ts"
+    },
+    "./registry/*": {
+      "types": "./dist/types/cli/registry.d.ts"
+    },
     "./loadable": {
       "types": "./dist/types/exports/loadable.d.ts",
       "default": "./dist/esm/exports/loadable.mjs"
@@ -71,6 +77,18 @@
       "types": "./dist/types/module-federation/index.d.ts",
       "default": "./dist/esm/module-federation/index.mjs"
     },
+    "./module-federation/distributed-ssr": {
+      "types": "./dist/types/module-federation/distributed-ssr.d.ts",
+      "default": "./dist/esm/module-federation/distributed-ssr.mjs"
+    },
+    "./module-federation/manifest-recovery-runtime-plugin": {
+      "types": "./dist/types/module-federation/manifest-recovery-runtime-plugin.d.ts",
+      "node": {
+        "import": "./dist/esm/module-federation/manifest-recovery-runtime-plugin.mjs",
+        "require": "./dist/cjs/module-federation/manifest-recovery-runtime-plugin.js"
+      },
+      "default": "./dist/esm/module-federation/manifest-recovery-runtime-plugin.mjs"
+    },
     "./ssr": {
       "types": "./dist/types/core/server/index.d.ts",
       "default": "./dist/esm/core/server/index.mjs"
@@ -99,10 +117,6 @@
       },
       "default": "./dist/esm/router/index.mjs"
     },
-    "./tanstack-router": {
-      "types": "./dist/types/exports/tanstack-router.d.ts",
-      "default": "./dist/esm/exports/tanstack-router.mjs"
-    },
     "./router/server": {
       "types": "./dist/types/router/runtime/server.d.ts",
       "default": "./dist/esm/router/runtime/server.mjs"
@@ -173,6 +187,12 @@
       "browser": [
         "./dist/types/core/browser/index.d.ts"
       ],
+      "registry": [
+        "./dist/types/cli/registry.d.ts"
+      ],
+      "registry/*": [
+        "./dist/types/cli/registry.d.ts"
+      ],
       "head": [
         "./dist/types/exports/head.d.ts"
       ],
@@ -182,6 +202,9 @@
       "module-federation": [
         "./dist/types/module-federation/index.d.ts"
       ],
+      "module-federation/manifest-recovery-runtime-plugin": [
+        "./dist/types/module-federation/manifest-recovery-runtime-plugin.d.ts"
+      ],
       "document": [
         "./dist/types/document/index.d.ts"
       ],
@@ -194,9 +217,6 @@
       "router": [
         "./dist/types/router/index.d.ts"
       ],
-      "tanstack-router": [
-        "./dist/types/exports/tanstack-router.d.ts"
-      ],
       "router/server": [
         "./dist/types/router/runtime/server.d.ts"
       ],
@@ -226,51 +246,51 @@
   "dependencies": {
     "@loadable/component": "5.16.7",
     "@loadable/server": "5.16.7",
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.5.0-ultramodern.100",
+    "@modern-js/plugin-data-loader": "npm:@bleedingdev/modern-js-plugin-data-loader@3.5.0-ultramodern.100",
+    "@modern-js/render": "npm:@bleedingdev/modern-js-render@3.5.0-ultramodern.100",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.5.0-ultramodern.100",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.100",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.100",
     "@swc/core": "1.15.43",
     "@swc/helpers": "^0.5.23",
-    "@swc/plugin-loadable-components": "^11.14.0",
+    "@swc/plugin-loadable-components": "^11.15.0",
     "@types/loadable__component": "^5.13.10",
     "@types/react-helmet": "^6.1.11",
-    "cookie": "2.0.0",
+    "cookie": "2.0.1",
     "entities": "^8.0.0",
-    "es-module-lexer": "^2.1.0",
+    "es-module-lexer": "^2.3.0",
     "esbuild": "^0.28.1",
     "invariant": "^2.2.4",
-    "isbot": "5.1.44",
+    "isbot": "5.2.0",
     "react-helmet": "^6.1.0",
     "react-helmet-async": "3.0.0",
-    "react-is": "^19.2.7",
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.5.0-ultramodern.10",
-    "@modern-js/plugin-data-loader": "npm:@bleedingdev/modern-js-plugin-data-loader@3.5.0-ultramodern.10",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.5.0-ultramodern.10",
-    "@modern-js/render": "npm:@bleedingdev/modern-js-render@3.5.0-ultramodern.10",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.10",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.10"
+    "react-is": "^19.2.7"
   },
   "peerDependencies": {
     "react": "^19.2.7",
     "react-dom": "^19.2.7"
   },
   "devDependencies": {
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.5.0-ultramodern.100",
     "@remix-run/web-fetch": "^4.4.2",
-    "@rsbuild/core": "2.1.1",
-    "@rslib/core": "0.23.1",
+    "@rsbuild/core": "2.1.5",
+    "@rslib/core": "0.23.2",
+    "@scripts/rstest-config": "2.66.0",
     "@testing-library/dom": "^10.4.1",
     "@testing-library/react": "^16.3.2",
+    "@types/cookie": "0.6.0",
     "@types/invariant": "^2.2.37",
     "@types/loadable__server": "5.12.11",
-    "@types/node": "^26.0.1",
-    "@typescript/native-preview": "7.0.0-dev.20260628.1",
+    "@types/node": "^26.1.1",
+    "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
     "ts-node": "^10.9.2",
-    "typescript": "^6.0.3",
-    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.5.0-ultramodern.10",
-    "@scripts/rstest-config": "2.66.0"
+    "typescript": "^7.0.2"
   },
   "sideEffects": false,
   "publishConfig": {
-    "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
   "scripts": {

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

@@ -1,83 +0,0 @@
-"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__);
-__webpack_require__.d(__webpack_exports__, {
-    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);
-    }
-});
-exports.Form = __webpack_exports__.Form;
-exports.Link = __webpack_exports__.Link;
-exports.NavLink = __webpack_exports__.NavLink;
-exports.Outlet = __webpack_exports__.Outlet;
-exports.RouteActionResponseError = __webpack_exports__.RouteActionResponseError;
-exports.useFetcher = __webpack_exports__.useFetcher;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "Form",
-    "Link",
-    "NavLink",
-    "Outlet",
-    "RouteActionResponseError",
-    "useFetcher"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/esm/exports/tanstack-router.mjs

@@ -1,30 +0,0 @@
-import { createElement } from "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)=>createElement(resolveCompatBindings('Link').Link, props);
-const NavLink = (props)=>createElement(resolveCompatBindings('NavLink').NavLink, props);
-const Outlet = ()=>createElement(resolveCompatBindings('Outlet').Outlet);
-const Form = (props)=>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);
-    }
-});
-export { Form, Link, NavLink, Outlet, RouteActionResponseError, useFetcher };

package/dist/esm-node/exports/tanstack-router.mjs

@@ -1,31 +0,0 @@
-import "node:module";
-import { createElement } from "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)=>createElement(resolveCompatBindings('Link').Link, props);
-const NavLink = (props)=>createElement(resolveCompatBindings('NavLink').NavLink, props);
-const Outlet = ()=>createElement(resolveCompatBindings('Outlet').Outlet);
-const Form = (props)=>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);
-    }
-});
-export { Form, Link, NavLink, Outlet, RouteActionResponseError, useFetcher };