@modern-js/runtime 2.69.5 → 3.0.0-alpha.0

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

@@ -6,14 +6,13 @@ export declare const entryForCSRWithRSC: ({ metaName, entryName, urlPath, mountI
     mountId?: string;
     isNestedRouter?: string;
 }) => string;
-export declare const index: ({ srcDirectory, internalSrcAlias, metaName, entry, entryName, customEntry, customBootstrap, mountId, enableRsc, isNestedRouter, }: {
+export declare const index: ({ srcDirectory, internalSrcAlias, metaName, entry, entryName, customEntry, mountId, enableRsc, isNestedRouter, }: {
     srcDirectory: string;
     internalSrcAlias: string;
     metaName: string;
     entry: string;
     entryName: string;
     customEntry?: boolean;
-    customBootstrap?: string | false;
     mountId?: string;
     enableRsc?: boolean;
     isNestedRouter?: boolean;
@@ -27,13 +26,14 @@ export declare const runtimeRegister: ({ entryName, srcDirectory, internalSrcAli
     runtimeConfigFile: string | false;
     runtimePlugins: RuntimePluginConfig[];
 }) => string;
-export declare const runtimeGlobalContext: ({ entryName, srcDirectory, internalSrcAlias, metaName, entry, customEntry, }: {
+export declare const runtimeGlobalContext: ({ entryName, srcDirectory, internalSrcAlias, metaName, entry, customEntry, basename, }: {
     entryName: string;
     srcDirectory: string;
     internalSrcAlias: string;
     metaName: string;
     entry: string;
     customEntry?: boolean;
+    basename?: string;
 }) => string;
 export declare const runtimeGlobalContextForRSCServer: ({ metaName, }: {
     metaName: string;

package/dist/types/common.d.ts

@@ -1,12 +1,7 @@
-import type { Plugin, RuntimePluginFuture } from './core/plugin';
-import type { RouterConfig } from './router/internal';
+import type { RuntimePlugin } from './core/plugin';
 export declare const isBrowser: () => boolean;
-export interface AppConfig {
-    router?: Pick<RouterConfig, 'future' | 'basename'>;
-    [key: string]: any;
-}
 export interface RuntimeConfig {
-    plugins?: (Plugin | RuntimePluginFuture)[];
+    plugins?: RuntimePlugin[];
     [key: string]: any;
 }
 export declare const JSX_SHELL_STREAM_END_MARK = "<!--<?- SHELL_STREAM_END ?>-->";

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 { RuntimeContext } from '../context/runtime';
+import type { TRuntimeContext } from '../context/runtime';
 export declare const isReact18: () => boolean;
-export declare function hydrateRoot(App: React.ReactElement, context: RuntimeContext, ModernRender: (App: React.ReactElement) => Promise<HTMLElement | Root>, ModernHydrate: (App: React.ReactElement, callback?: () => void) => Promise<HTMLElement | Root>): Promise<HTMLElement | 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,6 +1,8 @@
 import type React from 'react';
 export type RenderFunc = typeof render;
-export declare function render(App: React.ReactElement, id?: HTMLElement | string): Promise<HTMLElement | import("react-dom/client").Root>;
+export declare function render(App: React.ReactElement<{
+    basename: string;
+}>, id?: HTMLElement | string): Promise<HTMLElement | import("react-dom/client").Root>;
 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>;

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

@@ -1,4 +1,4 @@
-import type { RuntimeContext } from '../context';
+import type { TInternalRuntimeContext } from '../context';
 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: RuntimeContext): Record<string, any>;
+export declare function getHookRunners(runtimeContext: TInternalRuntimeContext): Record<string, any>;

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

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

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

@@ -1,24 +1,5 @@
-import type { RuntimeContext } from '../context';
-import type { RuntimePluginFuture } from '../plugin/types';
-export declare const makeRequestContext: (context: RuntimeContext) => import("../types").ServerContext | import("../types").ClientContext | {
-    isBrowser: boolean;
-    request: {
-        [propsName: string]: any;
-        params: Record<string, string>;
-        pathname: string;
-        query: Record<string, string>;
-        headers: import("http").IncomingHttpHeaders;
-        host: string;
-        url: string;
-        referer?: string;
-        userAgent?: string;
-        cookie?: string;
-        cookieMap?: Record<string, string>;
-    } & {
-        baseUrl: string;
-        raw: Request;
-    };
-    response: import("@modern-js/types").BaseResponseLike;
-    logger: import("@modern-js/types").Logger;
-};
-export declare const requestContextPlugin: () => RuntimePluginFuture;
+import type { TInternalRuntimeContext } from '../context';
+import type { RuntimePlugin } from '../plugin/types';
+import type { RequestContext } from '../types';
+export declare const makeRequestContext: (context: TInternalRuntimeContext) => RequestContext;
+export declare const requestContextPlugin: () => RuntimePlugin;

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

@@ -1,11 +1,4 @@
-import type React from 'react';
-import type { AppConfig, RuntimeConfig } from '../common';
-export declare const getConfig: (Component: React.ComponentType<any>) => AppConfig | undefined;
-/**
- * @deprecated
- * define config in modern.runtime.ts file
- */
-export declare const defineConfig: (Component: React.ComponentType<any>, config: AppConfig) => React.ComponentType<any>;
+import type { RuntimeConfig } from '../common';
 /**
  * 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/constants.d.ts

@@ -1,6 +1,5 @@
 export declare enum RenderLevel {
     CLIENT_RENDER = 0,
-    SERVER_PREFETCH = 1,
     SERVER_RENDER = 2
 }
 export declare const SSR_DATA_JSON_ID = "__MODERN_SSR_DATA__";

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

@@ -1,10 +1,9 @@
-import type { InternalRuntimeContext } from '@modern-js/plugin-v2';
+import type { InternalRuntimeContext } from '@modern-js/plugin';
 import type { NestedRoute, PageRoute } from '@modern-js/types';
 import type React from 'react';
-import type { AppConfig } from '../../common';
 import type { RuntimeExtends } from '../plugin/types';
 import type { ServerPayload } from './serverPayload/index';
-export { type RuntimeContext, RuntimeReactContext, getInitialContext, } from './runtime';
+export { type TRuntimeContext, type TInternalRuntimeContext, RuntimeContext, InternalRuntimeContext, getInitialContext, } from './runtime';
 export type { ServerPayload, PayloadRoute } from './serverPayload/index';
 interface GlobalContext {
     entryName?: string;
@@ -20,14 +19,14 @@ interface GlobalContext {
      * nest router init function
      */
     appInit?: () => Promise<unknown>;
-    /**
-     * nest router config function
-     */
-    appConfig?: AppConfig;
     /**
      * page router _app.tsx export layout app
      */
     layoutApp?: React.ComponentType;
+    /**
+     * Entry basename for routing
+     */
+    basename?: string;
     internalRuntimeContext?: InternalRuntimeContext<RuntimeExtends>;
     /**
      * RSCRoot
@@ -40,15 +39,12 @@ interface GlobalContext {
 export { getServerPayload, setServerPayload, } from './serverPayload/index';
 export declare function getGlobalIsRscClient(): boolean | undefined;
 export declare function getGlobalEnableRsc(): boolean | undefined;
-export declare function setGlobalContext(context: Omit<GlobalContext, 'appConfig' | 'internalRuntimeContext'> & {
-    appConfig?: () => AppConfig;
-}): void;
+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-v2").RuntimePluginExtends<import("../plugin/types").RuntimeConfig, import("./runtime").RuntimeContext, {}, {}>>>;
+export declare function getGlobalInternalRuntimeContext(): InternalRuntimeContext<Required<import("@modern-js/plugin").RuntimePluginExtends<import("../plugin/types").RuntimeConfig, import("./runtime").TInternalRuntimeContext, {}, {}>>>;
 export declare function getGlobalApp(): React.ComponentType<{}> | undefined;
 export declare function getGlobalRoutes(): undefined | (NestedRoute | PageRoute)[];
-export declare function getGlobalAppInit(): any;
-export declare function getGlobalAppConfig(): any;
 export declare function getGlobalLayoutApp(): React.ComponentType<{}> | undefined;
+export declare function getGlobalBasename(): string | undefined;

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: () => Omit<import("@modern-js/types/server").Monitors, "push">;

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

@@ -1,36 +1,33 @@
-import type { StaticHandlerContext } from '@modern-js/runtime-utils/remix-router';
 import type { RouteObject } from '@modern-js/runtime-utils/router';
+import type { StaticHandlerContext } from '@modern-js/runtime-utils/router';
 import type { RouteManifest } from '../../router/runtime/types';
-import { createLoaderManager } from '../loader/loaderManager';
-import type { SSRServerContext, TSSRContext } from '../types';
-interface BaseRuntimeContext {
-    initialData?: Record<string, unknown>;
-    loaderManager: ReturnType<typeof createLoaderManager>;
-    isBrowser: boolean;
-    ssrContext?: SSRServerContext;
-    routeManifest: RouteManifest;
-    routerContext?: StaticHandlerContext;
-    context?: TSSRContext;
-    /**
-     * private
-     */
-    unstable_getBlockNavState?: () => boolean;
-}
-export interface RuntimeContext extends BaseRuntimeContext {
-    [key: string]: any;
-}
-export declare const RuntimeReactContext: import("react").Context<RuntimeContext>;
-export declare const ServerRouterContext: import("react").Context<any>;
+import type { RequestContext, SSRServerContext } from '../types';
 export interface TRuntimeContext {
     initialData?: Record<string, unknown>;
     isBrowser: boolean;
-    context: TSSRContext;
-    /** @deprecated use context.request field instead */
-    request?: SSRServerContext['request'];
-    /** @deprecated use context.response field instead */
-    response?: SSRServerContext['response'];
     routes?: RouteObject[];
-    [key: string]: any;
+    context: RequestContext;
+    [key: string]: unknown;
+}
+/**
+ * InternalRuntimeContext used internally and by plugins
+ */
+export interface TInternalRuntimeContext extends TRuntimeContext {
+    routeManifest?: RouteManifest;
+    routerContext?: StaticHandlerContext;
+    unstable_getBlockNavState?: () => boolean;
+    ssrContext?: SSRServerContext;
+    _internalContext?: any;
+    _internalRouterBaseName?: any;
 }
-export declare const getInitialContext: (isBrowser?: boolean, routeManifest?: RouteManifest) => RuntimeContext;
-export {};
+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/context/serverPayload/index.server.d.ts

@@ -1,4 +1,4 @@
-import type { RouterState } from '@modern-js/runtime-utils/remix-router';
+import type { RouterState } from '@modern-js/runtime-utils/router';
 export type PayloadRoute = {
     clientAction?: any;
     clientLoader?: any;

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

@@ -1,8 +1,5 @@
-export type { Plugin, RuntimePluginFuture } from './plugin';
-export { defineConfig, getConfig, defineRuntimeConfig } from './config';
-export * from './compatible';
-export type { RuntimeContext } from './context/runtime';
-export { RuntimeReactContext, ServerRouterContext } from './context/runtime';
-export * from './loader';
+export type { RuntimePlugin } from './plugin';
+export { defineRuntimeConfig } from './config';
+export type { TRuntimeContext } from './context/runtime';
+export { RuntimeContext, useRuntimeContext, } from './context/runtime';
 export type { SSRData, SSRContainer } from './types';
-export * from '@modern-js/plugin';

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

@@ -1,20 +1,20 @@
-import type { Plugin as RuntimePlugin } from './base';
-import type { RuntimeConfig, RuntimePluginFuture } from './types';
-export type { Plugin } from './base';
-export type { RuntimePluginFuture };
-export declare function registerPlugin(internalPlugins: (RuntimePlugin | RuntimePluginFuture)[], runtimeConfig?: RuntimeConfig): {
-    hooks: import("@modern-js/plugin-v2/runtime").Hooks<{} | undefined, import("@modern-js/plugin-v2/runtime").RuntimeContext>;
+import type { RuntimeConfig, RuntimePlugin } from './types';
+export type { RuntimePlugin };
+export declare function registerPlugin(internalPlugins: RuntimePlugin[], runtimeConfig?: RuntimeConfig): {
+    hooks: import("@modern-js/plugin/runtime").Hooks<{} | undefined, import("@modern-js/plugin/runtime").RuntimeContext>;
     extendsHooks: {} | undefined;
     config: {} | undefined;
     pluginAPI?: Readonly<{
-        updateRuntimeContext: (updateContext: import("@modern-js/plugin-v2/dist/types/types/utils").DeepPartial<import("@modern-js/plugin-v2/runtime").RuntimeContext>) => void;
-        getHooks: () => Readonly<import("@modern-js/plugin-v2/runtime").Hooks<{} | undefined, import("@modern-js/plugin-v2/runtime").RuntimeContext>>;
+        updateRuntimeContext: (updateContext: import("@modern-js/plugin/dist/types/types/utils").DeepPartial<import("@modern-js/plugin/runtime").RuntimeContext>) => void;
+        getHooks: () => Readonly<import("@modern-js/plugin/runtime").Hooks<{} | undefined, import("@modern-js/plugin/runtime").RuntimeContext>>;
         getRuntimeConfig: () => Readonly<{} | undefined>;
-        onBeforeRender: import("@modern-js/plugin-v2/dist/types").PluginHookTap<import("@modern-js/plugin-v2/dist/types/types/runtime/hooks").OnBeforeRenderFn<{} | undefined>>;
-        wrapRoot: import("@modern-js/plugin-v2/dist/types").PluginHookTap<import("@modern-js/plugin-v2/dist/types/types/runtime/hooks").WrapRootFn>;
-        pickContext: import("@modern-js/plugin-v2/dist/types").PluginHookTap<import("@modern-js/plugin-v2/dist/types/types/runtime/hooks").PickContextFn<import("@modern-js/plugin-v2/runtime").RuntimeContext>>;
-        config: import("@modern-js/plugin-v2/dist/types").PluginHookTap<import("@modern-js/plugin-v2/dist/types/types/runtime/hooks").ConfigFn<{} | undefined>>;
+        onBeforeRender: import("@modern-js/plugin/dist/types").PluginHookTap<import("@modern-js/plugin/dist/types/types/runtime/hooks").OnBeforeRenderFn<{} | undefined>>;
+        wrapRoot: import("@modern-js/plugin/dist/types").PluginHookTap<import("@modern-js/plugin/dist/types/types/runtime/hooks").WrapRootFn>;
+        pickContext: import("@modern-js/plugin/dist/types").PluginHookTap<import("@modern-js/plugin/dist/types/types/runtime/hooks").PickContextFn<import("@modern-js/plugin/runtime").RuntimeContext>>;
+        config: import("@modern-js/plugin/dist/types").PluginHookTap<import("@modern-js/plugin/dist/types/types/runtime/hooks").ConfigFn<{} | undefined>>;
+        extendStringSSRCollectors: import("@modern-js/plugin/dist/types").PluginHookTap<import("@modern-js/plugin/dist/types/types/runtime/hooks").ExtendStringSSRCollectorsFn<import("@modern-js/plugin/dist/types/types/runtime/hooks").StringSSRCollectorsInfo>>;
+        extendStreamSSR: import("@modern-js/plugin/dist/types").PluginHookTap<import("@modern-js/plugin/dist/types/types/runtime/hooks").ExtendStreamSSRFn>;
     } & {}> | undefined;
-    _internalContext?: any | undefined;
+    _internalContext?: /*elided*/ any | undefined;
 };
 export declare function mergeConfig(config: Record<string, any>, ...otherConfig: Record<string, any>[]): Record<string, any>;

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

@@ -1,11 +1,10 @@
-import type { RuntimePlugin as BaseRuntimePlugin, RuntimePluginExtends } from '@modern-js/plugin-v2';
-import type { Hooks } from '@modern-js/plugin-v2/runtime';
-import type { AppConfig } from '../../common';
-import type { RuntimeContext } from '../context/runtime';
-import type { Plugin } from './base';
-export type RuntimeHooks = Hooks<RuntimeConfig, RuntimeContext>;
-export type RuntimeExtends = Required<RuntimePluginExtends<RuntimeConfig, RuntimeContext, {}, {}>>;
-export type RuntimePluginFuture<Extends extends RuntimePluginExtends = {}> = BaseRuntimePlugin<RuntimeExtends & Extends>;
-export interface RuntimeConfig extends AppConfig {
-    plugins?: (Plugin | RuntimePluginFuture)[];
+import type { RuntimePlugin as BaseRuntimePlugin, RuntimePluginExtends } from '@modern-js/plugin';
+import type { Hooks } from '@modern-js/plugin/runtime';
+import type { RuntimeConfig as BaseRuntimeConfig } from '../../common';
+import type { TInternalRuntimeContext } from '../context/runtime';
+export type RuntimeHooks = Hooks<RuntimeConfig, TInternalRuntimeContext>;
+export type RuntimeExtends = Required<RuntimePluginExtends<RuntimeConfig, TInternalRuntimeContext, {}, {}>>;
+export type RuntimePlugin<Extends extends RuntimePluginExtends = {}> = BaseRuntimePlugin<RuntimeExtends & Extends>;
+export interface RuntimeConfig extends BaseRuntimeConfig {
+    plugins?: RuntimePlugin[];
 }

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

@@ -1,3 +1,3 @@
-import React from 'react';
-import { type RuntimeContext } from '../context';
-export declare function wrapRuntimeContextProvider(App: React.ReactElement, contextValue: RuntimeContext): React.FunctionComponentElement<React.ProviderProps<RuntimeContext>>;
+import type React from 'react';
+import { type TRuntimeContext } from '../context';
+export declare function wrapRuntimeContextProvider(App: React.ReactElement, contextValue: TRuntimeContext): React.JSX.Element;

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

@@ -1,4 +1,4 @@
-import type { Plugin } from '../plugin';
-export { PreRender, NoSSR, NoSSRCache } from './react';
-export declare const ssr: (_config: any) => Plugin;
+import type { RuntimePlugin } from '../plugin';
+export { NoSSR, NoSSRCache } from './react';
+export declare const ssr: (_config: any) => RuntimePlugin;
 export default ssr;

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

@@ -1,3 +1,2 @@
-export { PreRender } from './prerender';
 export { NoSSR } from './nossr';
 export { NoSSRCache } from './no-ssr-cache';

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

@@ -1,9 +1,9 @@
 import type { RequestHandler, RequestHandlerOptions } from '@modern-js/app-tools';
-import type React from 'react';
-import { type RuntimeContext } from '../context';
+import React from 'react';
+import { type TInternalRuntimeContext } from '../context';
 export type { RequestHandlerConfig as HandleRequestConfig } from '@modern-js/app-tools';
 export type HandleRequestOptions = Exclude<RequestHandlerOptions, 'staticGenerate'> & {
-    runtimeContext: RuntimeContext;
+    runtimeContext: TInternalRuntimeContext;
 };
 export type HandleRequest = (request: Request, ServerRoot: React.ComponentType, // App, routes,
 options: HandleRequestOptions) => Promise<Response>;

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

@@ -1,9 +1,9 @@
 import { type RenderLevel } from '../../constants';
-import type { RuntimeContext } from '../../context';
+import type { TInternalRuntimeContext } from '../../context';
 import type { HandleRequestConfig } from '../requestHandler';
 import { type SSRConfig } from '../shared';
 export type BuildShellAfterTemplateOptions = {
-    runtimeContext: RuntimeContext;
+    runtimeContext: TInternalRuntimeContext;
     renderLevel: RenderLevel;
     ssrConfig: SSRConfig;
     request: Request;

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

@@ -1,7 +1,7 @@
-import type { RuntimeContext } from '../../context';
+import type { TInternalRuntimeContext } from '../../context';
 import type { HandleRequestConfig } from '../requestHandler';
 export interface BuildShellBeforeTemplateOptions {
-    runtimeContext: RuntimeContext;
+    runtimeContext: TInternalRuntimeContext;
     entryName: string;
     config: HandleRequestConfig;
     styledComponentsStyleTags?: string;

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

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

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

@@ -17,8 +17,8 @@ export interface LoadableCollectorOptions {
 }
 export interface LoadableCollectorConfig {
     scriptLoading?: 'defer' | 'blocking' | 'module' | 'async';
-    enableInlineStyles?: boolean | RegExp;
-    enableInlineScripts?: boolean | RegExp;
+    inlineStyles?: boolean | RegExp;
+    inlineScripts?: boolean | RegExp;
     crossorigin?: boolean | 'anonymous' | 'use-credentials';
     enableAsyncEntry?: boolean;
 }

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

@@ -1,10 +1,11 @@
-import type { StaticHandlerContext } from '@modern-js/runtime-utils/remix-router';
+import type { StaticHandlerContext } from '@modern-js/runtime-utils/router';
+import type { TRuntimeContext } from '../../context';
 import type { SSRServerContext } from '../../types';
 import type { SSRConfig } from '../shared';
 import type { ChunkSet, Collector } from './types';
 export interface SSRDataCreatorOptions {
+    runtimeContext: TRuntimeContext;
     request: Request;
-    prefetchData: Record<string, any>;
     chunkSet: ChunkSet;
     ssrContext: SSRServerContext;
     ssrConfig?: SSRConfig;

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

@@ -2,12 +2,10 @@ import type { OnError, OnTiming } from '@modern-js/app-tools';
 export declare enum SSRTimings {
     PRERENDER = "ssr-prerender",
     RENDER_HTML = "ssr-render-html",
-    RENDER_SHELL = "ssr-render-shell",
-    USE_LOADER = "use-loader"
+    RENDER_SHELL = "ssr-render-shell"
 }
 export declare enum SSRErrors {
     PRERENDER = "App Prerender",
-    USE_LOADER = "App run useLoader",
     RENDER_HTML = "App Render To HTML",
     RENDER_STREAM = "An error occurs during streaming SSR",
     RENDER_SHELL = "An error occurs during streaming render shell",

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

@@ -1,5 +1,5 @@
 import type { ServerUserConfig } from '@modern-js/app-tools';
-import { type StaticHandlerContext } from '@modern-js/runtime-utils/remix-router';
+import { type StaticHandlerContext } from '@modern-js/runtime-utils/router';
 import type { SSRConfig } from './shared';
 export declare function attributesToString(attributes: Record<string, any>): string;
 /**
@@ -17,9 +17,8 @@ export declare function checkIsNode(): boolean;
 export declare function serializeErrors(errors: StaticHandlerContext['errors']): StaticHandlerContext['errors'];
 export declare function getSSRConfigByEntry(entryName: string, ssr?: ServerUserConfig['ssr'], ssrByEntries?: ServerUserConfig['ssrByEntries']): true | {
     forceCSR?: boolean;
-    mode?: import("@modern-js/types").SSRMode;
+    mode?: import("@modern-js/types/common").SSRMode;
     inlineScript?: boolean;
-    disablePrerender?: boolean;
     unsafeHeaders?: string[];
     loaderFailureMode?: "clientRender" | "errorBoundary";
 };

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

@@ -1,7 +1,6 @@
 import type { OnError, OnTiming } from '@modern-js/app-tools';
 import type { BaseSSRServerContext } from '@modern-js/types';
 import type { RenderLevel } from './constants';
-import type { LoaderResult } from './loader/loaderManager';
 declare global {
     interface Window {
         _SSR_DATA?: SSRContainer;
@@ -9,9 +8,8 @@ declare global {
     }
 }
 export interface SSRData {
-    loadersData?: Record<string, LoaderResult | undefined>;
     initialData?: Record<string, unknown>;
-    storeState?: any;
+    i18nData?: Record<string, unknown>;
     [props: string]: any;
 }
 export interface RouteData {
@@ -34,9 +32,8 @@ export interface SSRContainer {
     };
 }
 type BuildHtmlCb = (tempalte: string) => string;
-export type SSRServerContext = Pick<BaseSSRServerContext, 'redirection' | 'response' | 'nonce' | 'mode' | 'loaderContext' | 'reporter' | 'logger' | 'metrics' | 'routeManifest'> & {
+export type SSRServerContext = Pick<BaseSSRServerContext, 'baseUrl' | 'response' | 'nonce' | 'mode' | 'loaderContext' | 'reporter' | 'routeManifest'> & {
     request: BaseSSRServerContext['request'] & {
-        baseUrl: string;
         raw: Request;
     };
     htmlModifiers: BuildHtmlCb[];
@@ -45,17 +42,8 @@ export type SSRServerContext = Pick<BaseSSRServerContext, 'redirection' | 'respo
     onTiming: OnTiming;
     useJsonScript?: boolean;
 };
-interface TSSRBaseContext {
+export type RequestContext = {
     request: BaseSSRServerContext['request'];
-    [propName: string]: any;
-}
-export interface ServerContext extends TSSRBaseContext {
-    isBrowser: false;
     response: BaseSSRServerContext['response'];
-    logger: BaseSSRServerContext['logger'];
-}
-export interface ClientContext extends TSSRBaseContext {
-    isBrowser: true;
-}
-export declare type TSSRContext = ServerContext | ClientContext;
+};
 export {};

package/dist/types/document/DocumentContext.d.ts

@@ -1,4 +1,4 @@
-import React from 'react';
+import React, { type JSX } from 'react';
 type DocumentProps = {
     [x: string]: any;
     config?: any;

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

@@ -1,5 +1,5 @@
-import type { AppTools, CliPluginFuture } from '@modern-js/app-tools';
+import type { AppTools, CliPlugin } from '@modern-js/app-tools';
 import type { Entrypoint } from '@modern-js/types/cli';
-export declare const getDocumenByEntryName: (entrypoints: Entrypoint[], entryName: string, fallbackDir?: string) => string | undefined;
-export declare const documentPlugin: () => CliPluginFuture<AppTools<"shared">>;
+export declare const getDocumentByEntryName: (entrypoints: Entrypoint[], entryName: string, fallbackDir?: string) => string | undefined;
+export declare const documentPlugin: () => CliPlugin<AppTools>;
 export default documentPlugin;

package/dist/types/document/constants.d.ts

@@ -21,5 +21,7 @@ export declare const DOCUMENT_STYLE_PLACEHOLDER_END: string;
 export declare const DOCUMENT_COMMENT_PLACEHOLDER_START: string;
 export declare const DOCUMENT_COMMENT_PLACEHOLDER_END: string;
 export declare const PLACEHOLDER_REPLACER_MAP: {
-    [x: string]: string;
+    [DOCUMENT_SSR_PLACEHOLDER]: string;
+    [DOCUMENT_CHUNKSMAP_PLACEHOLDER]: string;
+    [DOCUMENT_SSRDATASCRIPT_PLACEHOLDER]: string;
 };

package/dist/types/exports/config-routes.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Type definitions for config-based routing
+ */
+import type { DefineRoutesFunction, LayoutFunction, PageFunction, RouteConfig, RouteFunction, RouteFunctions, WildcardFunction } from '../router/cli/config-routes/parseRouteConfig';
+export type { RouteConfig, RouteFunction, LayoutFunction, PageFunction, WildcardFunction, RouteFunctions, DefineRoutesFunction, };
+/**
+ * defineRoutes - main function to define route configurations
+ */
+export declare function defineRoutes(routesCallback: (routeFunctions: RouteFunctions, fileRoutes: RouteConfig[]) => RouteConfig[]): (routeFunctions: RouteFunctions, fileRoutes: RouteConfig[]) => RouteConfig[];

package/dist/types/index.d.ts

@@ -1,11 +1,10 @@
 import type { RouterConfig } from './router/internal';
-export type { Plugin, RuntimePluginFuture } from './core';
-export type { AppConfig, RuntimeConfig } from './common';
+export type { RuntimePlugin } from './core';
+export type { RuntimeConfig } from './common';
 export { isBrowser } from './common';
-export type { RuntimeContext } from './core/context/runtime';
-export type { RuntimeUserConfig } from './config';
+export type { TRuntimeContext } from './core/context/runtime';
 export { getMonitors } from './core/context/monitors';
 export { getRequest } from './core/context/request';
 export { setHeaders, setStatus, redirect } from './core/context/response';
-export { createApp, useLoader, bootstrap, RuntimeReactContext, defineConfig, defineRuntimeConfig, useRuntimeContext, } from './core';
+export { RuntimeContext, defineRuntimeConfig, useRuntimeContext, } from './core';
 export type { RouterConfig };

package/dist/types/internal.d.ts

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

package/dist/types/router/cli/code/getClientRoutes/index.d.ts

@@ -1,2 +1 @@
 export { getClientRoutes } from './getRoutes';
-export { getClientRoutes as getClientRoutesLegacy } from './getRoutesLegacy';

package/dist/types/router/cli/code/getClientRoutes/utils.d.ts

@@ -1,5 +1,4 @@
 declare const debug: import("@modern-js/utils/compiled/debug").Debugger;
 export { debug };
-export declare const findLayout: (dir: string) => string | false;
 export declare const getRouteWeight: (route: string) => number;
 export declare const shouldSkip: (file: string) => boolean;

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

@@ -1,6 +1,10 @@
 import type { AppNormalizedConfig, AppTools, AppToolsContext } from '@modern-js/app-tools';
-import type { CLIPluginAPI } from '@modern-js/plugin-v2';
-import type { Entrypoint } from '@modern-js/types';
-export declare const generateCode: (appContext: AppToolsContext<"shared">, config: AppNormalizedConfig<"shared">, entrypoints: Entrypoint[], api: CLIPluginAPI<AppTools<"shared">>, isRouterV5: boolean) => Promise<void>;
+import type { CLIPluginAPI } from '@modern-js/plugin';
+import type { Entrypoint, NestedRouteForCli } from '@modern-js/types';
+/**
+ * Generate routing information for a single entry point (can be reused by the routes inspect feature)
+ */
+export declare function generateRoutesForEntry(entrypoint: Entrypoint, appContext: AppToolsContext): Promise<NestedRouteForCli[]>;
+export declare const generateCode: (appContext: AppToolsContext, config: AppNormalizedConfig, entrypoints: Entrypoint[], api: CLIPluginAPI<AppTools>) => Promise<void>;
 export declare function generatorRegisterCode(internalDirectory: string, entryName: string, code: string): void;
 export declare function generatorServerRegisterCode(internalDirectory: string, entryName: string, code: string): void;