@bleedingdev/modern-js-runtime 3.9.0-ultramodern.17 → 3.9.0-ultramodern.18

package/dist/cjs/cli/ssr/loadable-bundler-plugin.js

@@ -44,6 +44,7 @@ const external_path_namespaceObject = require("path");
 var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
 const normalizeChunkId = (id)=>'string' == typeof id && /^\d+$/.test(id) ? Number(id) : id;
 const DEFAULT_CHUNK_LOADING_GLOBAL = '__LOADABLE_LOADED_CHUNKS__';
+const normalizeStatsPublicPath = (publicPath)=>'auto' === publicPath || 'auto/' === publicPath ? '/' : publicPath;
 const normalizeChunkGroup = (group)=>({
         ...group,
         chunks: (group.chunks || []).map(normalizeChunkId)
@@ -86,6 +87,7 @@ class LoadablePlugin {
         for (const [name, ep] of Object.entries(stats.entrypoints || {}))entrypoints[name] = normalizeChunkGroup(ep);
         const output = {
             ...stats,
+            publicPath: normalizeStatsPublicPath(stats.publicPath),
             namedChunkGroups,
             entrypoints,
             generator: 'loadable-components',

package/dist/cjs/core/browser/hydrate.js

@@ -86,13 +86,7 @@ function hydrateRoot(App, context, ModernRender, ModernHydrate) {
                     });
                 return ModernHydrate((0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(SSRApp, {}), hydrateContext));
             });
-            const runtimeConsole = Reflect.get(globalThis, 'console');
-            if (null !== runtimeConsole && 'object' == typeof runtimeConsole) {
-                const warn = Reflect.get(runtimeConsole, 'warn');
-                if ('function' == typeof warn) Reflect.apply(warn, runtimeConsole, [
-                    `unknow render level: ${renderLevel}, execute render()`
-                ]);
-            }
+            console.warn(`unknow render level: ${renderLevel}, execute render()`);
             return ModernRender((0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(App, context));
         }
     }

package/dist/cjs/core/browser/index.js

@@ -35,10 +35,9 @@ __webpack_require__.d(__webpack_exports__, {
     renderWithReact17: ()=>renderWithReact17,
     renderWithReact18: ()=>renderWithReact18
 });
+const context_namespaceObject = require("@modern-js/runtime/context");
 const external_cookie_namespaceObject = require("cookie");
 const client_namespaceObject = require("react-dom/client");
-const index_js_namespaceObject = require("../context/index.js");
-const runtime_js_namespaceObject = require("../context/runtime.js");
 const wrapper_js_namespaceObject = require("../react/wrapper.js");
 const external_hydrate_js_namespaceObject = require("./hydrate.js");
 const IS_REACT18 = 'true' === process.env.IS_REACT18;
