@bleedingdev/modern-js-runtime 3.2.0-ultramodern.6 → 3.2.0-ultramodern.62

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

@@ -9,6 +9,7 @@ import { onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBefo
 import { applyRouterRuntimeState } from "../lifecycle.mjs";
 import { createRouteObjectsFromConfig, urlJoin } from "../utils.mjs";
 import { createModernBasepathRewrite } from "./basepathRewrite.mjs";
+import { Link } from "./prefetchLink.mjs";
 import { createRouteTreeFromRouteObjects } from "./routeTree.mjs";
 import { getTanstackRscSerializationAdapters } from "./rsc/client.mjs";
 import * as __rspack_external_react from "react";
@@ -71,6 +72,7 @@ const tanstackRouterPlugin = (userConfig = {})=>({
                     }
                 }
                 context.router = {
+                    Link: Link,
                     useMatches: useMatches,
                     useLocation: useLocation,
                     useNavigate: useNavigate,

package/dist/esm-node/router/runtime/tanstack/routeTree.mjs

@@ -1,5 +1,6 @@
 import "node:module";
 import { createRootRoute, createRoute, notFound, redirect } from "@tanstack/react-router";
+import { createElement } from "react";
 import { DefaultNotFound } from "../DefaultNotFound.mjs";
 function createTanstackRoute(options) {
     return createRoute(options);
@@ -44,6 +45,33 @@ function isModernDeferredData(value) {
 function normalizeModernLoaderResult(result) {
     return isModernDeferredData(result) ? result.data : result;
 }
+function pickRouteModuleComponent(routeModule) {
+    if ('function' == typeof routeModule || routeModule && 'object' == typeof routeModule && '$$typeof' in routeModule) return routeModule;
+    if (!routeModule || 'object' != typeof routeModule) return;
+    const module = routeModule;
+    const component = module.default || module.Component;
+    if ('function' == typeof component || component && 'object' == typeof component && '$$typeof' in component) return component;
+}
+function createServerLazyImportComponent(lazyImport, fallbackComponent) {
+    if ("u" > typeof document) return fallbackComponent;
+    let resolvedComponent;
+    let pendingLoad;
+    const load = async ()=>{
+        if (resolvedComponent) return resolvedComponent;
+        const routeModule = await lazyImport();
+        const component = pickRouteModuleComponent(routeModule);
+        if (component) resolvedComponent = component;
+        return resolvedComponent;
+    };
+    const Component = (props)=>{
+        if (resolvedComponent) return createElement(resolvedComponent, props);
+        pendingLoad ||= load();
+        throw pendingLoad;
+    };
+    Component.load = load;
+    Component.preload = load;
+    return Component;
+}
 function throwTanstackRedirect(location) {
     const target = location || '/';
     try {
@@ -210,10 +238,18 @@ function wrapRouteObjectLoader(route, revalidationState) {
 }
 function toRouteComponent(routeObject) {
     const route = routeObject;
+    const lazyImport = 'function' == typeof route.lazyImport ? route.lazyImport : void 0;
+    const fallbackComponent = route.Component ? route.Component : route.element ? ()=>route.element : void 0;
+    if (lazyImport && fallbackComponent) return createServerLazyImportComponent(lazyImport, fallbackComponent);
     if (route.Component) return route.Component;
     const element = route.element;
     if (element) return ()=>element;
 }
+function toModernRouteComponent(route) {
+    const component = route.component || void 0;
+    if ('function' == typeof route.lazyImport && component) return createServerLazyImportComponent(route.lazyImport, component);
+    return component;
+}
 function toErrorComponent(routeObject) {
     const route = routeObject;
     if (route.ErrorBoundary) return route.ErrorBoundary;
@@ -293,7 +329,7 @@ function createRouteFromModernRoute(opts) {
     const stableFallbackId = modernId || route._component || route.filename || route.data || ('function' == typeof route.loader ? route.id : void 0);
     const pendingComponent = route.loading || route.pendingComponent;
     const errorComponent = route.error || route.errorComponent;
-    const component = route.component;
+    const component = toModernRouteComponent(route);
     const modernLoader = route.loader;
     const modernAction = route.action;
     const modernShouldRevalidate = route.shouldRevalidate;
@@ -339,7 +375,7 @@ function createRouteFromModernRoute(opts) {
 }
 function createRouteTreeFromModernRoutes(routes) {
     const rootModern = routes.find((r)=>r && 'nested' === r.type && r.isRoot);
-    const rootComponent = rootModern?.component;
+    const rootComponent = rootModern ? toModernRouteComponent(rootModern) : void 0;
     const pendingComponent = rootModern?.loading;
     const errorComponent = rootModern?.error;
     const rootLoader = rootModern?.loader;

package/dist/esm-node/rsc/server.worker.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export * from "@modern-js/render/rsc-worker";

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

@@ -0,0 +1,25 @@
+import type { RuntimePlugin } from '../core';
+export type BoundaryDebugEntry = {
+    appId: string;
+    color?: string;
+    label?: string;
+    mfName: string;
+    ownerTeam?: string;
+    packageName?: string;
+    role?: 'host' | 'vertical';
+};
+export type BoundaryDebugMetadata = {
+    appId: string;
+    boundaries: BoundaryDebugEntry[];
+    schemaVersion: 1;
+};
+export type BoundaryDebuggerPluginOptions = {
+    enabledByDefault?: boolean;
+    labels?: Record<string, {
+        toggle: string;
+    }>;
+    metadata: BoundaryDebugMetadata;
+    storageKey?: string;
+};
+export declare const ultramodernBoundaryDebuggerPlugin: (options: BoundaryDebuggerPluginOptions) => RuntimePlugin;
+export default ultramodernBoundaryDebuggerPlugin;

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

@@ -0,0 +1 @@
+export * from '@modern-js/runtime-utils/cache';

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

@@ -0,0 +1,7 @@
+import type { Entrypoint } from '@modern-js/types';
+import type { RsbuildPlugin } from '@rsbuild/core';
+export declare const builderPluginAlias: ({ entrypoints, internalDirectory, metaName, }: {
+    entrypoints: Entrypoint[];
+    internalDirectory: string;
+    metaName: string;
+}) => RsbuildPlugin;

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

@@ -0,0 +1,3 @@
+import type { AppToolsContext, AppToolsFeatureHooks, AppToolsNormalizedConfig } from '@modern-js/app-tools';
+import type { Entrypoint } from '@modern-js/types';
+export declare const generateCode: (entrypoints: Entrypoint[], appContext: AppToolsContext, config: AppToolsNormalizedConfig, hooks: AppToolsFeatureHooks) => Promise<void>;

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

@@ -0,0 +1,9 @@
+export declare const APP_FILE_NAME = "App";
+export declare const ENTRY_POINT_FILE_NAME = "index.jsx";
+export declare const SERVER_ENTRY_POINT_FILE_NAME = "index.server.jsx";
+export declare const INDEX_FILE_NAME = "index";
+export declare const ENTRY_BOOTSTRAP_FILE_NAME = "bootstrap.jsx";
+export declare const ENTRY_SERVER_BOOTSTRAP_FILE_NAME = "bootstrap.server.jsx";
+export declare const ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME = "runtime-register.js";
+export declare const ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME = "runtime-global-context";
+export declare const ENTRY_POINT_REGISTER_FILE_NAME = "register.js";

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

@@ -0,0 +1,2 @@
+export declare const hasApp: (dir: string) => any;
+export declare const isRuntimeEntry: (dir: string) => any;

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

@@ -0,0 +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, handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints, isRouteEntry, } from '../router/cli';
+export { isRuntimeEntry } from './entry';
+export { documentPlugin, routerPlugin, ssrPlugin };
+export declare const runtimePlugin: (params?: {
+    plugins?: CliPlugin<AppTools>[];
+}) => CliPlugin<AppTools>;
+export default runtimePlugin;

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

@@ -0,0 +1,6 @@
+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/cli/ssr/loadable-bundler-plugin.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The following code is modified based on
+ * https://github.com/gregberge/loadable-components
+ *
+ * MIT Licensed
+ * Author Greg Bergé
+ * Copyright 2019 Greg Bergé
+ * https://github.com/gregberge/loadable-components/blob/main/LICENSE
+ */
+import type { Rspack } from '@modern-js/app-tools';
+interface LoadablePluginOptions {
+    filename: string;
+    path?: string;
+    writeToDisk?: any;
+    outputAsset?: boolean;
+    chunkLoadingGlobal?: string;
+}
+type Compiler = Rspack.Compiler;
+type Compilation = Rspack.Compilation;
+declare class LoadablePlugin {
+    opts: LoadablePluginOptions;
+    compiler: Compiler | null;
+    constructor({ filename, path, writeToDisk, outputAsset, chunkLoadingGlobal, }?: LoadablePluginOptions);
+    apply(compiler: Compiler): void;
+    handleEmit(compilation: Compilation): {
+        source(): string;
+        size(): number;
+    } | null;
+    writeAssetsFile(manifest: string): void;
+}
+export default LoadablePlugin;

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

@@ -0,0 +1,15 @@
+import type { AppToolsNormalizedConfig } from '@modern-js/app-tools';
+export type SSRMode = 'string' | 'stream' | false;
+/**
+ * Unified SSR mode resolution function.
+ * Priority:
+ * 1. If SSG is enabled, use SSG configuration (SSG takes precedence over SSR when both are configured)
+ * 2. User's explicit server.ssr/server.ssrByEntries config
+ * 3. Otherwise return false (no SSR)
+ */
+export declare function resolveSSRMode(params: {
+    entry?: string;
+    config: AppToolsNormalizedConfig;
+    appDirectory?: string;
+    nestedRoutesEntry?: string;
+}): SSRMode;

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

@@ -0,0 +1,50 @@
+import type { RuntimePluginConfig } from '@modern-js/app-tools';
+export declare const entryForCSRWithRSC: ({ metaName, entryName, urlPath, mountId, isNestedRouter, }: {
+    metaName: string;
+    entryName: string;
+    urlPath?: string;
+    mountId?: string;
+    isNestedRouter?: string;
+}) => string;
+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;
+    mountId?: string;
+    enableRsc?: boolean;
+    isNestedRouter?: boolean;
+}) => string;
+export declare const register: () => string;
+export declare const runtimeRegister: ({ entryName, srcDirectory, internalSrcAlias, metaName, runtimeConfigFile, runtimePlugins, }: {
+    entryName: string;
+    srcDirectory: string;
+    internalSrcAlias: string;
+    metaName: string;
+    runtimeConfigFile: string | false;
+    runtimePlugins: RuntimePluginConfig[];
+}) => string;
+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;
+}) => string;
+export declare const runtimeGlobalContextForRSCClient: ({ metaName, customEntry, }: {
+    metaName: string;
+    customEntry?: boolean;
+}) => string;
+export declare const AppProxyForRSC: ({ srcDirectory, internalSrcAlias, entry, customEntry, }: {
+    srcDirectory: string;
+    internalSrcAlias: string;
+    entry: string;
+    customEntry?: boolean;
+}) => string;

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

@@ -0,0 +1,20 @@
+type ServerIndexOptinos = GenHandlerCodeOptions & {
+    entryName: string;
+};
+export declare const serverIndex: (options: ServerIndexOptinos) => string;
+export declare const entryForCSRWithRSC: ({ metaName, entryName, }: {
+    metaName: string;
+    entryName: string;
+}) => string;
+type GenHandlerCodeOptions = {
+    customServerEntry?: string | false;
+    srcDirectory: string;
+    internalSrcAlias: string;
+    entry: string;
+    enableRsc?: boolean;
+} & TransformServerEntryOptions;
+type TransformServerEntryOptions = {
+    metaName?: string;
+    mode: 'string' | 'stream';
+};
+export {};

package/dist/types/common.d.ts

@@ -0,0 +1,8 @@
+import type { RuntimePlugin } from './core/plugin';
+export declare const isBrowser: () => boolean;
+export interface RuntimeConfig {
+    plugins?: RuntimePlugin[];
+    [key: string]: any;
+}
+export declare const JSX_SHELL_STREAM_END_MARK = "<!--<?- SHELL_STREAM_END ?>-->";
+export declare const ESCAPED_SHELL_STREAM_END_MARK = "&lt;!--&lt;?- SHELL_STREAM_END ?&gt;--&gt;";

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

@@ -0,0 +1,5 @@
+import type React from 'react';
+import type { Root } from 'react-dom/client';
+import type { TRuntimeContext } from '../context/runtime';
+export declare const isReact18: () => boolean;
+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

@@ -0,0 +1,9 @@
+import type React from 'react';
+export type RenderFunc = typeof render;
+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>;
+export declare function hydrateWithReact17(App: React.ReactElement, rootElement: HTMLElement, callback?: () => void): Promise<any>;

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

@@ -0,0 +1,5 @@
+import type React from 'react';
+export declare const WithCallback: React.FC<{
+    callback: () => void;
+    children: React.ReactElement;
+}>;

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

@@ -0,0 +1,4 @@
+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: TInternalRuntimeContext): Record<string, any>;

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

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

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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,6 @@
+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.
+ */
+export declare const defineRuntimeConfig: (config: RuntimeConfig | ((entryName: string) => RuntimeConfig)) => RuntimeConfig | ((entryName: string) => RuntimeConfig);

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

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

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

@@ -0,0 +1,50 @@
+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 { getInitialContext, InternalRuntimeContext, RuntimeContext, type TInternalRuntimeContext, type TRuntimeContext, } from './runtime';
+export type { PayloadRoute, ServerPayload } from './serverPayload/index';
+interface GlobalContext {
+    entryName?: string;
+    /**
+     * App.tsx export default component
+     */
+    App?: React.ComponentType;
+    /**
+     * nest router and page router config
+     */
+    routes?: (NestedRoute | PageRoute)[];
+    /**
+     * nest router init function
+     */
+    appInit?: () => Promise<unknown>;
+    /**
+     * page router _app.tsx export layout app
+     */
+    layoutApp?: React.ComponentType;
+    /**
+     * Entry basename for routing
+     */
+    basename?: string;
+    internalRuntimeContext?: InternalRuntimeContext<RuntimeExtends>;
+    /**
+     * RSCRoot
+     */
+    RSCRoot?: React.ComponentType;
+    isRscClient?: boolean;
+    serverPayload?: ServerPayload;
+    enableRsc?: boolean;
+}
+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, '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 getGlobalApp(): React.ComponentType<{}> | undefined;
+export declare function getGlobalRoutes(): undefined | (NestedRoute | PageRoute)[];
+export declare function getGlobalLayoutApp(): React.ComponentType<{}> | undefined;
+export declare function getGlobalBasename(): string | undefined;

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

@@ -0,0 +1,2 @@
+import type { Monitors } from '@modern-js/types';
+export declare const defaultMonitors: Omit<Monitors, 'push'>;

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

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

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

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

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

@@ -0,0 +1 @@
+export declare const getRequest: () => Request;

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

@@ -0,0 +1 @@
+export declare const getRequest: () => Request;

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

@@ -0,0 +1,4 @@
+export declare const getResponseProxy: () => null;
+export declare const setHeaders: (headers: Record<string, string>) => void;
+export declare const setStatus: (status: number) => void;
+export declare const redirect: (url: string, init?: number | ResponseInit) => void;

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

@@ -0,0 +1,4 @@
+export declare const getResponseProxy: () => any;
+export declare const setHeaders: (headers: Record<string, string>) => void;
+export declare const setStatus: (status: number) => void;
+export declare const redirect: (url: string, init?: number | ResponseInit) => void;

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

@@ -0,0 +1,42 @@
+import type { RouteObject, StaticHandlerContext } from '@modern-js/runtime-utils/router';
+import type { InternalRouterRuntimeState, InternalRouterServerSnapshot, RouteManifest, RouterFramework } from '../../router/runtime/types';
+import type { RequestContext, SSRServerContext } from '../types';
+export interface TRuntimeContext {
+    initialData?: Record<string, unknown>;
+    isBrowser: boolean;
+    routes?: RouteObject[];
+    routerFramework?: RouterFramework;
+    requestContext: RequestContext;
+    /**
+     * @deprecated Use `requestContext` instead
+     */
+    context: RequestContext;
+    [key: string]: unknown;
+}
+/**
+ * InternalRuntimeContext used internally and by plugins
+ */
+export interface TInternalRuntimeContext extends TRuntimeContext {
+    routeManifest?: RouteManifest;
+    routerRuntime?: InternalRouterRuntimeState;
+    routerInstance?: unknown;
+    routerHydrationScript?: string;
+    routerMatchedRouteIds?: string[];
+    routerServerSnapshot?: InternalRouterServerSnapshot;
+    routerContext?: StaticHandlerContext;
+    unstable_getBlockNavState?: () => boolean;
+    ssrContext?: SSRServerContext;
+    _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/context/serverPayload/index.d.ts

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

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

@@ -0,0 +1,31 @@
+import type { RouterState, ShouldRevalidateFunction } from '@modern-js/runtime-utils/router';
+export type PayloadRoute = {
+    clientAction?: (...args: unknown[]) => unknown;
+    clientLoader?: (...args: unknown[]) => unknown;
+    element?: React.ReactNode;
+    errorElement?: React.ReactNode;
+    handle?: unknown;
+    hasAction: boolean;
+    hasErrorBoundary: boolean;
+    hasLoader: boolean;
+    hasClientLoader?: boolean;
+    id: string;
+    index?: boolean;
+    params: Record<string, string>;
+    parentId?: string;
+    path?: string;
+    pathname: string;
+    pathnameBase: string;
+    shouldRevalidate?: ShouldRevalidateFunction;
+};
+export type ServerPayload = {
+    type: 'render';
+    actionData: RouterState['actionData'];
+    errors: RouterState['errors'];
+    loaderData: RouterState['loaderData'];
+    location: RouterState['location'];
+    routes: PayloadRoute[];
+    originalRoutes?: PayloadRoute[];
+};
+export declare const getServerPayload: () => ServerPayload | undefined;
+export declare const setServerPayload: (payload: ServerPayload) => void;

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

@@ -0,0 +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';

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

@@ -0,0 +1,5 @@
+import type { InternalRuntimeContext } from '@modern-js/plugin/runtime';
+import type { RuntimeConfig, RuntimeExtends, RuntimePlugin } from './types';
+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>[]): any;

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

@@ -0,0 +1,10 @@
+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/index.d.ts

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

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

@@ -0,0 +1,3 @@
+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/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const HTML_PLACEHOLDER = "<!--<?- html ?>-->";
+export declare const SSR_DATA_PLACEHOLDER = "<!--<?- SSRDataScript ?>-->";
+export declare const CHUNK_JS_PLACEHOLDER = "<!--<?- chunksMap.js ?>-->";
+export declare const CHUNK_CSS_PLACEHOLDER = "<!--<?- chunksMap.css ?>-->";

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

@@ -0,0 +1,3 @@
+import type { HelmetData } from 'react-helmet';
+export declare function createReplaceHelemt(helmetData?: HelmetData): (template: string) => string;
+export declare function helmetReplace(content: string, helmetData: HelmetData): string;

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

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

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

package/dist/types/core/server/react/no-ssr-cache/index.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const NoSSRCache: () => React.JSX.Element;

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

@@ -0,0 +1,4 @@
+import React, { type ReactElement } from 'react';
+export declare const NoSSR: (props?: React.PropsWithChildren<{
+    fallback?: ReactElement | string;
+}>) => ReactElement | null;

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

@@ -0,0 +1,13 @@
+import type { RequestHandler, RequestHandlerOptions } from '@modern-js/app-tools';
+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: TInternalRuntimeContext;
+};
+export type HandleRequest = (request: Request, ServerRoot: React.ComponentType, // App, routes,
+options: HandleRequestOptions) => Promise<Response>;
+export type CreateRequestHandler = (handleRequest: HandleRequest, options?: {
+    enableRsc?: boolean;
+}) => Promise<RequestHandler>;
+export declare const createRequestHandler: CreateRequestHandler;

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

@@ -0,0 +1,4 @@
+export { type CreateRequestHandler, createRequestHandler, type HandleRequest, type HandleRequestConfig, type HandleRequestOptions, } from './requestHandler';
+export type { RenderOptions, RenderStreaming, RenderString } from './shared';
+export { renderStreaming } from './stream';
+export { renderString } from './string';

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

@@ -0,0 +1,8 @@
+import type { ServerUserConfig } from '@modern-js/app-tools';
+import type { HandleRequestOptions } from './requestHandler';
+export type RenderOptions = HandleRequestOptions;
+export type SSRConfig = NonNullable<ServerUserConfig['ssr']>;
+export type RenderStreaming = (request: Request, serverRoot: React.ReactElement, optinos: RenderOptions) => Promise<ReadableStream>;
+export type RenderString = (request: Request, serverRoot: React.ReactElement, optinos: RenderOptions) => Promise<string>;
+export type BuildHtmlCb = (template: string) => string | Promise<string>;
+export declare function buildHtml(template: string, callbacks: BuildHtmlCb[]): Promise<string>;