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

package/dist/cjs/core/context/public.js

@@ -0,0 +1,49 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ReactRuntimeContext: ()=>ReactRuntimeContext,
+    RuntimeContext: ()=>RuntimeContext,
+    useRuntimeContext: ()=>useRuntimeContext
+});
+const external_react_namespaceObject = require("react");
+const RuntimeContext = (0, external_react_namespaceObject.createContext)({});
+const ReactRuntimeContext = RuntimeContext;
+const useRuntimeContext = ()=>(0, external_react_namespaceObject.useContext)(RuntimeContext);
+exports.ReactRuntimeContext = __webpack_exports__.ReactRuntimeContext;
+exports.RuntimeContext = __webpack_exports__.RuntimeContext;
+exports.useRuntimeContext = __webpack_exports__.useRuntimeContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ReactRuntimeContext",
+    "RuntimeContext",
+    "useRuntimeContext"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/core/context/runtime.js

@@ -29,16 +29,14 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     InternalRuntimeContext: ()=>InternalRuntimeContext,
-    ReactRuntimeContext: ()=>ReactRuntimeContext,
-    RuntimeContext: ()=>RuntimeContext,
+    ReactRuntimeContext: ()=>external_public_js_namespaceObject.ReactRuntimeContext,
+    RuntimeContext: ()=>external_public_js_namespaceObject.RuntimeContext,
     getInitialContext: ()=>getInitialContext,
-    useRuntimeContext: ()=>useRuntimeContext
+    useRuntimeContext: ()=>external_public_js_namespaceObject.useRuntimeContext
 });
-const constants_namespaceObject = require("@modern-js/utils/universal/constants");
-const external_react_namespaceObject = require("react");
-const InternalRuntimeContext = (0, external_react_namespaceObject.createContext)({});
-const RuntimeContext = (0, external_react_namespaceObject.createContext)({});
-const ReactRuntimeContext = RuntimeContext;
+const external_public_js_namespaceObject = require("./public.js");
+const ROUTE_MANIFEST = '_MODERNJS_ROUTE_MANIFEST';
+const InternalRuntimeContext = external_public_js_namespaceObject.RuntimeContext;
 const getInitialContext = (isBrowser = true, routeManifest)=>{
     const requestContext = {
         request: {},
@@ -46,12 +44,11 @@ const getInitialContext = (isBrowser = true, routeManifest)=>{
     };
     return {
         isBrowser,
-        routeManifest: routeManifest || "u" > typeof window && window[constants_namespaceObject.ROUTE_MANIFEST],
+        routeManifest: routeManifest || "u" > typeof window && window[ROUTE_MANIFEST],
         requestContext,
         context: requestContext
     };
 };
-const useRuntimeContext = ()=>(0, external_react_namespaceObject.useContext)(RuntimeContext);
 exports.InternalRuntimeContext = __webpack_exports__.InternalRuntimeContext;
 exports.ReactRuntimeContext = __webpack_exports__.ReactRuntimeContext;
 exports.RuntimeContext = __webpack_exports__.RuntimeContext;

package/dist/cjs/index.js

@@ -28,19 +28,20 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    RuntimeContext: ()=>index_js_namespaceObject.RuntimeContext,
-    defineRuntimeConfig: ()=>index_js_namespaceObject.defineRuntimeConfig,
-    getMonitors: ()=>monitors_index_js_namespaceObject.getMonitors,
+    RuntimeContext: ()=>public_js_namespaceObject.RuntimeContext,
+    defineRuntimeConfig: ()=>config_js_namespaceObject.defineRuntimeConfig,
+    getMonitors: ()=>index_js_namespaceObject.getMonitors,
     getRequest: ()=>request_index_js_namespaceObject.getRequest,
     isBrowser: ()=>external_common_js_namespaceObject.isBrowser,
     redirect: ()=>response_index_js_namespaceObject.redirect,
     setHeaders: ()=>response_index_js_namespaceObject.setHeaders,
     setStatus: ()=>response_index_js_namespaceObject.setStatus,
-    useRuntimeContext: ()=>index_js_namespaceObject.useRuntimeContext
+    useRuntimeContext: ()=>public_js_namespaceObject.useRuntimeContext
 });
 const external_common_js_namespaceObject = require("./common.js");
