@bleedingdev/modern-js-runtime 3.5.0-ultramodern.3 → 3.5.0-ultramodern.31

package/dist/esm-node/core/server/requestHandler.mjs

@@ -3,15 +3,13 @@ import { jsx } from "react/jsx-runtime";
 import { storage } from "@modern-js/runtime-utils/node";
 import { getPathname, parseCookie, parseHeaders, parseQuery } from "@modern-js/runtime-utils/universal/request";
 import react, { Fragment } from "react";
-import { getRouterServerSnapshot } from "../../router/runtime/lifecycle.mjs";
-import { handleRSCRedirect } from "../../router/runtime/rsc-router.mjs";
 import { getGlobalInternalRuntimeContext, getGlobalRSCRoot } from "../context/index.mjs";
 import { getInitialContext } from "../context/runtime.mjs";
 import { getServerPayload } from "../context/serverPayload/index.mjs";
 import { createRoot } from "../react/index.mjs";
 import { CHUNK_CSS_PLACEHOLDER } from "./constants.mjs";
-import { withRouterCleanup } from "./routerCleanup.mjs";
-import { SSRErrors } from "./tracer.mjs";
+import { applyRouterSnapshotResult, createLoaderRedirectResponse, finalizeRenderResponse } from "./requestResponse.mjs";
+import { createRouterCleanup, finishWithRouterCleanup, runWithRouterCleanupOnError } from "./routerCleanup.mjs";
 import { getSSRConfigByEntry, getSSRMode } from "./utils.mjs";
 async function handleRSCRequest(request, Root, context, options, handleRequest) {
     const serverPayload = getServerPayload();
@@ -31,29 +29,6 @@ async function handleRSCRequest(request, Root, context, options, handleRequest)
         runtimeContext: context
     });
 }