@@ -85,7 +84,7 @@ function isClientArgs(id) {
     return void 0 === id || 'string' == typeof id || "u" > typeof HTMLElement && id instanceof HTMLElement;
 }
 async function renderApp(App, id, hydrateFromSsrData, internalRuntimeContext) {
-    const context = (0, runtime_js_namespaceObject.getInitialContext)();
+    const context = (0, context_namespaceObject.getInitialContext)();
     const runBeforeRender = async (context)=>{
         const api = internalRuntimeContext.pluginAPI;
         api.updateRuntimeContext(context);
@@ -115,10 +114,10 @@ async function renderApp(App, id, hydrateFromSsrData, internalRuntimeContext) {
     throw Error('`render` function needs id in browser environment, it needs to be string or element');
 }
 async function render(App, id) {
-    return renderApp(App, id, true, (0, index_js_namespaceObject.getGlobalInternalRuntimeContext)());
+    return renderApp(App, id, true, (0, context_namespaceObject.getGlobalInternalRuntimeContext)());
 }
 function createNestedAppRenderer() {
-    const internalRuntimeContext = (0, index_js_namespaceObject.getGlobalInternalRuntimeContext)();
+    const internalRuntimeContext = (0, context_namespaceObject.getGlobalInternalRuntimeContext)();
     return (App, id)=>renderApp(App, id, false, internalRuntimeContext);
 }
 async function renderWithReact18(App, rootElement) {

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

@@ -30,6 +30,7 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     DefaultNotFound: ()=>DefaultNotFound_js_namespaceObject.DefaultNotFound,
     InternalRuntimeContext: ()=>external_runtime_js_namespaceObject.InternalRuntimeContext,
+    ReactRuntimeContext: ()=>external_runtime_js_namespaceObject.ReactRuntimeContext,
     RuntimeComponentResolverContext: ()=>external_runtime_js_namespaceObject.RuntimeComponentResolverContext,
     RuntimeContext: ()=>external_runtime_js_namespaceObject.RuntimeContext,
     getCurrentEntryName: ()=>getCurrentEntryName,
@@ -52,7 +53,8 @@ __webpack_require__.d(__webpack_exports__, {
     routerProviderRegistryHooks: ()=>hooks_js_namespaceObject.routerProviderRegistryHooks,
     setGlobalContext: ()=>setGlobalContext,
     setGlobalInternalRuntimeContext: ()=>setGlobalInternalRuntimeContext,
-    setServerPayload: ()=>index_js_namespaceObject.setServerPayload
+    setServerPayload: ()=>index_js_namespaceObject.setServerPayload,
+    useRuntimeContext: ()=>external_runtime_js_namespaceObject.useRuntimeContext
 });
 const DefaultNotFound_js_namespaceObject = require("../../router/runtime/DefaultNotFound.js");
 const hooks_js_namespaceObject = require("../../router/runtime/hooks.js");
@@ -102,6 +104,7 @@ function getGlobalBasename() {
 }
 exports.DefaultNotFound = __webpack_exports__.DefaultNotFound;
 exports.InternalRuntimeContext = __webpack_exports__.InternalRuntimeContext;
+exports.ReactRuntimeContext = __webpack_exports__.ReactRuntimeContext;
 exports.RuntimeComponentResolverContext = __webpack_exports__.RuntimeComponentResolverContext;
 exports.RuntimeContext = __webpack_exports__.RuntimeContext;
 exports.getCurrentEntryName = __webpack_exports__.getCurrentEntryName;
@@ -125,9 +128,11 @@ exports.routerProviderRegistryHooks = __webpack_exports__.routerProviderRegistry
 exports.setGlobalContext = __webpack_exports__.setGlobalContext;
 exports.setGlobalInternalRuntimeContext = __webpack_exports__.setGlobalInternalRuntimeContext;
 exports.setServerPayload = __webpack_exports__.setServerPayload;
+exports.useRuntimeContext = __webpack_exports__.useRuntimeContext;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "DefaultNotFound",
     "InternalRuntimeContext",
+    "ReactRuntimeContext",
     "RuntimeComponentResolverContext",
     "RuntimeContext",
     "getCurrentEntryName",
@@ -150,7 +155,8 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "routerProviderRegistryHooks",
     "setGlobalContext",
     "setGlobalInternalRuntimeContext",
-    "setServerPayload"
+    "setServerPayload",
+    "useRuntimeContext"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

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

@@ -28,11 +28,11 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    ReactRuntimeContext: ()=>external_runtime_js_namespaceObject.ReactRuntimeContext,
-    RuntimeContext: ()=>external_runtime_js_namespaceObject.RuntimeContext,
-    useRuntimeContext: ()=>external_runtime_js_namespaceObject.useRuntimeContext
+    ReactRuntimeContext: ()=>context_namespaceObject.ReactRuntimeContext,
+    RuntimeContext: ()=>context_namespaceObject.RuntimeContext,
+    useRuntimeContext: ()=>context_namespaceObject.useRuntimeContext
 });
-const external_runtime_js_namespaceObject = require("./runtime.js");
+const context_namespaceObject = require("@modern-js/runtime/context");
 exports.ReactRuntimeContext = __webpack_exports__.ReactRuntimeContext;
 exports.RuntimeContext = __webpack_exports__.RuntimeContext;
 exports.useRuntimeContext = __webpack_exports__.useRuntimeContext;

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

@@ -37,15 +37,9 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const external_react_namespaceObject = require("react");
 const ROUTE_MANIFEST = '_MODERNJS_ROUTE_MANIFEST';
-function getRuntimeReactContext(kind, create) {
-    const key = Symbol.for(`@modern-js/runtime:react-context:v1:${kind}`);
-    const contexts = globalThis;
-    contexts[key] ??= create();
-    return contexts[key];
-}
-const InternalRuntimeContext = getRuntimeReactContext('internal', ()=>(0, external_react_namespaceObject.createContext)({}));
-const RuntimeContext = getRuntimeReactContext('public', ()=>(0, external_react_namespaceObject.createContext)({}));
-const RuntimeComponentResolverContext = getRuntimeReactContext('component-resolver', ()=>(0, external_react_namespaceObject.createContext)(void 0));
+const InternalRuntimeContext = (0, external_react_namespaceObject.createContext)({});
+const RuntimeContext = (0, external_react_namespaceObject.createContext)({});
+const RuntimeComponentResolverContext = (0, external_react_namespaceObject.createContext)(void 0);
 const ReactRuntimeContext = RuntimeContext;
 const useRuntimeContext = ()=>(0, external_react_namespaceObject.useContext)(RuntimeContext);
 const getInitialContext = (isBrowser = true, routeManifest)=>{

package/dist/cjs/core/index.js

@@ -28,12 +28,12 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    RuntimeContext: ()=>runtime_js_namespaceObject.RuntimeContext,
+    RuntimeContext: ()=>context_namespaceObject.RuntimeContext,
     defineRuntimeConfig: ()=>external_config_js_namespaceObject.defineRuntimeConfig,
-    useRuntimeContext: ()=>runtime_js_namespaceObject.useRuntimeContext
+    useRuntimeContext: ()=>context_namespaceObject.useRuntimeContext
 });