-const index_js_namespaceObject = require("./core/index.js");
-const monitors_index_js_namespaceObject = require("./core/context/monitors/index.js");
+const config_js_namespaceObject = require("./core/config.js");
+const index_js_namespaceObject = require("./core/context/monitors/index.js");
+const public_js_namespaceObject = require("./core/context/public.js");
 const request_index_js_namespaceObject = require("./core/context/request/index.js");
 const response_index_js_namespaceObject = require("./core/context/response/index.js");
 exports.RuntimeContext = __webpack_exports__.RuntimeContext;

package/dist/cjs/router/runtime/hooks.js

@@ -36,12 +36,13 @@ __webpack_require__.d(__webpack_exports__, {
     onBeforeHydrateRouter: ()=>onBeforeHydrateRouter
 });
 const plugin_namespaceObject = require("@modern-js/plugin");
-const modifyRoutes = (0, plugin_namespaceObject.createSyncHook)();
-const onBeforeCreateRoutes = (0, plugin_namespaceObject.createSyncHook)();
-const onBeforeCreateRouter = (0, plugin_namespaceObject.createSyncHook)();
-const onAfterCreateRouter = (0, plugin_namespaceObject.createSyncHook)();
-const onBeforeHydrateRouter = (0, plugin_namespaceObject.createSyncHook)();
-const onAfterHydrateRouter = (0, plugin_namespaceObject.createSyncHook)();
+const createRouterSyncHook = ()=>(0, plugin_namespaceObject.createSyncHook)();
+const modifyRoutes = createRouterSyncHook();
+const onBeforeCreateRoutes = createRouterSyncHook();
+const onBeforeCreateRouter = createRouterSyncHook();
+const onAfterCreateRouter = createRouterSyncHook();
+const onBeforeHydrateRouter = createRouterSyncHook();
+const onAfterHydrateRouter = createRouterSyncHook();
 exports.modifyRoutes = __webpack_exports__.modifyRoutes;
 exports.onAfterCreateRouter = __webpack_exports__.onAfterCreateRouter;
 exports.onAfterHydrateRouter = __webpack_exports__.onAfterHydrateRouter;

package/dist/esm/core/context/public.mjs

@@ -0,0 +1,5 @@
+import { createContext, useContext } from "react";
+const RuntimeContext = createContext({});
+const ReactRuntimeContext = RuntimeContext;
+const useRuntimeContext = ()=>useContext(RuntimeContext);
+export { ReactRuntimeContext, RuntimeContext, useRuntimeContext };

package/dist/esm/core/context/runtime.mjs