-const isRedirectStatus = (status)=>status >= 300 && status <= 399;
-const processRedirect = (headers, status, ctx)=>{
-    if (ctx.enableRsc && ctx.isRSCNavigation) return handleRSCRedirect(headers, ctx.basename, status);
-    return new Response(null, {
-        status,
-        headers
-    });
-};
-const applyRouterSnapshotResult = (context, onError)=>{
-    const routerServerSnapshot = getRouterServerSnapshot(context);
-    const routerStatusCode = routerServerSnapshot?.statusCode ?? context.routerContext?.statusCode;
-    if (routerStatusCode && 200 !== routerStatusCode) context.ssrContext?.response.status(routerStatusCode);
-    const errors = Object.values(routerServerSnapshot?.errors || context.routerContext?.errors || {});
-    if (errors.length > 0) onError(errors[0], SSRErrors.LOADER_ERROR);
-};
-const createLoaderRedirectResponse = (beforeRenderResult, redirectCtx)=>{
-    if (!beforeRenderResult || !isRedirectStatus(beforeRenderResult.status)) return;
-    if (beforeRenderResult.headers.has('X-Modernjs-Redirect')) return beforeRenderResult;
-    const redirectUrl = beforeRenderResult.headers.get('Location') || '/';
-    return processRedirect(new Headers({
-        Location: redirectUrl
-    }), beforeRenderResult.status, redirectCtx);
-};
 const renderRequest = async (request, Root, context, options, handleRequest, enableRsc)=>{
     if (enableRsc) return handleRSCRequest(request, Root, context, options, handleRequest);
     return handleRequest(request, Root, {
@@ -61,17 +36,6 @@ const renderRequest = async (request, Root, context, options, handleRequest, ena
         runtimeContext: context
     });
 };
-const finalizeRenderResponse = (response, responseProxy, redirectCtx, routerCleanup)=>{
-    if (-1 !== responseProxy.status && isRedirectStatus(responseProxy.status) && responseProxy.headers.Location) return processRedirect(new Headers(responseProxy.headers), responseProxy.status, redirectCtx);
-    Object.entries(responseProxy.headers).forEach(([key, value])=>{
-        response.headers.set(key, value);
-    });
-    if (-1 !== responseProxy.status) return routerCleanup.deferUntilBodyDone(new Response(response.body, {
-        status: responseProxy.status,
-        headers: response.headers
-    }));
-    return routerCleanup.deferUntilBodyDone(response);
-};
 function createSSRContext(request, options) {
     const { config, loaderContext, onError, onTiming, locals, resource, params, responseProxy, reporter } = options;
     const { nonce, useJsonScript } = config;
@@ -167,20 +131,26 @@ const createRequestHandler = async (handleRequest, createRequestOptions)=>{
                 isRSCNavigation: 'true' === request.headers.get('x-rsc-tree'),
                 basename: ssrContext.baseUrl || '/'
             };
-            return withRouterCleanup(context, options.onError, async (routerCleanup)=>{
-                const beforeRenderResult = await runBeforeRender(context);
+            const routerCleanup = createRouterCleanup(context, options.onError);
+            const beforeRenderResult = await runWithRouterCleanupOnError(routerCleanup, ()=>runBeforeRender(context));
+            await runWithRouterCleanupOnError(routerCleanup, ()=>{
                 applyRouterSnapshotResult(context, options.onError);
-                if ("u" > typeof Response) {
-                    const redirectResponse = createLoaderRedirectResponse(beforeRenderResult, redirectCtx);
-                    if (redirectResponse) return redirectResponse;
+            });
+            if ("u" > typeof Response) {
+                const redirectResponse = await runWithRouterCleanupOnError(routerCleanup, ()=>createLoaderRedirectResponse(beforeRenderResult, redirectCtx));
+                if (redirectResponse) {
+                    await routerCleanup.run();
+                    return redirectResponse;
                 }
+            }
+            await runWithRouterCleanupOnError(routerCleanup, ()=>{
                 if (!createRequestOptions?.enableRsc) {
                     const { htmlTemplate } = options.resource;
                     options.resource.htmlTemplate = htmlTemplate.replace('</head>', `${CHUNK_CSS_PLACEHOLDER}</head>`);
                 }
-                const response = await renderRequest(request, Root, context, options, handleRequest, !!createRequestOptions?.enableRsc);
-                return finalizeRenderResponse(response, responseProxy, redirectCtx, routerCleanup);
             });
+            const response = await runWithRouterCleanupOnError(routerCleanup, ()=>renderRequest(request, Root, context, options, handleRequest, !!createRequestOptions?.enableRsc));
+            return finishWithRouterCleanup(routerCleanup, ()=>finalizeRenderResponse(response, responseProxy, redirectCtx, routerCleanup));
         });
     };
     return requestHandler;

package/dist/esm-node/core/server/requestResponse.mjs

@@ -0,0 +1,40 @@
+import "node:module";
+import { getRouterServerSnapshot } from "../../router/runtime/lifecycle.mjs";
+import { handleRSCRedirect } from "../../router/runtime/rsc-router.mjs";
+import { SSRErrors } from "./tracer.mjs";
+const isRedirectStatus = (status)=>status >= 300 && status <= 399;
+const isNullBodyStatus = (status)=>204 === status || 205 === status || 304 === status;
+const processRedirect = (headers, status, ctx)=>{
+    if (ctx.enableRsc && ctx.isRSCNavigation) return handleRSCRedirect(headers, ctx.basename, status);
+    return new Response(null, {
+        status,
+        headers
+    });
+};
+const applyRouterSnapshotResult = (context, onError)=>{
+    const routerServerSnapshot = getRouterServerSnapshot(context);
+    const routerStatusCode = routerServerSnapshot?.statusCode ?? context.routerContext?.statusCode;
+    if (routerStatusCode && 200 !== routerStatusCode) context.ssrContext?.response.status(routerStatusCode);
+    const errors = Object.values(routerServerSnapshot?.errors || context.routerContext?.errors || {});
+    if (errors.length > 0) onError(errors[0], SSRErrors.LOADER_ERROR);
+};
+const createLoaderRedirectResponse = (beforeRenderResult, redirectCtx)=>{
+    if (!beforeRenderResult || !isRedirectStatus(beforeRenderResult.status)) return;
+    if (beforeRenderResult.headers.has('X-Modernjs-Redirect')) return beforeRenderResult;
+    const redirectUrl = beforeRenderResult.headers.get('Location') || '/';
+    return processRedirect(new Headers({
+        Location: redirectUrl
+    }), beforeRenderResult.status, redirectCtx);
+};
+const finalizeRenderResponse = (response, responseProxy, redirectCtx, routerCleanup)=>{
+    if (-1 !== responseProxy.status && isRedirectStatus(responseProxy.status) && responseProxy.headers.Location) return processRedirect(new Headers(responseProxy.headers), responseProxy.status, redirectCtx);
+    Object.entries(responseProxy.headers).forEach(([key, value])=>{
+        response.headers.set(key, value);
+    });
+    if (-1 !== responseProxy.status) return routerCleanup.deferUntilBodyDone(new Response(isNullBodyStatus(responseProxy.status) ? null : response.body, {
+        status: responseProxy.status,
+        headers: response.headers
+    }));
+    return routerCleanup.deferUntilBodyDone(response);
+};
+export { applyRouterSnapshotResult, createLoaderRedirectResponse, finalizeRenderResponse };

package/dist/esm-node/core/server/routerCleanup.mjs

@@ -9,6 +9,21 @@ async function withRouterCleanup(runtimeContext, onError, callback) {
         if (!routerCleanup.deferred) await routerCleanup.run();
     }
 }
+async function runWithRouterCleanupOnError(routerCleanup, callback) {
+    try {
+        return await callback();
+    } catch (error) {
+        await routerCleanup.run();
+        throw error;
+    }
+}
+async function finishWithRouterCleanup(routerCleanup, callback) {
+    try {
+        return await callback();
+    } finally{
+        if (!routerCleanup.deferred) await routerCleanup.run();
+    }
+}
 function createRouterCleanup(runtimeContext, onError) {
     let deferred = false;
     let finished = false;
@@ -64,4 +79,4 @@ function createRouterCleanup(runtimeContext, onError) {
         deferUntilBodyDone
     };
 }
-export { ROUTER_CLEANUP_ERROR, createRouterCleanup, withRouterCleanup };
+export { ROUTER_CLEANUP_ERROR, createRouterCleanup, finishWithRouterCleanup, runWithRouterCleanupOnError, withRouterCleanup };

package/dist/esm-node/core/server/scriptOrder.mjs

@@ -43,6 +43,10 @@ function getMatchedRouteAssets(runtimeContext, routeManifest) {
     const matchedRouteIds = getRouterMatchedRouteIds(runtimeContext) ?? [];
     return matchedRouteIds.flatMap((routeId)=>routeAssets[routeId]?.assets ?? []);
 }
+function getMatchedRouteChunks(runtimeContext, routeManifest, routeAssetToChunk) {
+    if (!routeManifest) return [];
+    return getMatchedRouteAssets(runtimeContext, routeManifest).map(routeAssetToChunk);
+}
 const orderHydrationScriptChunks = ({ asyncEntryChunks, collectedChunks, matchedRouteChunks, entryName })=>{
     const asyncEntryScriptChunks = [];
     const asyncEntryDependencyChunks = [];
@@ -73,13 +77,12 @@ function createRouteHydrationScriptTags(runtimeContext, entryName, options = {})
     const { nonce, template } = options;
     const routeAssets = getRouteAssets(runtimeContext);
     if (void 0 === routeAssets) return '';
-    const matchedRouteIds = getRouterMatchedRouteIds(runtimeContext) ?? [];
-    const assetEntries = [
-        ...matchedRouteIds.map((routeId)=>routeAssets[routeId]),
-        routeAssets[`async-${entryName}`]
-    ].filter((entry)=>void 0 !== entry);
-    const jsAssets = Array.from(new Set(assetEntries.flatMap((entry)=>(entry.assets ?? []).filter((asset)=>asset.endsWith('.js')))));
+    const existingScriptSrcs = void 0 === template ? new Set() : new Set(getScriptTags(template).map(({ src })=>src));
+    const jsAssets = Array.from(new Set([
+        ...getMatchedRouteAssets(runtimeContext),
+        ...routeAssets[`async-${entryName}`]?.assets ?? []
+    ].filter((asset)=>asset.endsWith('.js'))));
     const nonceAttr = void 0 === nonce || '' === nonce ? '' : ` nonce="${nonce}"`;
-    return jsAssets.filter((asset)=>template?.includes(asset) !== true).map((asset)=>`<script src=${asset}${nonceAttr}></script>`).join(' ');
+    return jsAssets.filter((asset)=>!existingScriptSrcs.has(asset)).map((asset)=>`<script src=${asset}${nonceAttr}></script>`).join(' ');
 }
-export { createRouteHydrationScriptTags, getMatchedRouteAssets, injectBeforeHydrationEntryScript, orderHydrationScriptChunks, replaceChunkJsPlaceholder };
+export { createRouteHydrationScriptTags, getMatchedRouteAssets, getMatchedRouteChunks, injectBeforeHydrationEntryScript, orderHydrationScriptChunks, replaceChunkJsPlaceholder };

package/dist/esm-node/core/server/string/loadable.mjs

@@ -1,7 +1,7 @@
 import "node:module";
 import { ChunkExtractor } from "@loadable/server";
 import { createFederatedCssLinks } from "../federatedCss.mjs";
-import { getMatchedRouteAssets, orderHydrationScriptChunks } from "../scriptOrder.mjs";
+import { getMatchedRouteChunks, orderHydrationScriptChunks } from "../scriptOrder.mjs";
 import { attributesToString, checkIsNode, hasStylesheetLink } from "../utils.mjs";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
@@ -32,11 +32,6 @@ const readAsset = async (chunk)=>{
     return fs.readFile(filepath, 'utf-8');
 };
 class LoadableCollector {
-    getMatchedRouteChunks() {
-        const { routeManifest, runtimeContext } = this.options;
-        if (!routeManifest) return [];
-        return getMatchedRouteAssets(runtimeContext, routeManifest).map(routeAssetToChunk);
-    }
     collect(comopnent) {
         const { stats, entryName } = this.options;
         if (!stats) return comopnent;
@@ -58,7 +53,7 @@ class LoadableCollector {
             ]));
         } catch (e) {}
         const collectedChunks = extractor ? extractor.getChunkAssets(extractor.chunks) : [];