+const context_namespaceObject = require("@modern-js/runtime/context");
 const external_config_js_namespaceObject = require("./config.js");
-const runtime_js_namespaceObject = require("./context/runtime.js");
 exports.RuntimeContext = __webpack_exports__.RuntimeContext;
 exports.defineRuntimeConfig = __webpack_exports__.defineRuntimeConfig;
 exports.useRuntimeContext = __webpack_exports__.useRuntimeContext;

package/dist/cjs/core/plugin/index.js

@@ -32,11 +32,11 @@ __webpack_require__.d(__webpack_exports__, {
     registerPlugin: ()=>registerPlugin
 });
 const runtime_namespaceObject = require("@modern-js/plugin/runtime");
+const context_namespaceObject = require("@modern-js/runtime/context");
 const merge_namespaceObject = require("@modern-js/runtime-utils/merge");
 const index_js_namespaceObject = require("../compat/index.js");
 const hooks_js_namespaceObject = require("../compat/hooks.js");
 const requestContext_js_namespaceObject = require("../compat/requestContext.js");
-const external_context_index_js_namespaceObject = require("../context/index.js");
 function registerPlugin(internalPlugins, runtimeConfig) {
     const { plugins = [] } = runtimeConfig || {};
     const { runtimeContext } = runtime_namespaceObject.runtime.run({
@@ -50,7 +50,7 @@ function registerPlugin(internalPlugins, runtimeConfig) {
         handleSetupResult: hooks_js_namespaceObject.handleSetupResult
     });
     const internalRuntimeContext = runtimeContext;
-    (0, external_context_index_js_namespaceObject.setGlobalInternalRuntimeContext)(internalRuntimeContext);
+    (0, context_namespaceObject.setGlobalInternalRuntimeContext)(internalRuntimeContext);
     return internalRuntimeContext;
 }
 function mergeConfig(config, ...otherConfig) {

package/dist/cjs/core/react/index.js

@@ -30,17 +30,17 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     createRoot: ()=>createRoot
 });
+const context_namespaceObject = require("@modern-js/runtime/context");
 const parsed_namespaceObject = require("@modern-js/runtime-utils/parsed");
 const external_common_js_namespaceObject = require("../../common.js");
 const external_constants_js_namespaceObject = require("../constants.js");
