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

package/dist/esm-node/router/runtime/internal.mjs

@@ -1,27 +1,35 @@
 import "node:module";
 import { merge } from "@modern-js/runtime-utils/merge";
 import { modifyRoutes, routerPlugin } from "./plugin.mjs";
-import { registerRouterProvider, reportUnsupportedProviderRegistryHooks, resolveRouterProvider, routerProviderRegistryHooks } from "./provider.mjs";
+import { createRouterProviderRealm, registerRouterProvider, reportUnsupportedProviderRegistryHooks, resolveRouterProvider, routerProviderRegistryHooks } from "./provider.mjs";
 registerRouterProvider('react-router', routerPlugin, {
     isDefault: true
 });
-const internal_routerPlugin = (userConfig = {})=>({
-        name: '@modern-js/plugin-router',
-        registryHooks: routerProviderRegistryHooks,
-        setup: (api)=>{
-            const mergedConfig = merge(api.getRuntimeConfig().router || {}, userConfig);
-            const pluginFactory = resolveRouterProvider(mergedConfig.framework, {
-                localDefault: {
-                    name: 'react-router',
-                    factory: routerPlugin
-                }
-            });
-            const providerPlugin = pluginFactory(userConfig);
-            reportUnsupportedProviderRegistryHooks(providerPlugin);
-            providerPlugin.setup?.(api);
-        }
-    });
+const createRouterPlugin = (localProviders = [])=>{
+    const providerRealm = createRouterProviderRealm([
+        {
+            name: 'react-router',
+            factory: routerPlugin,
+            isDefault: true
+        },
+        ...localProviders
+    ]);
+    return (userConfig = {})=>({
+            name: '@modern-js/plugin-router',
+            registryHooks: routerProviderRegistryHooks,
+            setup: (api)=>{
+                const mergedConfig = merge(api.getRuntimeConfig().router || {}, userConfig);
+                const pluginFactory = resolveRouterProvider(mergedConfig.framework, {
+                    realm: providerRealm
+                });
+                const providerPlugin = pluginFactory(userConfig);
+                reportUnsupportedProviderRegistryHooks(providerPlugin);
+                providerPlugin.setup?.(api);
+            }
+        });
+};
+const internal_routerPlugin = createRouterPlugin();
 const internal = internal_routerPlugin;
 export { renderRoutes } from "./utils.mjs";
 export default internal;
-export { internal_routerPlugin as routerPlugin, modifyRoutes, registerRouterProvider, resolveRouterProvider };
+export { createRouterPlugin, createRouterProviderRealm, internal_routerPlugin as routerPlugin, modifyRoutes, registerRouterProvider, resolveRouterProvider };

package/dist/esm-node/router/runtime/plugin.mjs