-        const matchedRouteChunks = this.getMatchedRouteChunks();
+        const matchedRouteChunks = getMatchedRouteChunks(options.runtimeContext, options.routeManifest, routeAssetToChunk);
         const orderedScriptChunks = orderHydrationScriptChunks({
             asyncEntryChunks: asyncChunks,
             collectedChunks,
@@ -136,4 +131,4 @@ class LoadableCollector {
         this.options = options;
     }
 }
-export { LoadableCollector, orderHydrationScriptChunks };
+export { LoadableCollector };

package/dist/esm-node/index.mjs

@@ -1,6 +1,7 @@
 import "node:module";
 export { isBrowser } from "./common.mjs";
-export { RuntimeContext, defineRuntimeConfig, useRuntimeContext } from "./core/index.mjs";
+export { defineRuntimeConfig } from "./core/config.mjs";
 export { getMonitors } from "./core/context/monitors/index.mjs";
+export { RuntimeContext, useRuntimeContext } from "./core/context/public.mjs";
 export { getRequest } from "./core/context/request/index.mjs";
 export { redirect, setHeaders, setStatus } from "./core/context/response/index.mjs";

package/dist/esm-node/router/cli/code/templates.mjs

@@ -184,7 +184,8 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
             component = `component_${components.length - 1}`;
         }
         const isClientComponent = 'nested' === route.type && Boolean(route._component) && Boolean(srcDirectory) && Boolean(internalSrcAlias) && await hasUseClientDirective(route._component, srcDirectory, internalSrcAlias);