@@ -1,8 +1,6 @@
-import { ROUTE_MANIFEST } from "@modern-js/utils/universal/constants";
-import { createContext, useContext } from "react";
-const InternalRuntimeContext = createContext({});
-const RuntimeContext = createContext({});
-const ReactRuntimeContext = RuntimeContext;
+import { ReactRuntimeContext, RuntimeContext, useRuntimeContext } from "./public.mjs";
+const ROUTE_MANIFEST = '_MODERNJS_ROUTE_MANIFEST';
+const InternalRuntimeContext = RuntimeContext;
 const getInitialContext = (isBrowser = true, routeManifest)=>{
     const requestContext = {
         request: {},
@@ -15,5 +13,4 @@ const getInitialContext = (isBrowser = true, routeManifest)=>{
         context: requestContext
     };
 };
-const useRuntimeContext = ()=>useContext(RuntimeContext);
 export { InternalRuntimeContext, ReactRuntimeContext, RuntimeContext, getInitialContext, useRuntimeContext };

package/dist/esm/index.mjs

@@ -1,5 +1,6 @@
 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/router/runtime/hooks.mjs

@@ -1,8 +1,9 @@
 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/core/context/public.mjs

@@ -0,0 +1,6 @@
+import "node:module";
+import { createContext, useContext } from "react";
+const RuntimeContext = createContext({});
+const ReactRuntimeContext = RuntimeContext;
+const useRuntimeContext = ()=>useContext(RuntimeContext);
+export { ReactRuntimeContext, RuntimeContext, useRuntimeContext };

package/dist/esm-node/core/context/runtime.mjs

@@ -1,9 +1,7 @@
 import "node:module";
-import { ROUTE_MANIFEST } from "@modern-js/utils/universal/constants";
-import { createContext, useContext } from "react";
-const InternalRuntimeContext = createContext({});
-const RuntimeContext = createContext({});
-const ReactRuntimeContext = RuntimeContext;
+import { ReactRuntimeContext, RuntimeContext, useRuntimeContext } from "./public.mjs";
+const ROUTE_MANIFEST = '_MODERNJS_ROUTE_MANIFEST';
+const InternalRuntimeContext = RuntimeContext;
 const getInitialContext = (isBrowser = true, routeManifest)=>{
     const requestContext = {
         request: {},
@@ -16,5 +14,4 @@ const getInitialContext = (isBrowser = true, routeManifest)=>{
         context: requestContext
     };
 };
-const useRuntimeContext = ()=>useContext(RuntimeContext);
 export { InternalRuntimeContext, ReactRuntimeContext, RuntimeContext, getInitialContext, useRuntimeContext };

package/dist/esm-node/core/server/stream/beforeTemplate.mjs

@@ -8,11 +8,11 @@ import { buildHtml } from "../shared.mjs";
 import { checkIsNode, hasStylesheetLink, safeReplace } from "../utils.mjs";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
-var beforeTemplate_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+var __rspack_import_meta_dirname__ = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
 const readAsset = async (chunk)=>{
     const fs = await import("fs/promises");
     const path = await import("path");
-    const filepath = path.join(beforeTemplate_dirname, chunk);
+    const filepath = path.join(__rspack_import_meta_dirname__, chunk);
     return fs.readFile(filepath, 'utf-8');
 };
 const checkIsInline = (chunk, enableInline)=>{

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

@@ -5,7 +5,7 @@ import { getMatchedRouteAssets, orderHydrationScriptChunks } from "../scriptOrde
 import { attributesToString, checkIsNode, hasStylesheetLink } from "../utils.mjs";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
-var loadable_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+var __rspack_import_meta_dirname__ = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
 const extname = (uri)=>{
     if ('string' != typeof uri || !uri.includes('.')) return '';
     return `.${uri?.split('.').pop()}` || '';
@@ -28,7 +28,7 @@ const checkIsInline = (chunk, enableInline)=>{
 const readAsset = async (chunk)=>{
     const fs = await import("fs/promises");
     const path = await import("path");
-    const filepath = path.resolve(loadable_dirname, chunk.filename);
+    const filepath = path.resolve(__rspack_import_meta_dirname__, chunk.filename);
     return fs.readFile(filepath, 'utf-8');
 };
 class 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/index.mjs

@@ -7,7 +7,7 @@ import { handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints } f
 import { updateNestedRoutesSpec } from "./nestedRoutesSpec.mjs";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
-var cli_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+var __rspack_import_meta_dirname__ = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
 function isBuiltInRouteEntrypoint(entrypoint) {
     const entrypointRoutesOwner = getEntrypointRoutesOwner(entrypoint);
     if (entrypointRoutesOwner) return entrypointRoutesOwner === BUILT_IN_ROUTES_OWNER;
@@ -62,7 +62,7 @@ const routerPlugin = ()=>({
                     source: {
                         include: [
                             /[\\/]node_modules[\\/]react-router[\\/]/,
-                            node_path.resolve(cli_dirname, '../runtime').replace('cjs', 'esm')
+                            node_path.resolve(__rspack_import_meta_dirname__, '../runtime').replace('cjs', 'esm')
                         ]
                     }
                 }));

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/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,8 +1,24 @@
-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';
@@ -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,23 @@
-import type { RouteObject, StaticHandlerContext } from '@modern-js/runtime-utils/router';
-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 { Context } from 'react';
+import { type RequestContext, type TRuntimeContext } from './public';
+export type InternalSSRContext = {
+    request: RequestContext['request'] & {
+        raw?: Request;
+    };
+    response: RequestContext['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;
-    routerContext?: StaticHandlerContext;
+    routeManifest?: Record<string, unknown>;
+    routerContext?: unknown;
     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;
+export declare const InternalRuntimeContext: Context<TInternalRuntimeContext>;
+export declare const getInitialContext: (isBrowser?: boolean, routeManifest?: Record<string, unknown>) => TInternalRuntimeContext;

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

package/dist/types/router/runtime/provider.d.ts

@@ -11,7 +11,7 @@
  * - `@modern-js/plugin-tanstack` registers the `tanstack` provider when its
  *   runtime entry is imported.
  */
-import type { RuntimePlugin } from '../../core';
+import type { RuntimePlugin } from '../../common';
 import type { RouterExtendsHooks } from './hooks';
 import type { RouterConfig } from './types';
 /**

package/dist/types/router/runtime/types.d.ts

@@ -1,6 +1,12 @@
-import type { RequestContext } from '@modern-js/runtime-utils/node';
 import type { Params, RouteObject, RouteProps } from '@modern-js/runtime-utils/router';
-import type { NestedRoute, PageRoute } from '@modern-js/types';
+export type ModernRoute = {
+    type: 'nested' | 'page';
+    path?: string;
+    id?: string;
+    component?: React.ComponentType | string;
+    children?: ModernRoute[];
+    [key: string]: any;
+};
 export type SingleRouteConfig = RouteProps & {
     redirect?: string;
     routes?: SingleRouteConfig[];
@@ -25,7 +31,7 @@ export type RouterConfig = {
     framework?: RouterFramework;
     routesConfig: {
         globalApp?: React.ComponentType<any>;
-        routes?: (NestedRoute | PageRoute)[];
+        routes?: ModernRoute[];
     };
     /**
      * You should not use it
@@ -108,12 +114,28 @@ export type ModernRouteObject = RouteObject & {
     component?: React.ComponentType | LazyComponentDescriptor;
     entryCssFiles?: string[];
 };
+type LoaderContextKey<T = unknown> = {
+    symbol: symbol;
+    getDefaultValue: () => T;
+};
+interface LoaderRequestGet<P extends Record<string, unknown>> {
+    <Key extends keyof P>(key: Key): P[Key];
+    <T>(key: LoaderContextKey<T>): T;
+}
+interface LoaderRequestSet<P extends Record<string, unknown>> {
+    <Key extends keyof P>(key: Key, value: P[Key]): void;
+    <T>(key: LoaderContextKey<T>, value: T): void;
+}
+type LoaderRequestContext<P extends Record<string, unknown> = {}> = {
+    get: LoaderRequestGet<P & Record<string, unknown>>;
+    set: LoaderRequestSet<P & Record<string, unknown>>;
+};
 interface DataFunctionArgs<D = any> {
     request: Request;
     params: Params;
     context?: D;
 }
-export type LoaderFunctionArgs<P extends Record<string, unknown> = Record<string, unknown>> = DataFunctionArgs<RequestContext<P>>;
+export type LoaderFunctionArgs<P extends Record<string, unknown> = Record<string, unknown>> = DataFunctionArgs<LoaderRequestContext<P>>;
 declare type DataFunctionValue = Response | NonNullable<unknown> | null;
 export type LoaderFunction = <P extends Record<string, unknown> = Record<string, unknown>>(args: LoaderFunctionArgs<P>) => Promise<DataFunctionValue> | DataFunctionValue;
 export {};

package/package.json

@@ -17,7 +17,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.5.0-ultramodern.1",
+  "version": "3.5.0-ultramodern.11",
   "engines": {
     "node": ">=20"
   },
@@ -240,12 +240,12 @@
     "react-helmet": "^6.1.0",
     "react-helmet-async": "3.0.0",
     "react-is": "^19.2.7",
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.5.0-ultramodern.1",
-    "@modern-js/render": "npm:@bleedingdev/modern-js-render@3.5.0-ultramodern.1",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.5.0-ultramodern.1",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.1",
-    "@modern-js/plugin-data-loader": "npm:@bleedingdev/modern-js-plugin-data-loader@3.5.0-ultramodern.1",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.1"
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.5.0-ultramodern.11",
+    "@modern-js/render": "npm:@bleedingdev/modern-js-render@3.5.0-ultramodern.11",
+    "@modern-js/plugin-data-loader": "npm:@bleedingdev/modern-js-plugin-data-loader@3.5.0-ultramodern.11",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.11",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.5.0-ultramodern.11",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.11"
   },
   "peerDependencies": {
     "react": "^19.2.7",
@@ -253,19 +253,19 @@
   },
   "devDependencies": {
     "@remix-run/web-fetch": "^4.4.2",
-    "@rsbuild/core": "2.1.0",
-    "@rslib/core": "0.23.0",
+    "@rsbuild/core": "2.1.1",
+    "@rslib/core": "0.23.1",
     "@testing-library/dom": "^10.4.1",
     "@testing-library/react": "^16.3.2",
     "@types/invariant": "^2.2.37",
     "@types/loadable__server": "5.12.11",
     "@types/node": "^26.0.1",
-    "@typescript/native-preview": "7.0.0-dev.20260624.1",
+    "@typescript/native-preview": "7.0.0-dev.20260628.1",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
     "ts-node": "^10.9.2",
     "typescript": "^6.0.3",
-    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.5.0-ultramodern.1",
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.5.0-ultramodern.11",
     "@scripts/rstest-config": "2.66.0"
   },
   "sideEffects": false,