@bleedingdev/modern-js-runtime 3.8.3-ultramodern.6 → 3.9.0-ultramodern.10

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

@@ -1,11 +1,10 @@
 import "node:module";
 "use client";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-import { getNavigationWarmupCacheKey } from "@modern-js/runtime-extensions";
 import { Link as router_Link, NavLink, matchRoutes, useHref, useMatches, useResolvedPath } from "@modern-js/runtime-utils/router";
 import react, { useContext, useMemo } from "react";
 import { InternalRuntimeContext } from "../../core/context/index.mjs";
-import { __webpack_require__ } from "../../rslib-runtime.mjs";
+import { __webpack_require__ } from "../../rslib-runtime~0.mjs";
 const getWebpackChunkLoader = ()=>__webpack_chunk_load__;
 const getWebpackPublicPath = ()=>{
     try {
@@ -21,62 +20,6 @@ function composeEventHandlers(theirHandler, ourHandler) {
     };
 }
 const ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
-const DEFAULT_PREFETCH_BEHAVIOR = 'render';
-const INTENT_DELAY = 100;
-const VIEWPORT_ROOT_MARGIN = '200px';
-const MAX_CONCURRENT_WARMUPS = 4;
-const WARMUP_TTL = 30000;
-const SLOW_EFFECTIVE_TYPES = new Set([
-    'slow-2g',
-    '2g'
-]);
-const warmupCache = new Map();
-const warmupQueue = [];
-let activeWarmups = 0;
-const getWarmupTimestamp = ()=>performance.now();
-const getConnection = ()=>{
-    const nav = globalThis.navigator;
-    return nav?.connection || nav?.mozConnection || nav?.webkitConnection;
-};
-const shouldWarmupOnCurrentNetwork = ()=>{
-    const connection = getConnection();
-    if (connection?.saveData) return false;
-    if ('string' == typeof connection?.effectiveType && SLOW_EFFECTIVE_TYPES.has(connection.effectiveType)) return false;
-    return true;
-};
-const pruneWarmupCache = (now = getWarmupTimestamp())=>{
-    for (const [key, timestamp] of warmupCache)if (now - timestamp > WARMUP_TTL) warmupCache.delete(key);
-};
-const runNextWarmup = ()=>{
-    while(activeWarmups < MAX_CONCURRENT_WARMUPS && warmupQueue.length > 0){
-        const task = warmupQueue.shift();
-        if (task.cancelled) continue;
-        activeWarmups += 1;
-        task.run().catch(()=>{
-            warmupCache.delete(task.key);
-        }).finally(()=>{
-            activeWarmups -= 1;
-            runNextWarmup();
-        });
-    }
-};
-const scheduleWarmup = (key, run)=>{
-    if (!shouldWarmupOnCurrentNetwork()) return ()=>{};
-    pruneWarmupCache();
-    if (warmupCache.has(key)) return ()=>{};
-    warmupCache.set(key, getWarmupTimestamp());
-    const task = {
-        key,
-        run,
-        cancelled: false
-    };
-    warmupQueue.push(task);
-    runNextWarmup();
-    return ()=>{
-        task.cancelled = true;
-        if (warmupQueue.includes(task)) warmupCache.delete(task.key);
-    };
-};
 const setRef = (ref, value)=>{
     if (!ref) return;
     if ('function' == typeof ref) return void ref(value);
@@ -84,70 +27,65 @@ const setRef = (ref, value)=>{
         ref.current = value;
     } catch  {}
 };
-const isDataWarmupEnabled = (route)=>{
-    const handle = route.handle;
-    return handle?.navigationWarmup?.data !== false;
-};
-function usePrefetchBehavior(prefetch, preload, theirElementProps) {
-    const [maybeWarmup, setMaybeWarmup] = react.useState(false);
-    const [shouldPrefetch, setShouldPrefetch] = react.useState(false);
-    const [shouldPreload, setShouldPreload] = react.useState(false);
-    const [viewportElement, setViewportElement] = react.useState(null);
+function usePrefetchBehavior(prefetch, preload, theirElementProps, policy) {
+    const [maybePrefetch, setMaybePrefetch] = react.useState(false);
+    const [state, setState] = react.useState({
+        code: false,
+        data: false
+    });
+    const [element, setElement] = react.useState(null);
+    const observerRef = react.useRef(void 0);
     const { onFocus, onBlur, onMouseEnter, onMouseLeave, onTouchStart } = theirElementProps;
     react.useEffect(()=>{
-        if ('render' === prefetch) setShouldPrefetch(true);
-        if ('render' === preload) setShouldPreload(true);
+        if (!policy) return void setState({
+            code: 'render' === prefetch,
+            data: 'render' === prefetch
+        });
+        const observer = policy.observe({
+            element,
+            prefetch,
+            preload,
+            notify: (next)=>setState((previous)=>previous.code === next.code && previous.data === next.data ? previous : next)
+        });
+        observerRef.current = observer;
+        return ()=>{
+            observerRef.current = void 0;
+            observer.dispose();
+        };
     }, [
+        policy,
         prefetch,
-        preload
+        preload,
+        element
+    ]);
+    react.useEffect(()=>{
+        if (policy || !maybePrefetch) return;
+        const timer = setTimeout(()=>setState({
+                code: true,
+                data: true
+            }), 100);
+        return ()=>clearTimeout(timer);
+    }, [
+        policy,
+        maybePrefetch
     ]);
     const setIntent = ()=>{
-        if ('intent' === prefetch || 'intent' === preload) setMaybeWarmup(true);
+        if (policy) observerRef.current?.onIntent();
+        else if ('intent' === prefetch) setMaybePrefetch(true);
     };
     const cancelIntent = ()=>{
-        if ('intent' === prefetch || 'intent' === preload) {
-            setMaybeWarmup(false);
-            setShouldPrefetch(false);
-            setShouldPreload(false);
+        if (policy) observerRef.current?.onCancel();
+        else if ('intent' === prefetch) {
+            setMaybePrefetch(false);
+            setState({
+                code: false,
+                data: false
+            });
         }
     };
-    react.useEffect(()=>{
-        if (maybeWarmup) {
-            const id = setTimeout(()=>{
-                if ('intent' === prefetch) setShouldPrefetch(true);
-                if ('intent' === preload) setShouldPreload(true);
-            }, INTENT_DELAY);
-            return ()=>{
-                clearTimeout(id);
-            };
-        }
-    }, [
-        maybeWarmup,
-        prefetch,
-        preload
-    ]);
-    react.useEffect(()=>{
-        if (!viewportElement || 'viewport' !== prefetch && 'viewport' !== preload || "u" < typeof IntersectionObserver) return;
-        const observer = new IntersectionObserver((entries)=>{
-            if (!entries.some((entry)=>entry.isIntersecting)) return;
-            if ('viewport' === prefetch) setShouldPrefetch(true);
-            if ('viewport' === preload) setShouldPreload(true);
-            observer.disconnect();
-        }, {
-            rootMargin: VIEWPORT_ROOT_MARGIN
-        });
-        observer.observe(viewportElement);
-        return ()=>{
-            observer.disconnect();
-        };
-    }, [
-        prefetch,
-        preload,
-        viewportElement
-    ]);
     return [
-        shouldPrefetch,
-        shouldPreload,
+        state.data,
+        state.code,
         {
             onFocus: composeEventHandlers(onFocus, setIntent),
             onBlur: composeEventHandlers(onBlur, cancelIntent),
@@ -155,7 +93,7 @@ function usePrefetchBehavior(prefetch, preload, theirElementProps) {
             onMouseLeave: composeEventHandlers(onMouseLeave, cancelIntent),
             onTouchStart: composeEventHandlers(onTouchStart, setIntent)
         },
-        setViewportElement
+        setElement
     ];
 }
 async function loadRouteModule(route, routeAssets, chunkLoader) {
@@ -196,7 +134,8 @@ const PrefetchPageLinks = ({ path, includeData })=>{
     const context = useContext(InternalRuntimeContext);
     const { routeManifest, routes } = context;
     const { routeAssets } = routeManifest || {};
-    const allowNetworkWarmup = shouldWarmupOnCurrentNetwork();
+    const policy = context.linkPrefetchPolicy;
+    const allowNetworkWarmup = policy?.canWarmup() ?? true;
     const matches = useMemo(()=>Array.isArray(routes) ? matchRoutes(routes, pathname) : [], [
         pathname,
         routes
@@ -216,7 +155,16 @@ const PrefetchPageLinks = ({ path, includeData })=>{
             const routeAsset = routeId ? routeAssets[routeId] : void 0;
             const chunkIds = routeAsset?.chunkIds;
             if (!routeId || !Array.isArray(chunkIds) || 0 === chunkIds.length) return ()=>{};
-            return scheduleWarmup(getNavigationWarmupCacheKey(context, chunkLoader, getWebpackPublicPath(), `route-module:${routeId}:${chunkIds.join(',')}`), ()=>loadRouteModule(match.route, routeAssets, chunkLoader));
+            const run = ()=>loadRouteModule(match.route, routeAssets, chunkLoader);
+            if (policy) return policy.schedule({
+                runtimeContext: context,
+                chunkLoader,
+                publicPath: getWebpackPublicPath(),
+                key: `route-module:${routeId}:${chunkIds.join(',')}`,
+                run
+            });
+            run().catch(()=>{});
+            return ()=>{};
         });
         return ()=>{
             cancellations.forEach((cancel)=>cancel());
@@ -225,6 +173,7 @@ const PrefetchPageLinks = ({ path, includeData })=>{
         allowNetworkWarmup,
         chunkLoader,
         context,
+        policy,
         routeAssetGeneration
     ]);
     if (!allowNetworkWarmup || !includeData || !window._SSR_DATA) return null;
@@ -236,10 +185,11 @@ const PrefetchPageLinks = ({ path, includeData })=>{
 };
 const PrefetchDataLinks = ({ matches, path, routeManifest })=>{
     const { pathname, search, hash } = path;
+    const policy = useContext(InternalRuntimeContext).linkPrefetchPolicy;
     const currentMatches = useMatches();
     const basename = useHref('/');
     const dataHrefs = useMemo(()=>matches?.filter((match, index)=>{
-            if (!isDataWarmupEnabled(match.route) || !match.route.loader || 'function' != typeof match.route.loader || 0 === match.route.loader.length) return false;
+            if (policy?.allowData(match.route) === false || !match.route.loader || 'function' != typeof match.route.loader || 0 === match.route.loader.length) return false;
             if (match.route.shouldRevalidate) {
                 const currentUrl = new URL(location.pathname + location.search + location.hash, window.origin);
                 const nextUrl = new URL(pathname + search + hash, window.origin);
@@ -266,16 +216,10 @@ const PrefetchDataLinks = ({ matches, path, routeManifest })=>{
         children: dataHrefs
     });
 };
-const normalizePreloadBehavior = (preload, prefetch)=>{
-    if (false === preload || 'none' === preload) return 'none';
-    if (void 0 !== preload) return preload;
-    if ('none' === prefetch) return 'none';
-    return prefetch;
-};
-const createPrefetchLink = (Link)=>/*#__PURE__*/ react.forwardRef(({ to, prefetch = DEFAULT_PREFETCH_BEHAVIOR, preload, ...props }, forwardedRef)=>{
+const createPrefetchLink = (Link)=>/*#__PURE__*/ react.forwardRef(({ to, prefetch, preload, ...props }, forwardedRef)=>{
         const isAbsolute = 'string' == typeof to && ABSOLUTE_URL_REGEX.test(to);
-        const resolvedPreload = normalizePreloadBehavior(preload, prefetch);
-        const [shouldPrefetch, shouldPreload, prefetchHandlers, setViewportElement] = usePrefetchBehavior(prefetch, resolvedPreload, props);
+        const policy = useContext(InternalRuntimeContext).linkPrefetchPolicy;
+        const [shouldPrefetch, shouldPreload, prefetchHandlers, setViewportElement] = usePrefetchBehavior(prefetch, preload, props, policy);
         const setAnchorRef = react.useCallback((element)=>{
             setViewportElement(element);
             setRef(forwardedRef, element);

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

@@ -7,4 +7,12 @@ const onBeforeCreateRouter = createRouterSyncHook();
 const onAfterCreateRouter = createRouterSyncHook();
 const onBeforeHydrateRouter = createRouterSyncHook();
 const onAfterHydrateRouter = createRouterSyncHook();
-export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter };
+const routerProviderRegistryHooks = {
+    modifyRoutes: modifyRoutes,
+    onBeforeCreateRoutes: onBeforeCreateRoutes,
+    onBeforeCreateRouter: onBeforeCreateRouter,
+    onAfterCreateRouter: onAfterCreateRouter,
+    onBeforeHydrateRouter: onBeforeHydrateRouter,
+    onAfterHydrateRouter: onAfterHydrateRouter
+};
+export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter, routerProviderRegistryHooks };

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

@@ -1,35 +1,4 @@
 import "node:module";
-import { merge } from "@modern-js/runtime-utils/merge";
-import { modifyRoutes, routerPlugin } from "./plugin.mjs";
-import { createRouterProviderRealm, registerRouterProvider, reportUnsupportedProviderRegistryHooks, resolveRouterProvider, routerProviderRegistryHooks } from "./provider.mjs";
-registerRouterProvider('react-router', routerPlugin, {
-    isDefault: true
-});
-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 { routerProviderRegistryHooks } from "./hooks.mjs";
+export { modifyRoutes, routerPlugin as default, routerPlugin } from "./plugin.mjs";
 export { renderRoutes } from "./utils.mjs";
-export default internal;
-export { createRouterPlugin, createRouterProviderRealm, internal_routerPlugin as routerPlugin, modifyRoutes, registerRouterProvider, resolveRouterProvider };

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

@@ -5,9 +5,8 @@ import { RouterProvider, createBrowserRouter, createHashRouter, createRoutesFrom
 import { normalizePathname } from "@modern-js/runtime-utils/url";
 import * as __rspack_external_react from "react";
 import { InternalRuntimeContext, getGlobalEnableRsc, getGlobalIsRscClient, getGlobalLayoutApp, getGlobalRoutes } from "../../core/context/index.mjs";
-import { applyRouterRuntimeState } from "./lifecycle.mjs";
+import { routerProviderRegistryHooks } from "./hooks.mjs";
 import { Link } from "./PrefetchLink.mjs";
-import { routerProviderRegistryHooks } from "./provider.mjs";
 import { createClientRouterFromPayload } from "./rsc-router.mjs";
 import { createRouteObjectsFromConfig, deserializeErrors, renderRoutes, urlJoin } from "./utils.mjs";
 let finalRouteConfig = {
@@ -169,11 +168,6 @@ function useRouterCreation(props, options) {
             basename: _basename,
             hydrationData
         });
-        applyRouterRuntimeState(runtimeContext, {
-            framework: 'react-router',
-            basename: _basename,
-            instance: router
-        });
         hooks.onAfterCreateRouter.call({
             ...routerLifecycleContext,
             router,

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

@@ -9,9 +9,8 @@ import { useContext } from "react";
 import { InternalRuntimeContext, getGlobalEnableRsc, getGlobalLayoutApp, getGlobalRoutes } from "../../core/context/index.mjs";
 import { setServerPayload } from "../../core/context/serverPayload/index.server.mjs";
 import DeferredDataScripts_node from "./DeferredDataScripts.node.mjs";
-import { applyRouterRuntimeState, createRouterServerSnapshot } from "./lifecycle.mjs";
+import { routerProviderRegistryHooks } from "./hooks.mjs";
 import { Link } from "./PrefetchLink.mjs";
-import { routerProviderRegistryHooks } from "./provider.mjs";
 import { RSCStaticRouter, createServerPayload, handleRSCRedirect, prepareRSCRoutes } from "./rsc-router.mjs";
 import { createRouteObjectsFromConfig, renderRoutes, urlJoin } from "./utils.mjs";
 function createRemixRequest(request) {
@@ -24,24 +23,6 @@ function createRemixRequest(request) {
         signal: controller.signal
     });
 }
-function createReactRouterServerSnapshot(routerContext, basename) {
-    return createRouterServerSnapshot({
-        framework: 'react-router',
-        basename,
-        statusCode: routerContext.statusCode,
-        errors: routerContext.errors,
-        routerData: {
-            loaderData: routerContext.loaderData,
-            errors: routerContext.errors
-        },
-        matches: routerContext.matches.map((match)=>{
-            const routeId = match.route.id;
-            return 'string' == typeof routeId ? {
-                routeId
-            } : void 0;
-        }).filter((match)=>void 0 !== match)
-    });
-}
 const routerPlugin = (userConfig = {})=>({
         name: '@modern-js/plugin-router',
         registryHooks: routerProviderRegistryHooks,
@@ -108,18 +89,9 @@ const routerPlugin = (userConfig = {})=>({
                     throw errors[0];
                 }
                 context.routerContext = routerContext;
-                const routerServerSnapshot = createReactRouterServerSnapshot(routerContext, _basename);
-                applyRouterRuntimeState(context, {
-                    framework: 'react-router',
-                    basename: _basename,
-                    instance: routerContext,
-                    matchedRouteIds: routerServerSnapshot.matchedRouteIds,
-                    serverSnapshot: routerServerSnapshot
-                });
                 hooks.onAfterCreateRouter.call({
                     ...routerLifecycleContext,
                     router: routerContext,
-                    serverSnapshot: routerServerSnapshot,
                     runtimeContext: context
                 });
                 let payload;

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

@@ -2,7 +2,7 @@ import "node:module";
 const handleRSCRedirect = (headers, basename, status)=>{
     const newHeaders = new Headers(headers);
     let redirectUrl = headers.get('Location');
-    if (!redirectUrl || ![
+    if (null === redirectUrl || '' === redirectUrl || ![
         301,
         302,
         303,

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

@@ -1,11 +1,11 @@
 import type { AppTools, CliPlugin } from '@modern-js/app-tools';
-import { documentPlugin } from '../document/cli';
-import { routerPlugin } from '../router/cli';
-import { ssrPlugin } from './ssr';
-export { getEntrypointRoutesDir, getEntrypointRoutesOwner, handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints, isRouteEntry, updateNestedRoutesSpec, } from '../router/cli';
-export { makeLegalIdentifier } from '../router/cli/code/makeLegalIdentifier';
-export { getPathWithoutExt } from '../router/cli/code/utils';
-export { isRuntimeEntry } from './entry';
+import { documentPlugin } from '../document/cli/index.js';
+import { routerPlugin } from '../router/cli/index.js';
+import { ssrPlugin } from './ssr/index.js';
+export { getEntrypointRoutesDir, getEntrypointRoutesOwner, handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints, isRouteEntry, updateNestedRoutesSpec, } from '../router/cli/index.js';
+export { makeLegalIdentifier } from '../router/cli/code/makeLegalIdentifier.js';
+export { getPathWithoutExt } from '../router/cli/code/utils.js';
+export { isRuntimeEntry } from './entry.js';
 export { documentPlugin, routerPlugin, ssrPlugin };
 export declare const runtimePlugin: (params?: {
     plugins?: CliPlugin<AppTools>[];

package/dist/types/cli/ssr/index.d.ts

@@ -1,6 +1,3 @@
 import type { AppTools, CliPlugin } from '@modern-js/app-tools';
-import type { MergedEnvironmentConfig } from '@rsbuild/core';
-type EnvironmentConfigLike = Partial<Pick<MergedEnvironmentConfig, 'output' | 'source' | 'tools'>>;
-export declare const shouldUseModuleFederationNodeOutput: (config: EnvironmentConfigLike) => boolean;
 export declare const ssrPlugin: () => CliPlugin<AppTools>;
 export default ssrPlugin;

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

@@ -1,5 +1,5 @@
 import type React from 'react';
 import { type Root } from 'react-dom/client';
-import type { TRuntimeContext } from '../context/runtime';
+import type { TRuntimeContext } from '../context/runtime.js';
 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,5 +1,5 @@
 import type React from 'react';
-import { hydrateWithReact } from './hydrate';
+import { hydrateWithReact } from './hydrate.js';
 export { hydrateWithReact };
 export type RenderFunc = typeof render;
 export declare function render(App: React.ReactElement<{

package/dist/types/core/compat/hooks.d.ts

@@ -1,4 +1,4 @@
-import type { TInternalRuntimeContext } from '../context';
+import type { TInternalRuntimeContext } from '../context/index.js';
 export declare function transformHookRunner(hookRunnerName: string): string;
 export declare function handleSetupResult(setupResult: Record<string, (...args: any) => any>, api: Record<string, any>): void;
 export declare function getHookRunners(runtimeContext: TInternalRuntimeContext): Record<string, any>;

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

@@ -1,2 +1,2 @@
-import type { RuntimePlugin } from '../plugin/types';
+import type { RuntimePlugin } from '../plugin/types.js';
 export declare const compatPlugin: () => RuntimePlugin;

package/dist/types/core/compat/requestContext.d.ts

@@ -1,5 +1,5 @@
-import type { TInternalRuntimeContext } from '../context';
-import type { RuntimePlugin } from '../plugin/types';
-import type { RequestContext } from '../types';
+import type { TInternalRuntimeContext } from '../context/index.js';
+import type { RuntimePlugin } from '../plugin/types.js';
+import type { RequestContext } from '../types.js';
 export declare const makeRequestContext: (context: TInternalRuntimeContext) => RequestContext;
 export declare const requestContextPlugin: () => RuntimePlugin;

package/dist/types/core/config.d.ts

@@ -1,4 +1,4 @@
-import type { RuntimeConfig } from '../common';
+import type { RuntimeConfig } from '../common.js';
 /**
  * This function helps you to autocomplete configuration types.
  * It accepts a direct config object, or a function that returns a config.

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

@@ -1,5 +1,5 @@
 import type React from 'react';
-import type { ServerPayload } from './serverPayload/index';
+import type { ServerPayload } from './serverPayload/index.js';
 export type RuntimeRoute = {
     children?: RuntimeRoute[];
     routes?: RuntimeRoute[];
@@ -19,14 +19,12 @@ type InternalRuntimeContextLike = {
     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 { 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';
+export { DefaultNotFound } from '../../router/runtime/DefaultNotFound.js';
+export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter, type RouterExtendsHooks, type RouterLifecycleContext, routerProviderRegistryHooks, } from '../../router/runtime/hooks.js';
+export type { LinkPrefetchPolicy } from '../../router/runtime/PrefetchLink.js';
+export type { LoaderFunction, LoaderFunctionArgs, ModernRoute, } from '../../router/runtime/types.js';
+export { getInitialContext, InternalRuntimeContext, RuntimeComponentResolverContext, RuntimeContext, type TInternalRuntimeContext, type TRuntimeContext, } from './runtime.js';
+export type { PayloadRoute, ServerPayload } from './serverPayload/index.js';
 interface GlobalContext {
     entryName?: string;
     /**
@@ -58,7 +56,7 @@ interface GlobalContext {
     serverPayload?: ServerPayload;
     enableRsc?: boolean;
 }
-export { getServerPayload, setServerPayload, } from './serverPayload/index';
+export { getServerPayload, setServerPayload, } from './serverPayload/index.js';
 export declare function getGlobalIsRscClient(): boolean | undefined;
 export declare function getGlobalEnableRsc(): boolean | undefined;
 export declare function setGlobalContext(context: Omit<GlobalContext, 'internalRuntimeContext'>): void;

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

@@ -1 +1 @@
-export declare const getMonitors: () => import("./default").RuntimeMonitors;
+export declare const getMonitors: () => import("./default.js").RuntimeMonitors;

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

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

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

@@ -1,23 +1 @@
-import type { RouteObject } from '@modern-js/runtime-utils/router';
-import type { RequestContext } from '../types';
-export type { RequestContext };
-export interface TRuntimeContext {
-    initialData?: Record<string, unknown>;
-    isBrowser: boolean;
-    routes?: RouteObject[];
-    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 { ReactRuntimeContext, type RequestContext, RuntimeContext, type TRuntimeContext, useRuntimeContext, } from './runtime.js';

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

@@ -1,7 +1,10 @@
+import type { ResolveComponentFn } from '@modern-js/plugin/runtime';
 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 TRuntimeContext } from './public';
+import type { LinkPrefetchPolicy } from '../../router/runtime/PrefetchLink.js';
+import type { RouteManifest } from '../../router/runtime/types.js';
+import type { RequestContext } from '../types.js';
+export type { RequestContext };
 export type InternalSSRContext = {
     request: BaseSSRServerContext['request'] & {
         raw?: Request;
@@ -9,12 +12,23 @@ export type InternalSSRContext = {
     response: BaseSSRServerContext['response'];
     [key: string]: any;
 };
-export { ReactRuntimeContext, RuntimeContext, type TRuntimeContext, useRuntimeContext, } from './public';
+export interface TRuntimeContext {
+    initialData?: Record<string, unknown>;
+    isBrowser: boolean;
+    routes?: RouteObject[];
+    requestContext: RequestContext;
+    /**
+     * @deprecated Use `requestContext` instead
+     */
+    context: RequestContext;
+    [key: string]: unknown;
+}
 /**
  * InternalRuntimeContext used internally and by plugins
  */
 export interface TInternalRuntimeContext extends TRuntimeContext {
     routeManifest?: RouteManifest;
+    linkPrefetchPolicy?: LinkPrefetchPolicy;
     routes?: RouteObject[];
     routerContext?: StaticHandlerContext;
     unstable_getBlockNavState?: () => boolean;
@@ -23,4 +37,14 @@ export interface TInternalRuntimeContext extends TRuntimeContext {
     _internalRouterBaseName?: any;
 }
 export declare const InternalRuntimeContext: import("react").Context<TInternalRuntimeContext>;
+export declare const RuntimeContext: import("react").Context<TRuntimeContext>;
+export declare const RuntimeComponentResolverContext: import("react").Context<ResolveComponentFn | undefined>;
+/**
+ * deprecated, use RuntimeContext instead
+ */
+export declare const ReactRuntimeContext: import("react").Context<TRuntimeContext>;
+/**
+ * @deprecated use use(RuntimeContext) instead
+ */
+export declare const useRuntimeContext: () => TRuntimeContext;
 export declare const getInitialContext: (isBrowser?: boolean, routeManifest?: RouteManifest) => TInternalRuntimeContext;

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

@@ -1,4 +1,4 @@
-import type { PayloadRoute, ServerPayload } from './index.server';
+import type { PayloadRoute, ServerPayload } from './index.server.js';
 export type { PayloadRoute, ServerPayload };
 export declare const getServerPayload: () => ServerPayload | undefined;
 export declare const setServerPayload: (payload: ServerPayload) => void;

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

@@ -1,5 +1,5 @@
-export { defineRuntimeConfig } from './config';
-export type { TRuntimeContext } from './context/runtime';
-export { RuntimeContext, useRuntimeContext, } from './context/runtime';
-export type { RuntimePlugin } from './plugin';
-export type { SSRContainer, SSRData } from './types';
+export { defineRuntimeConfig } from './config.js';
+export type { TRuntimeContext } from './context/runtime.js';
+export { RuntimeContext, useRuntimeContext, } from './context/runtime.js';
+export type { RuntimePlugin } from './plugin/index.js';
+export type { SSRContainer, SSRData } from './types.js';

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

@@ -1,5 +1,5 @@
 import type { InternalRuntimeContext } from '@modern-js/plugin/runtime';
-import type { RuntimeConfig, RuntimeExtends, RuntimePlugin } from './types';
+import type { RuntimeConfig, RuntimeExtends, RuntimePlugin } from './types.js';
 export type { RuntimePlugin };
 export declare function registerPlugin(internalPlugins: RuntimePlugin[], runtimeConfig?: RuntimeConfig): InternalRuntimeContext<RuntimeExtends>;
 export declare function mergeConfig(config: Record<string, any>, ...otherConfig: Record<string, any>[]): Record<string, any>;