-const index_js_namespaceObject = require("../context/index.js");
 function createRoot(UserApp) {
-    const App = UserApp || (0, index_js_namespaceObject.getGlobalApp)();
+    const App = UserApp || (0, context_namespaceObject.getGlobalApp)();
     if ((0, external_common_js_namespaceObject.isBrowser)()) {
         window._SSR_DATA = window._SSR_DATA || (0, parsed_namespaceObject.parsedJSONFromElement)(external_constants_js_namespaceObject.SSR_DATA_JSON_ID);
         window._ROUTER_DATA = window._ROUTER_DATA || (0, parsed_namespaceObject.parsedJSONFromElement)(external_constants_js_namespaceObject.ROUTER_DATA_JSON_ID);
     }
-    const internalRuntimeContext = (0, index_js_namespaceObject.getGlobalInternalRuntimeContext)();
+    const internalRuntimeContext = (0, context_namespaceObject.getGlobalInternalRuntimeContext)();
     const hooks = internalRuntimeContext.hooks;
     const WrapperApp = hooks.wrapRoot.call(App);
     return WrapperApp;

package/dist/cjs/core/react/wrapper.js

@@ -32,10 +32,9 @@ __webpack_require__.d(__webpack_exports__, {
     wrapRuntimeContextProvider: ()=>wrapRuntimeContextProvider
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
-const index_js_namespaceObject = require("../context/index.js");
-const runtime_js_namespaceObject = require("../context/runtime.js");
-function wrapRuntimeComponentResolver(root, hooks = (0, index_js_namespaceObject.getGlobalInternalRuntimeContext)()?.hooks) {
-    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(runtime_js_namespaceObject.RuntimeComponentResolverContext.Provider, {
+const context_namespaceObject = require("@modern-js/runtime/context");
+function wrapRuntimeComponentResolver(root, hooks = (0, context_namespaceObject.getGlobalInternalRuntimeContext)()?.hooks) {
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(context_namespaceObject.RuntimeComponentResolverContext.Provider, {
         value: hooks?.resolveComponent?.call,
         children: root
     });
@@ -49,18 +48,18 @@ function wrapRuntimeContextProvider(App, contextValue) {
         context,
         ...rest
     };
-    const isRsc = true === (0, index_js_namespaceObject.getGlobalEnableRsc)();
+    const isRsc = true === (0, context_namespaceObject.getGlobalEnableRsc)();
     const projection = {
         internalContext: contextValue,
         publicContext: runtimeContextValue
     };
-    const values = (0, index_js_namespaceObject.getGlobalInternalRuntimeContext)()?.hooks.transformRuntimeContext?.call(projection, {
+    const values = (0, context_namespaceObject.getGlobalInternalRuntimeContext)()?.hooks.transformRuntimeContext?.call(projection, {
         context: contextValue,
         isRsc
     }) ?? projection;
-    const root = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(index_js_namespaceObject.InternalRuntimeContext.Provider, {
+    const root = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(context_namespaceObject.InternalRuntimeContext.Provider, {
         value: values.internalContext,
-        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(index_js_namespaceObject.RuntimeContext.Provider, {
+        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(context_namespaceObject.RuntimeContext.Provider, {
             value: values.publicContext,
             children: App
         })

package/dist/cjs/core/server/requestHandler.js

@@ -40,26 +40,25 @@ __webpack_require__.d(__webpack_exports__, {
     createRequestHandler: ()=>createRequestHandler
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const context_namespaceObject = require("@modern-js/runtime/context");
 const node_namespaceObject = require("@modern-js/runtime-utils/node");
 const request_namespaceObject = require("@modern-js/runtime-utils/universal/request");
 const external_react_namespaceObject = require("react");
 var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
-const index_js_namespaceObject = require("../context/index.js");
-const runtime_js_namespaceObject = require("../context/runtime.js");
-const serverPayload_index_js_namespaceObject = require("../context/serverPayload/index.js");
+const index_js_namespaceObject = require("../context/serverPayload/index.js");
 const external_react_index_js_namespaceObject = require("../react/index.js");
 const external_constants_js_namespaceObject = require("./constants.js");
 const external_requestResponse_js_namespaceObject = require("./requestResponse.js");
 const external_routerCleanup_js_namespaceObject = require("./routerCleanup.js");
 const external_utils_js_namespaceObject = require("./utils.js");
 async function handleRSCRequest(request, Root, context, options, handleRequest) {
-    const serverPayload = (0, serverPayload_index_js_namespaceObject.getServerPayload)();
+    const serverPayload = (0, index_js_namespaceObject.getServerPayload)();
     if (void 0 !== serverPayload) return await handleRequest(request, Root, {
         ...options,
         runtimeContext: context,
         rscRoot: serverPayload
     });
-    const App = (0, index_js_namespaceObject.getGlobalRSCRoot)();
+    const App = (0, context_namespaceObject.getGlobalRSCRoot)();
     if (App) return await handleRequest(request, external_react_namespaceObject.Fragment, {
         ...options,
         runtimeContext: context,
@@ -151,10 +150,10 @@ const createRequestHandler = async (handleRequest, createRequestOptions)=>{
             serverPayload: void 0
         }, async ()=>{
             const Root = (0, external_react_index_js_namespaceObject.createRoot)();
-            const internalRuntimeContext = (0, index_js_namespaceObject.getGlobalInternalRuntimeContext)();
+            const internalRuntimeContext = (0, context_namespaceObject.getGlobalInternalRuntimeContext)();
             const hooks = internalRuntimeContext.hooks;
             const { routeManifest } = options.resource;
-            const context = (0, runtime_js_namespaceObject.getInitialContext)(false, routeManifest);
+            const context = (0, context_namespaceObject.getInitialContext)(false, routeManifest);
             const runBeforeRender = async (context)=>{
                 const result = await hooks.onBeforeRender.call(context);
                 if ("u" > typeof Response && result instanceof Response) return result;

package/dist/cjs/core/server/stream/createReadableStream.js

@@ -30,13 +30,13 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     createReadableStreamFromElement: ()=>createReadableStreamFromElement
 });
+const context_namespaceObject = require("@modern-js/runtime/context");
 const node_namespaceObject = require("@modern-js/runtime-utils/node");
 const constants_namespaceObject = require("@modern-js/utils/universal/constants");
 const external_stream_namespaceObject = require("stream");
 const external_common_js_namespaceObject = require("../../../common.js");
 const external_constants_js_namespaceObject = require("../../constants.js");
-const index_js_namespaceObject = require("../../context/index.js");
-const monitors_index_js_namespaceObject = require("../../context/monitors/index.js");
+const index_js_namespaceObject = require("../../context/monitors/index.js");
 const wrapper_js_namespaceObject = require("../../react/wrapper.js");
 const external_helmet_js_namespaceObject = require("../helmet.js");
 const external_shared_js_namespaceObject = require("../shared.js");
@@ -46,8 +46,8 @@ const external_template_js_namespaceObject = require("./template.js");
 const createReadableStreamFromElement = async (request, rootElement, options)=>{
     const { renderToPipeableStream } = await import("react-dom/server");
     const { runtimeContext, htmlTemplate, config, ssrConfig, entryName, resource } = options;
-    const hooks = (0, index_js_namespaceObject.getGlobalInternalRuntimeContext)().hooks;
-    const isRsc = true === (0, index_js_namespaceObject.getGlobalEnableRsc)();
+    const hooks = (0, context_namespaceObject.getGlobalInternalRuntimeContext)().hooks;
+    const isRsc = true === (0, context_namespaceObject.getGlobalEnableRsc)();
     const extenders = hooks.extendStreamSSR.call({
         runtimeContext,
         request,
@@ -55,6 +55,7 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
         config,
         platform: 'node',
         mode: 'stream',
+        monitors: (0, index_js_namespaceObject.getMonitors)(),
         isRsc,
         terminalMarker: external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK
     }) || [];
@@ -153,7 +154,9 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
             });
             if (failed) return;
             const chunks = [];
+            let bufferedLength = 0;
             const marker = Buffer.from(external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK);
+            let markerTail = Buffer.alloc(0);
             const pendingScripts = [];
             let shellChunkStatus = external_shared_js_namespaceObject_1.ShellChunkStatus.START;
             const emitShell = (destination, buffered, markerIndex)=>{
@@ -161,6 +164,7 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
                 const completedShellBefore = (0, external_helmet_js_namespaceObject.createReplaceHelemt)((0, external_helmet_js_namespaceObject.getHelmetData)(extenders))(shellBefore);
                 shellChunkStatus = external_shared_js_namespaceObject_1.ShellChunkStatus.FINISH;
                 chunks.length = 0;
+                bufferedLength = 0;
                 destination.push(`${completedShellBefore}${beforeMark}${shellAfter}`);
                 const afterMark = buffered.subarray(markerIndex + marker.length);
                 if (afterMark.length > 0) destination.push(afterMark);
@@ -172,10 +176,17 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
                     try {
                         if (shellChunkStatus === external_shared_js_namespaceObject_1.ShellChunkStatus.FINISH) this.push(chunk);
                         else {
-                            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-                            const buffered = Buffer.concat(chunks);
-                            const markerIndex = buffered.indexOf(marker);
-                            if (-1 !== markerIndex) emitShell(this, buffered, markerIndex);
+                            const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                            const window = Buffer.concat([
+                                markerTail,
+                                bytes
+                            ]);
+                            const windowIndex = window.indexOf(marker);
+                            const windowStart = bufferedLength - markerTail.length;
+                            chunks.push(bytes);
+                            bufferedLength += bytes.length;
+                            if (-1 === windowIndex) markerTail = window.subarray(Math.max(0, window.length - marker.length + 1));
+                            else emitShell(this, Buffer.concat(chunks, bufferedLength), windowStart + windowIndex);
                         }
                         callback();
                     } catch (error) {
@@ -212,7 +223,7 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
                     else pendingScripts.push(script);
                 });
             } catch (error) {
-                (0, monitors_index_js_namespaceObject.getMonitors)().error("cannot inject router data script", error);
+                (0, index_js_namespaceObject.getMonitors)().error("cannot inject router data script", error);
             }
         };
         const renderFallback = async (error)=>{

package/dist/cjs/core/server/stream/createReadableStream.worker.js

@@ -40,12 +40,13 @@ __webpack_require__.d(__webpack_exports__, {
     createReadableStreamFromElement: ()=>createReadableStreamFromElement
 });
 const ssr_namespaceObject = require("@modern-js/render/ssr");
+const context_namespaceObject = require("@modern-js/runtime/context");
 const node_namespaceObject = require("@modern-js/runtime-utils/node");
 const external_react_namespaceObject = require("react");
 var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
 const external_common_js_namespaceObject = require("../../../common.js");
 const external_constants_js_namespaceObject = require("../../constants.js");
-const index_js_namespaceObject = require("../../context/index.js");
+const index_js_namespaceObject = require("../../context/monitors/index.js");
 const wrapper_js_namespaceObject = require("../../react/wrapper.js");
 const external_helmet_js_namespaceObject = require("../helmet.js");
 const external_shared_js_namespaceObject = require("../shared.js");
@@ -54,8 +55,8 @@ const external_shared_js_namespaceObject_1 = require("./shared.js");
 const external_template_js_namespaceObject = require("./template.js");
 const createReadableStreamFromElement = async (request, rootElement, options)=>{
     const { htmlTemplate, runtimeContext, config, ssrConfig, entryName, resource, rscManifest, rscRoot } = options;
-    const hooks = (0, index_js_namespaceObject.getGlobalInternalRuntimeContext)().hooks;
-    const isRsc = true === (0, index_js_namespaceObject.getGlobalEnableRsc)();
+    const hooks = (0, context_namespaceObject.getGlobalInternalRuntimeContext)().hooks;
+    const isRsc = true === (0, context_namespaceObject.getGlobalEnableRsc)();
     const extenders = hooks.extendStreamSSR.call({
         runtimeContext,
         request,
@@ -63,6 +64,7 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
         config,
         platform: 'web',
         mode: 'stream',
+        monitors: (0, index_js_namespaceObject.getMonitors)(),
         isRsc,
         terminalMarker: external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK
     }) || [];
@@ -122,7 +124,9 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
         const decoder = new TextDecoder();
         const encoder = new TextEncoder();
         const pendingScripts = [];
-        let buffered = '';
+        const buffered = [];
+        let bufferedLength = 0;
+        let markerTail = '';
         let shellChunkStatus = external_shared_js_namespaceObject_1.ShellChunkStatus.START;
         let bodyController;
         const emit = (chunk, controller)=>{
@@ -130,14 +134,21 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
                 if (chunk.length > 0) controller.enqueue(encoder.encode(chunk));
                 return;
             }
-            buffered += chunk;
-            const markerIndex = buffered.indexOf(external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK);
-            if (-1 === markerIndex) return;
-            const beforeMark = lifecycle.completedBody(buffered.slice(0, markerIndex), 'shell');
-            const afterMark = buffered.slice(markerIndex + external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK.length);
+            const window = markerTail + chunk;
+            const windowIndex = window.indexOf(external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK);
+            const markerIndex = bufferedLength - markerTail.length + windowIndex;
+            buffered.push(chunk);
+            bufferedLength += chunk.length;
+            if (-1 === windowIndex) {
+                markerTail = window.slice(Math.max(0, window.length - external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK.length + 1));
+                return;
+            }
+            const shell = buffered.join('');
+            const beforeMark = lifecycle.completedBody(shell.slice(0, markerIndex), 'shell');
+            const afterMark = shell.slice(markerIndex + external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK.length);
             const completedShellBefore = (0, external_helmet_js_namespaceObject.createReplaceHelemt)((0, external_helmet_js_namespaceObject.getHelmetData)(extenders))(shellBefore);
             shellChunkStatus = external_shared_js_namespaceObject_1.ShellChunkStatus.FINISH;
-            buffered = '';
+            buffered.length = 0;
             controller.enqueue(encoder.encode(`${completedShellBefore}${beforeMark}${shellAfter}`));
             if (afterMark.length > 0) controller.enqueue(encoder.encode(afterMark));
             for (const script of pendingScripts)controller.enqueue(encoder.encode(script));

package/dist/cjs/core/server/string/index.js

@@ -39,12 +39,13 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     renderString: ()=>renderString
 });
+const context_namespaceObject = require("@modern-js/runtime/context");
 const time_namespaceObject = require("@modern-js/runtime-utils/time");
 const constants_namespaceObject = require("@modern-js/utils/universal/constants");
 const server_namespaceObject = require("react-dom/server");
 var server_default = /*#__PURE__*/ __webpack_require__.n(server_namespaceObject);
 const external_constants_js_namespaceObject = require("../../constants.js");
-const index_js_namespaceObject = require("../../context/index.js");
+const index_js_namespaceObject = require("../../context/monitors/index.js");
 const wrapper_js_namespaceObject = require("../../react/wrapper.js");
 const external_constants_js_namespaceObject_1 = require("../constants.js");
 const external_helmet_js_namespaceObject = require("../helmet.js");
@@ -91,7 +92,7 @@ const renderString = async (request, serverRoot, options)=>{
         useJsonScript: config.useJsonScript,
         lifecycle
     }));
-    const internalRuntimeContext = (0, index_js_namespaceObject.getGlobalInternalRuntimeContext)();
+    const internalRuntimeContext = (0, context_namespaceObject.getGlobalInternalRuntimeContext)();
     const hooks = internalRuntimeContext.hooks;
     const extraCollectors = hooks.extendStringSSRCollectors.call({
         chunkSet,
@@ -102,14 +103,15 @@ const renderString = async (request, serverRoot, options)=>{
             config,
             platform: 'node',
             mode: 'string',
-            isRsc: true === (0, index_js_namespaceObject.getGlobalEnableRsc)()
+            monitors: (0, index_js_namespaceObject.getMonitors)(),
+            isRsc: true === (0, context_namespaceObject.getGlobalEnableRsc)()
         }
     });
     for (const c of extraCollectors)if (c) collectors.unshift(c);
     let rootElement = (0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(serverRoot, Object.assign(runtimeContext, {
         ssr: true
     }));
-    if (true === (0, index_js_namespaceObject.getGlobalEnableRsc)() && false === runtimeContext.isBrowser) rootElement = (0, wrapper_js_namespaceObject.wrapRuntimeComponentResolver)(rootElement, hooks);
+    if (true === (0, context_namespaceObject.getGlobalEnableRsc)() && false === runtimeContext.isBrowser) rootElement = (0, wrapper_js_namespaceObject.wrapRuntimeComponentResolver)(rootElement, hooks);
     const html = await generateHtml(rootElement, htmlTemplate, chunkSet, collectors, runtimeContext.ssrContext?.htmlModifiers || [], tracer, request.signal, lifecycle, loadableCollector.stylesheetInfo);
     return html;
 };

package/dist/cjs/exports/head.js

@@ -41,12 +41,12 @@ __webpack_require__.d(__webpack_exports__, {
     Helmet: ()=>Helmet,
     default: ()=>exports_head
 });
+const context_namespaceObject = require("@modern-js/runtime/context");
 const external_react_namespaceObject = require("react");
 var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
 const external_react_helmet_async_namespaceObject = require("react-helmet-async");
-const runtime_js_namespaceObject = require("../core/context/runtime.js");
 const Helmet = (props)=>{
-    const resolveComponent = external_react_default().useContext(runtime_js_namespaceObject.RuntimeComponentResolverContext);
+    const resolveComponent = external_react_default().useContext(context_namespaceObject.RuntimeComponentResolverContext);
     const Component = resolveComponent?.(external_react_helmet_async_namespaceObject.Helmet, {
         name: 'head.Helmet'
     }) ?? external_react_helmet_async_namespaceObject.Helmet;

package/dist/cjs/internal.js

@@ -28,9 +28,9 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    InternalRuntimeContext: ()=>runtime_js_namespaceObject.InternalRuntimeContext
+    InternalRuntimeContext: ()=>context_namespaceObject.InternalRuntimeContext
 });
-const runtime_js_namespaceObject = require("./core/context/runtime.js");
+const context_namespaceObject = require("@modern-js/runtime/context");
 exports.InternalRuntimeContext = __webpack_exports__.InternalRuntimeContext;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "InternalRuntimeContext"

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

@@ -70,10 +70,10 @@ __webpack_require__.d(__webpack_exports__, {
     NavLink: ()=>NavLink
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const context_namespaceObject = require("@modern-js/runtime/context");
 const router_namespaceObject = require("@modern-js/runtime-utils/router");
 const external_react_namespaceObject = require("react");
 var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
-const index_js_namespaceObject = require("../../core/context/index.js");
 const getWebpackChunkLoader = ()=>__webpack_chunk_load__;
 const getWebpackPublicPath = ()=>{
     try {
@@ -200,7 +200,7 @@ const getDataHref = (route, pathname, basename)=>{
 };
 const PrefetchPageLinks = ({ path, includeData })=>{
     const { pathname } = path;
-    const context = (0, external_react_namespaceObject.useContext)(index_js_namespaceObject.InternalRuntimeContext);
+    const context = (0, external_react_namespaceObject.useContext)(context_namespaceObject.InternalRuntimeContext);
     const { routeManifest, routes } = context;
     const { routeAssets } = routeManifest || {};
     const policy = context.linkPrefetchPolicy;
@@ -254,7 +254,7 @@ const PrefetchPageLinks = ({ path, includeData })=>{
 };
 const PrefetchDataLinks = ({ matches, path, routeManifest })=>{
     const { pathname, search, hash } = path;
-    const policy = (0, external_react_namespaceObject.useContext)(index_js_namespaceObject.InternalRuntimeContext).linkPrefetchPolicy;
+    const policy = (0, external_react_namespaceObject.useContext)(context_namespaceObject.InternalRuntimeContext).linkPrefetchPolicy;
     const currentMatches = (0, router_namespaceObject.useMatches)();
     const basename = (0, router_namespaceObject.useHref)('/');
     const dataHrefs = (0, external_react_namespaceObject.useMemo)(()=>matches?.filter((match, index)=>{
@@ -287,7 +287,7 @@ const PrefetchDataLinks = ({ matches, path, routeManifest })=>{
 };
 const createPrefetchLink = (Link)=>/*#__PURE__*/ (external_react_default()).forwardRef(({ to, prefetch, preload, ...props }, forwardedRef)=>{
         const isAbsolute = 'string' == typeof to && ABSOLUTE_URL_REGEX.test(to);
-        const policy = (0, external_react_namespaceObject.useContext)(index_js_namespaceObject.InternalRuntimeContext).linkPrefetchPolicy;
+        const policy = (0, external_react_namespaceObject.useContext)(context_namespaceObject.InternalRuntimeContext).linkPrefetchPolicy;
         const [shouldPrefetch, shouldPreload, prefetchHandlers, setViewportElement] = usePrefetchBehavior(prefetch, preload, props, policy);
         const setAnchorRef = external_react_default().useCallback((element)=>{
             setViewportElement(element);