-        const shouldIncludeClientBundle = !isRscClientBundle || isClientComponent;
+        const shouldHydrateRscRoute = isRscClientBundle && !isClientComponent && !route.loader && !route.data;
+        const shouldIncludeClientBundle = !isRscClientBundle || isClientComponent || shouldHydrateRscRoute;
         const finalRoute = {
             ...route,
             loading,
@@ -287,7 +288,7 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
     ${importLazyCode}
     ${!isRscClientBundle ? importComponentsCode : ''}
     ${importRuntimeRouterCode}
-    ${!isRscClientBundle ? rootLayoutCode : ''}
+    ${rootLayoutCode}
     ${importLoadingCode}
     ${importErrorComponentsCode}
     ${importLoadersCode}

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

@@ -1,9 +1,10 @@
 import "node:module";
 import { createSyncHook } from "@modern-js/plugin";
-const modifyRoutes = createSyncHook();
-const onBeforeCreateRoutes = createSyncHook();
-const onBeforeCreateRouter = createSyncHook();
-const onAfterCreateRouter = createSyncHook();
-const onBeforeHydrateRouter = createSyncHook();
-const onAfterHydrateRouter = createSyncHook();
+const createRouterSyncHook = ()=>createSyncHook();
+const modifyRoutes = createRouterSyncHook();
+const onBeforeCreateRoutes = createRouterSyncHook();
+const onBeforeCreateRouter = createRouterSyncHook();
+const onAfterCreateRouter = createRouterSyncHook();
+const onBeforeHydrateRouter = createRouterSyncHook();
+const onAfterHydrateRouter = createRouterSyncHook();
 export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter };

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

@@ -41,7 +41,7 @@ function registerRouterProvider(name, factory, options = {}) {
 }
 function resolveRouterProvider(framework, options = {}) {
     const registry = getRegistry();
-    const name = framework || registry.defaultProvider || options.localDefault?.name;
+    const name = framework || options.localDefault?.name || registry.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);

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/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/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 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,26 @@
+export type RuntimeRequest = Record<string, unknown>;
+export 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;

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

@@ -25,4 +25,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

@@ -10,6 +10,7 @@ type ScriptChunkLike = {
     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/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/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,4 +1,4 @@
-import type { RuntimePlugin } from '../../core';
+import type { RuntimePlugin } from '../../common';
 import type { RouterExtendsHooks } from './hooks';
 import type { RouterConfig, SingleRouteConfig } from './types';
 export declare const routerPlugin: (userConfig?: Partial<RouterConfig>) => RuntimePlugin<{

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<{