@@ -65,10 +65,10 @@ const routerPlugin = (userConfig = {})=>({
                 };
                 let cachedRouter = null;
                 const RouterWrapper = (props)=>{
-                    const routerResult = useRouterCreation({
+                    const routerResult = useRouterCreation(process.env.MODERN_ENABLE_RSC ? {
                         ...props,
                         rscPayload: props?.rscPayload
-                    }, {
+                    } : props, {
                         api: api,
                         createRoutes,
                         supportHtml5History,
@@ -122,16 +122,15 @@ function useRouterCreation(props, options) {
     const baseUrl = selectBasePath(location.pathname).replace(/^\/*/, '/');
     const _basename = '/' === baseUrl ? urlJoin(baseUrl, runtimeContext._internalRouterBaseName || basename || '') : baseUrl;
     const { unstable_getBlockNavState: getBlockNavState } = runtimeContext;
-    const rscPayload = props?.rscPayload ? safeUse(props.rscPayload) : null;
-    let hydrationData = window._ROUTER_DATA || rscPayload;
+    const rscPayload = process.env.MODERN_ENABLE_RSC && props?.rscPayload ? safeUse(props.rscPayload) : null;
+    let hydrationData = process.env.MODERN_ENABLE_RSC ? window._ROUTER_DATA || rscPayload : window._ROUTER_DATA;
     return (0, __rspack_external_react.useMemo)(()=>{
         if (hydrationData?.errors) hydrationData = {
             ...hydrationData,
             errors: deserializeErrors(hydrationData.errors)
         };
-        const isRscClient = getGlobalIsRscClient();
         let routes = null;
-        routes = isRscClient ? createRoutes ? createRoutes() : createRouteObjectsFromConfig({
+        routes = process.env.MODERN_ENABLE_RSC && getGlobalIsRscClient() ? createRoutes ? createRoutes() : createRouteObjectsFromConfig({
             routesConfig: finalRouteConfig
         }) : createRoutes ? createRoutes() : createRoutesFromElements(renderRoutes({
             routesConfig: finalRouteConfig,
@@ -139,7 +138,7 @@ function useRouterCreation(props, options) {
         }));
         if (!routes) routes = [];
         const hooks = api.getHooks();
-        if (rscPayload) try {
+        if (process.env.MODERN_ENABLE_RSC && rscPayload) try {
             const router = createClientRouterFromPayload(rscPayload, routes, _basename);
             return {
                 router,

package/dist/esm-node/router/runtime/provider.mjs

@@ -13,46 +13,89 @@ function reportUnsupportedProviderRegistryHooks(providerPlugin) {
     if (unsupportedHookNames.length > 0) console.warn(`[@modern-js/runtime] The router provider "${providerPlugin.name}" declares registry hooks outside the router hook contract: ${unsupportedHookNames.join(', ')}. These hooks are not registered when the provider is resolved through \`runtime.router.framework\` — declare them on a separate runtime plugin instead.`);
     return unsupportedHookNames;
 }
-const REGISTRY_SLOT = Symbol.for('@modern-js/runtime:router-providers:v2');
+function createRouterProviderRealm(registrations) {
+    const providers = new Map();
+    let defaultProvider;
+    for (const registration of registrations){
+        if (!registration.name) throw new Error('[@modern-js/runtime] A router provider realm cannot contain an unnamed provider.');
+        if (providers.has(registration.name)) throw new Error(`[@modern-js/runtime] Router provider "${registration.name}" is declared more than once in the same runtime realm.`);
+        if (true === registration.isDefault && void 0 !== defaultProvider && defaultProvider !== registration.name) throw new Error(`[@modern-js/runtime] Router provider realm declares both "${defaultProvider}" and "${registration.name}" as defaults.`);
+        providers.set(registration.name, registration.factory);
+        if (true === registration.isDefault) defaultProvider = registration.name;
+    }
+    const providerNames = Object.freeze([
+        ...providers.keys()
+    ]);
+    return Object.freeze({
+        ...defaultProvider ? {
+            defaultProvider
+        } : {},
+        get: (name)=>providers.get(name),
+        names: ()=>providerNames
+    });
+}
+const REGISTRY_SLOT = Symbol.for('@modern-js/runtime:router-providers:v3');
+const LEGACY_V2_REGISTRY_SLOT = Symbol.for('@modern-js/runtime:router-providers:v2');
 function getRegistry() {
     const host = globalThis;
     host[REGISTRY_SLOT] ??= {
         providers: new Map(),
+        duplicateProviders: new Set(),
         warnedDuplicates: new Set()
     };
+    host[REGISTRY_SLOT].duplicateProviders ??= new Set();
     host[REGISTRY_SLOT].warnedDuplicates ??= new Set();
     return host[REGISTRY_SLOT];
 }
+function getLegacyV2Registry() {
+    const host = globalThis;
+    return host[LEGACY_V2_REGISTRY_SLOT];
+}
 function registerRouterProvider(name, factory, options = {}) {
     const registry = getRegistry();
     const existing = registry.providers.get(name);
     if (void 0 !== existing) {
-        if (existing !== factory && !registry.warnedDuplicates.has(name)) {
-            registry.warnedDuplicates.add(name);
-            console.warn(`[@modern-js/runtime] The router provider "${name}" was registered more than once with different module instances; keeping the first registration. This usually means two copies of the providing plugin were bundled — for Module Federation, add the provider runtime (e.g. '@modern-js/plugin-tanstack/runtime') to the shared modules of both the host and the remote to deduplicate it.`);
-        }
+        if (existing !== factory) registry.duplicateProviders.add(name);
         return;
     }
-    if (true !== options.isDefault) {
-        if (void 0 !== registry.nonDefaultProvider && registry.nonDefaultProvider !== name) throw new Error(`[@modern-js/runtime] Cannot register router provider "${name}": the competing router provider "${registry.nonDefaultProvider}" is already registered. Only one non-default router provider may be installed at a time — remove one of the router plugins.`);
-        registry.nonDefaultProvider = name;
-    } else registry.defaultProvider = name;
+    if (true === options.isDefault) registry.defaultProvider = name;
     registry.providers.set(name, factory);
 }
 function resolveRouterProvider(framework, options = {}) {
+    if (void 0 !== options.realm) {
+        const name = framework || options.realm.defaultProvider;
+        const realmProviderNames = options.realm.names();
+        if (void 0 === name) throw new Error(`[@modern-js/runtime] The app-owned router provider realm does not declare a default provider. Available realm providers: ${realmProviderNames.join(', ') || '(none)'}.`);
+        const factory = options.realm.get(name);
+        if (void 0 === factory) throw new Error(`[@modern-js/runtime] Router provider "${name}" is not registered in the app-owned router provider realm. Available realm providers: ${realmProviderNames.join(', ') || '(none)'}. Compatibility registry fallback is disabled for app-owned realms.`);
+        return factory;
+    }
     const registry = getRegistry();
-    const name = framework || registry.defaultProvider || options.localDefault?.name;
+    const legacyV2Registry = getLegacyV2Registry();
+    const name = framework || options.localDefault?.name || registry.defaultProvider || legacyV2Registry?.defaultProvider;
     if (void 0 === name) throw new Error('[@modern-js/runtime] No default router provider is registered. This is a bug in the runtime setup.');
     if (void 0 !== options.localDefault && name === options.localDefault.name) return options.localDefault.factory;
     const factory = registry.providers.get(name);
-    if (void 0 !== factory) return factory;
+    if (void 0 !== factory) {
+        if (registry.duplicateProviders.has(name) && !registry.warnedDuplicates.has(name)) {
+            registry.warnedDuplicates.add(name);
+            console.warn(`[@modern-js/runtime] The router provider "${name}" was registered more than once with different module instances, and a router wrapper without an app-owned provider realm is resolving the mixed-version compatibility fallback. The fallback is keeping the first registration. Modern router wrappers isolate app-owned realms automatically. For an older wrapper, share the provider runtime between Module Federation host and remotes or upgrade every app to a realm-aware runtime.`);
+        }
+        return factory;
+    }
+    const legacyV2Factory = legacyV2Registry?.providers.get(name);
+    if (void 0 !== legacyV2Factory) return legacyV2Factory;
     if ('tanstack' === name) throw new Error("[@modern-js/runtime] `runtime.router.framework` is set to \"tanstack\", but no TanStack router provider is registered. 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).");
     throw new Error(`[@modern-js/runtime] Unknown router framework "${name}". Registered providers: ${[
-        ...registry.providers.keys()
+        ...new Set([
+            ...registry.providers.keys(),
+            ...legacyV2Registry?.providers.keys() ?? []
+        ])
     ].join(', ') || '(none)'}. Install and register the plugin that provides this router framework.`);
 }
 function unsafe_resetRouterProvidersForTesting() {
     const host = globalThis;
     delete host[REGISTRY_SLOT];
+    delete host[LEGACY_V2_REGISTRY_SLOT];
 }
-export { registerRouterProvider, reportUnsupportedProviderRegistryHooks, resolveRouterProvider, routerProviderRegistryHooks, unsafe_resetRouterProvidersForTesting };
+export { createRouterProviderRealm, registerRouterProvider, reportUnsupportedProviderRegistryHooks, resolveRouterProvider, routerProviderRegistryHooks, unsafe_resetRouterProvidersForTesting };

package/dist/types/boundary-debugger/index.d.ts

@@ -1,4 +1,4 @@
-import type { RuntimePlugin } from '../core';
+import type { RuntimePlugin } from '../common';
 export type BoundaryDebugEntry = {
     appId: string;
     color?: string;

package/dist/types/cli/registry.d.ts

@@ -0,0 +1,2 @@
+/** Type-only contract for generated runtime registry aliases. */
+export {};

package/dist/types/common.d.ts

@@ -1,5 +1,12 @@
-import type { RuntimePlugin } from './core/plugin';
 export declare const isBrowser: () => boolean;
+export type RuntimePlugin<Extends = unknown> = {
+    name?: string;
+    registryHooks?: Extends extends {
+        extendHooks: infer Hooks;
+    } ? Hooks : Record<string, unknown>;
+    setup?: (...args: any[]) => unknown;
+    [key: string]: unknown;
+};
 export interface RuntimeConfig {
     plugins?: RuntimePlugin[];
     [key: string]: any;

package/dist/types/core/browser/hydrate.d.ts

@@ -1,5 +1,6 @@
 import type React from 'react';
-import type { Root } from 'react-dom/client';
+import { type Root } from 'react-dom/client';
 import type { TRuntimeContext } from '../context/runtime';
 export declare const isReact18: () => boolean;
+export declare function hydrateWithReact(App: React.ReactElement, rootElement: HTMLElement): Promise<Root>;
 export declare function hydrateRoot(App: React.ReactElement, context: TRuntimeContext, ModernRender: (App: React.ReactElement) => Promise<HTMLElement | Root>, ModernHydrate: (App: React.ReactElement, callback?: () => void) => Promise<HTMLElement | Root>): Promise<HTMLElement | Root>;

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

@@ -1,9 +1,12 @@
 import type React from 'react';
+import { hydrateWithReact } from './hydrate';
+export { hydrateWithReact };
 export type RenderFunc = typeof render;
 export declare function render(App: React.ReactElement<{
     basename: string;
 }>, id?: HTMLElement | string): Promise<HTMLElement | import("react-dom/client").Root>;
+/** Bind a client renderer to the runtime context that owns a nested app root. */
+export declare function createNestedAppRenderer(): RenderFunc;
 export declare function renderWithReact18(App: React.ReactElement, rootElement: HTMLElement): Promise<import("react-dom/client").Root>;
 export declare function renderWithReact17(App: React.ReactElement, rootElement: HTMLElement): Promise<HTMLElement>;
-export declare function hydrateWithReact18(App: React.ReactElement, rootElement: HTMLElement): Promise<import("react-dom/client").Root>;
 export declare function hydrateWithReact17(App: React.ReactElement, rootElement: HTMLElement, callback?: () => void): Promise<any>;

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

@@ -1,13 +1,29 @@
-import type { InternalRuntimeContext } from '@modern-js/plugin';
-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 type RuntimeRoute = {
+    children?: RuntimeRoute[];
+    routes?: RuntimeRoute[];
+    [key: string]: any;
+};
+type RuntimeHookCaller = {
+    call: (...args: any[]) => any;
+    [key: string]: unknown;
+};
+type RuntimeHooks = Record<string, RuntimeHookCaller>;
+type RuntimePluginAPI = {
+    updateRuntimeContext?: (context: unknown) => unknown;
+    [key: string]: any;
+};
+type InternalRuntimeContextLike = {
+    hooks: RuntimeHooks;
+    pluginAPI?: RuntimePluginAPI;
+    [key: string]: any;
+};
 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 { createRouterProviderRealm, type RouterProviderFactory, type RouterProviderPlugin, type RouterProviderRealm, type RouterProviderRegistration, registerRouterProvider, resolveRouterProvider, routerProviderRegistryHooks, } from '../../router/runtime/provider';
+export type { BuiltInRouterFramework, InternalRouterRuntimeState, InternalRouterServerSnapshot, LoaderFunction, LoaderFunctionArgs, ModernRoute, 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';
@@ -20,7 +36,7 @@ interface GlobalContext {
     /**
      * nest router and page router config
      */
-    routes?: (NestedRoute | PageRoute)[];
+    routes?: RuntimeRoute[];
     /**
      * nest router init function
      */
@@ -33,7 +49,7 @@ interface GlobalContext {
      * Entry basename for routing
      */
     basename?: string;
-    internalRuntimeContext?: InternalRuntimeContext<RuntimeExtends>;
+    internalRuntimeContext?: InternalRuntimeContextLike;
     /**
      * RSCRoot
      */
@@ -48,9 +64,9 @@ export declare function getGlobalEnableRsc(): boolean | undefined;
 export declare function setGlobalContext(context: Omit<GlobalContext, 'internalRuntimeContext'>): void;
 export declare function getCurrentEntryName(): string | undefined;
 export declare function getGlobalRSCRoot(): React.ComponentType<{}> | undefined;
-export declare function setGlobalInternalRuntimeContext(context: InternalRuntimeContext<RuntimeExtends>): void;
-export declare function getGlobalInternalRuntimeContext(): InternalRuntimeContext<Required<import("@modern-js/plugin").RuntimePluginExtends<import("../plugin/types").RuntimeConfig, import("./runtime").TInternalRuntimeContext, {}, {}>>>;
+export declare function setGlobalInternalRuntimeContext(context: InternalRuntimeContextLike): void;
+export declare function getGlobalInternalRuntimeContext(): InternalRuntimeContextLike;
 export declare function getGlobalApp(): React.ComponentType<{}> | undefined;
-export declare function getGlobalRoutes(): undefined | (NestedRoute | PageRoute)[];
+export declare function getGlobalRoutes(): undefined | RuntimeRoute[];
 export declare function getGlobalLayoutApp(): React.ComponentType<{}> | undefined;
 export declare function getGlobalBasename(): string | undefined;

package/dist/types/core/context/monitors/default.d.ts

@@ -1,2 +1,10 @@
-import type { Monitors } from '@modern-js/types';
-export declare const defaultMonitors: Omit<Monitors, 'push'>;
+export type RuntimeMonitors = {
+    counter: (name: string, ...args: any[]) => void;
+    info: (...args: any[]) => void;
+    debug: (...args: any[]) => void;
+    trace: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    timing: (name: string, dur: number, ...args: any[]) => void;
+};
+export declare const defaultMonitors: RuntimeMonitors;

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

@@ -1 +1 @@
-export declare const getMonitors: () => Omit<import("@modern-js/types").Monitors, "push">;
+export declare const getMonitors: () => import("./default").RuntimeMonitors;

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

@@ -1,2 +1,2 @@
-import type { Monitors } from '@modern-js/types';
-export declare const getMonitors: () => Omit<Monitors, 'push'>;
+import { type RuntimeMonitors } from './default';
+export declare const getMonitors: () => RuntimeMonitors;

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

@@ -0,0 +1,27 @@
+type RuntimeRequest = Record<string, unknown>;
+type RuntimeResponse = Record<string, unknown>;
+export type RequestContext = {
+    request: RuntimeRequest;
+    response: RuntimeResponse;
+};
+export interface TRuntimeContext {
+    initialData?: Record<string, unknown>;
+    isBrowser: boolean;
+    routes?: unknown[];
+    requestContext: RequestContext;
+    /**
+     * @deprecated Use `requestContext` instead
+     */
+    context: RequestContext;
+    [key: string]: unknown;
+}
+export declare const RuntimeContext: import("react").Context<TRuntimeContext>;
+/**
+ * deprecated, use RuntimeContext instead
+ */
+export declare const ReactRuntimeContext: import("react").Context<TRuntimeContext>;
+/**
+ * @deprecated use use(RuntimeContext) instead
+ */
+export declare const useRuntimeContext: () => TRuntimeContext;
+export {};

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

@@ -1,36 +1,26 @@
 import type { RouteObject, StaticHandlerContext } from '@modern-js/runtime-utils/router';
+import type { BaseSSRServerContext } from '@modern-js/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[];
-    requestContext: RequestContext;
-    /**
-     * @deprecated Use `requestContext` instead
-     */
-    context: RequestContext;
-    [key: string]: unknown;
-}
+import { type TRuntimeContext } from './public';
+export type InternalSSRContext = {
+    request: BaseSSRServerContext['request'] & {
+        raw?: Request;
+    };
+    response: BaseSSRServerContext['response'];
+    [key: string]: any;
+};
+export { ReactRuntimeContext, RuntimeContext, type TRuntimeContext, useRuntimeContext, } from './public';
 /**
  * InternalRuntimeContext used internally and by plugins
  */
 export interface TInternalRuntimeContext extends TRuntimeContext {
     routeManifest?: RouteManifest;
+    routes?: RouteObject[];
     routerContext?: StaticHandlerContext;
     unstable_getBlockNavState?: () => boolean;
-    ssrContext?: SSRServerContext;
+    ssrContext?: InternalSSRContext;
     _internalContext?: any;
     _internalRouterBaseName?: any;
 }
 export declare const InternalRuntimeContext: import("react").Context<TInternalRuntimeContext>;
-export declare const RuntimeContext: import("react").Context<TRuntimeContext>;
-/**
- * deprecated, use RuntimeContext instead
- */
-export declare const ReactRuntimeContext: import("react").Context<TRuntimeContext>;
 export declare const getInitialContext: (isBrowser?: boolean, routeManifest?: RouteManifest) => TInternalRuntimeContext;
-/**
- * @deprecated use use(RuntimeContext) instead
- */
-export declare const useRuntimeContext: () => TRuntimeContext;

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

@@ -1,2 +1,2 @@
 import type React from 'react';
-export declare function createRoot(UserApp?: React.ComponentType | null): React.ComponentType<any>;
+export declare function createRoot(UserApp?: React.ComponentType | null): any;

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

@@ -0,0 +1,15 @@
+import type { OnError } from '@modern-js/app-tools';
+import type { TInternalRuntimeContext } from '../context';
+import type { RouterCleanup } from './routerCleanup';
+export type ResponseProxy = {
+    headers: Record<string, string>;
+    status: number;
+};
+export type RedirectContext = {
+    enableRsc: boolean;
+    isRSCNavigation: boolean;
+    basename: string;
+};
+export declare const applyRouterSnapshotResult: (context: TInternalRuntimeContext, onError: OnError) => void;
+export declare const createLoaderRedirectResponse: (beforeRenderResult: Response | undefined, redirectCtx: RedirectContext) => Response | undefined;
+export declare const finalizeRenderResponse: (response: Response, responseProxy: ResponseProxy, redirectCtx: RedirectContext, routerCleanup: RouterCleanup) => Response;

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

@@ -24,5 +24,6 @@ export type RouterCleanup = {
      */
     deferUntilBodyDone: (response: Response) => Response;
 };
-export declare function withRouterCleanup<T>(runtimeContext: TInternalRuntimeContext, onError: OnError, callback: (routerCleanup: RouterCleanup) => Promise<T>): Promise<T>;
+export declare function runWithRouterCleanupOnError<T>(routerCleanup: RouterCleanup, callback: () => Promise<T> | T): Promise<T>;
+export declare function finishWithRouterCleanup<T>(routerCleanup: RouterCleanup, callback: () => Promise<T> | T): Promise<T>;
 export declare function createRouterCleanup(runtimeContext: TInternalRuntimeContext, onError: OnError): RouterCleanup;

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

@@ -9,7 +9,7 @@ type ScriptChunkLike = {
     filename?: string;
     url?: string;
 };
-export declare function getMatchedRouteAssets(runtimeContext: TInternalRuntimeContext, routeManifest?: RouteManifestLike): string[];
+export declare function getMatchedRouteChunks<T>(runtimeContext: TInternalRuntimeContext, routeManifest: RouteManifestLike | undefined, routeAssetToChunk: (asset: string) => T): T[];
 export declare const orderHydrationScriptChunks: <T extends ScriptChunkLike>({ asyncEntryChunks, collectedChunks, matchedRouteChunks, entryName, }: {
     asyncEntryChunks: T[];
     collectedChunks: T[];

package/dist/types/core/server/stream/shared.d.ts

@@ -1,7 +1,7 @@
 import type { OnError } from '@modern-js/app-tools';
 import type { ClientManifest as RscClientManifest, ServerManifest as RscServerManifest, SSRManifest as RscSSRManifest } from '@modern-js/types/server';
 import type React from 'react';
-import type { TRuntimeContext } from '../../context';
+import type { TInternalRuntimeContext } from '../../context';
 import type { HandleRequestConfig } from '../requestHandler';
 import type { RenderStreaming, SSRConfig } from '../shared';
 export type RscManifest = {
@@ -11,7 +11,7 @@ export type RscManifest = {
     entryCssFiles?: Record<string, string[]>;
 };
 export type CreateReadableStreamFromElementOptions = {
-    runtimeContext: TRuntimeContext;
+    runtimeContext: TInternalRuntimeContext;
     config: HandleRequestConfig;
     ssrConfig: SSRConfig;
     htmlTemplate: string;

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

@@ -1,7 +1,6 @@
 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[];
@@ -30,7 +29,6 @@ export declare class LoadableCollector implements Collector {
     private options;
     private extractor?;
     constructor(options: LoadableCollectorOptions);
-    private getMatchedRouteChunks;
     collect(comopnent: ReactElement): ReactElement;
     effect(): Promise<void>;
     private emitLoadableScripts;

package/dist/types/exports/head.d.ts

@@ -2,7 +2,7 @@ import React from 'react';
 import { Helmet as AsyncHelmet, HelmetData as AsyncHelmetData, type HelmetDatum, type HelmetHTMLBodyDatum, type HelmetHTMLElementDatum, type HelmetProps, HelmetProvider, type HelmetServerState, type HelmetTags } from 'react-helmet-async';
 export declare const Helmet: (props: React.PropsWithChildren<HelmetProps>) => React.CElement<React.PropsWithChildren<HelmetProps>, AsyncHelmet> | null;
 declare const head: {
-    Helmet: (props: React.PropsWithChildren<HelmetProps>) => React.CElement<React.PropsWithChildren<HelmetProps>, AsyncHelmet> | null;
+    Helmet: typeof Helmet;
     HelmetData: typeof AsyncHelmetData;
     HelmetProvider: typeof HelmetProvider;
 };

package/dist/types/index.d.ts

@@ -1,10 +1,10 @@
-import type { RouterConfig } from './router/internal';
-export type { RuntimeConfig } from './common';
+import type { RouterConfig } from './router/runtime/types';
+export type { RuntimeConfig, RuntimePlugin } from './common';
 export { isBrowser } from './common';
-export type { RuntimePlugin } from './core';
-export { defineRuntimeConfig, RuntimeContext, useRuntimeContext, } from './core';
+export { defineRuntimeConfig } from './core/config';
 export { getMonitors } from './core/context/monitors';
+export type { TRuntimeContext } from './core/context/public';
+export { RuntimeContext, useRuntimeContext, } from './core/context/public';
 export { getRequest } from './core/context/request';
 export { redirect, setHeaders, setStatus } from './core/context/response';
-export type { TRuntimeContext } from './core/context/runtime';
 export type { RouterConfig };

package/dist/types/internal.d.ts

@@ -1,2 +1 @@
 export { InternalRuntimeContext, type TInternalRuntimeContext, } from './core/context/runtime';
-export type { SSRServerContext } from './core/types';

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

@@ -0,0 +1,104 @@
+/**
+ * G22 — mandatory degraded consumption API.
+ *
+ * CONTEXT.md (Degraded State): "consuming a surface obliges the consumer to
+ * define a degraded state". This module turns that obligation into a
+ * compile-level one: {@link SurfaceConsumerOptions.degraded} is a REQUIRED
+ * field, so a call site that forgets its fallback does not type-check.
+ *
+ * The consumer wraps the loadRemote-ish flow (resolve a SurfaceRef through a
+ * provider, then load the execution artifact from the resolved record) and
+ * guarantees isolation: any discovery/load failure is caught, classified,
+ * reported through the existing MF fallback telemetry, and handed to the
+ * required degraded handler.
+ *
+ * Criticality (owner-default 5: unclassified consumption is `critical`). For a
+ * `noncritical` consumption the degraded handler's result is returned and the
+ * failure is swallowed, so one failing consumption can never propagate to a
+ * sibling (CONTEXT.md: faults isolate at the vertical boundary). For a
+ * `critical` consumption the degraded handler still runs — telemetry and
+ * fallback-UI obligations hold — but the returned promise then REJECTS with the
+ * typed failure so callers and rollout machinery observe it. Critical
+ * consumption during a rollout window should be driven by expand/contract, not
+ * by silent degrade.
+ */
+import { type ModuleFederationFallbackClassification, type ModuleFederationFallbackTelemetryEmitOptions, type ModuleFederationFallbackTelemetryPayload } from './index';
+import { type DiscoveryError, type EnvironmentId, type ParsedSurfaceRef, type ResolvedDeliveryUnit, type SurfaceResolutionProvider } from './surface-resolution-types';
+/** Where in the consumption lifecycle a failure was raised. */
+export type SurfaceConsumptionPhase = 'discovery' | 'load' | 'mount';
+/**
+ * The typed failure surfaced to the degraded handler. Exactly one of
+ * `discoveryError` (resolver returned a typed {@link DiscoveryError}) or
+ * `error` (something threw) is populated for a given failure.
+ */
+export type SurfaceConsumptionFailure = {
+    ref: ParsedSurfaceRef;
+    env: EnvironmentId;
+    phase: SurfaceConsumptionPhase;
+    classification: ModuleFederationFallbackClassification;
+    /** Present when discovery returned a typed error state. */
+    discoveryError?: DiscoveryError;
+    /** Present when a thrown error caused the failure. */
+    error?: unknown;
+    /** The resolved record, when discovery succeeded but load/mount failed. */
+    resolved?: ResolvedDeliveryUnit;
+    /** The fallback telemetry payload emitted for this failure. */
+    telemetry: ModuleFederationFallbackTelemetryPayload;
+};
+export type SurfaceLoadInput = {
+    resolved: ResolvedDeliveryUnit;
+    ref: ParsedSurfaceRef;
+    env: EnvironmentId;
+};
+export type SurfaceConsumerOptions<T> = {
+    /** The logical surface to consume (object or canonical string form). */
+    ref: ParsedSurfaceRef | string;
+    env: EnvironmentId;
+    /** The pluggable resolution seam (RESOLUTION-0001 §2.2). */
+    provider: SurfaceResolutionProvider;
+    /** Consumer app name, used for telemetry attribution. */
+    appName: string;
+    /**
+     * Loads the execution artifact from a resolved record — the loadRemote-ish
+     * flow. Receives the whole {@link ResolvedDeliveryUnit} so the adapter reads
+     * locations under one buildMarker (RESOLUTION-0001 §2.3).
+     */
+    load: (input: SurfaceLoadInput) => Promise<T> | T;
+    /**
+     * REQUIRED degraded handler (G22 compile-level obligation). There is no
+     * default and no way to opt out at the type level: omitting this field is a
+     * compile error. Return the value to serve while the surface is unavailable
+     * or incompatible.
+     */
+    degraded: (failure: SurfaceConsumptionFailure) => T | Promise<T>;
+    /**
+     * Consumption criticality (owner-default 5). Defaults to `'critical'` when
+     * omitted.
+     *
+     * - `'noncritical'`: the degraded handler's result is returned and the
+     *   failure is swallowed — the promise never rejects.
+     * - `'critical'`: the degraded handler still runs (telemetry + fallback-UI
+     *   obligations hold), but the returned promise then REJECTS with the typed
+     *   failure so callers / rollout machinery observe it. Prefer expand/contract
+     *   over silent degrade for critical surfaces during rollout windows.
+     */
+    classification?: 'critical' | 'noncritical';
+    /** Optional telemetry emission options (endpoint/auth/fetch overrides). */
+    telemetry?: ModuleFederationFallbackTelemetryEmitOptions;
+};
+/**
+ * Consume one surface with a mandatory degraded fallback. On any discovery or
+ * load failure the required degraded handler runs (telemetry + fallback UI).
+ *
+ * For a `noncritical` consumption (see {@link SurfaceConsumerOptions.classification})
+ * this resolves to the degraded value and never rejects, so a failing
+ * consumption is isolated from any sibling. For a `critical` consumption (the
+ * default) it rejects with the typed failure AFTER the degraded handler has
+ * run, so callers / rollout machinery observe the failure.
+ */
+export declare function consumeSurface<T>(options: SurfaceConsumerOptions<T>): Promise<T>;
+/**
+ * Build a reusable consumer bound to a provider/env/app, still requiring a
+ * degraded handler per call. Per-call options override the bound base.
+ */
+export declare function createSurfaceConsumer(base: Pick<SurfaceConsumerOptions<unknown>, 'provider' | 'env' | 'appName' | 'telemetry'>): <T>(options: Omit<SurfaceConsumerOptions<T>, keyof typeof base> & Partial<Pick<SurfaceConsumerOptions<T>, keyof typeof base>>) => Promise<T>;