@bleedingdev/modern-js-runtime 3.9.0-ultramodern.9 → 3.9.3-ultramodern.1

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

@@ -40,22 +40,24 @@ __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");
 const external_deferredScript_js_namespaceObject = require("./deferredScript.js");
+const external_deferredScriptOutputCoordinator_js_namespaceObject = require("./deferredScriptOutputCoordinator.js");
 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 +65,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
     }) || [];
@@ -75,6 +78,7 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
     let pendingSource;
     let bodyOpen = true;
     let bodyPipe;
+    let coordinator;
     const templateOptions = {
         runtimeContext,
         ssrConfig,
@@ -93,6 +97,7 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
             request,
             signal: request.signal,
             nonce: config.nonce,
+            progressiveChunkSize: external_shared_js_namespaceObject_1.SHELL_PROGRESSIVE_CHUNK_SIZE,
             rscManifest,
             rscRoot: rscRoot,
             routes: runtimeContext.routes,
@@ -121,66 +126,87 @@ 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)=>{
+        let deferredResolversComplete = Promise.resolve();
+        coordinator = new external_deferredScriptOutputCoordinator_js_namespaceObject.DeferredScriptOutputCoordinator((content)=>{
+            if (!bodyOpen) return;
+            try {
+                bodyController.enqueue(encoder.encode(content));
+            } catch  {
+                bodyOpen = false;
+            }
+        });
+        const emit = (chunk)=>{
             if (shellChunkStatus === external_shared_js_namespaceObject_1.ShellChunkStatus.FINISH) {
-                if (chunk.length > 0) controller.enqueue(encoder.encode(chunk));
+                if (chunk.length > 0) coordinator?.writeReact(chunk);
+                return;
+            }
+            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;
             }
-            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 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 = '';
-            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));
+            buffered.length = 0;
+            coordinator?.writeReact(`${completedShellBefore}${beforeMark}${shellAfter}`);
+            if (afterMark.length > 0) coordinator?.writeReact(afterMark);
+            coordinator?.markShellFinished();
+            for (const script of pendingScripts)coordinator?.enqueueResolver(script);
             pendingScripts.length = 0;
         };
         const body = new TransformStream({
             start (controller) {
                 bodyController = controller;
             },
-            transform (chunk, controller) {
+            transform (chunk) {
                 emit(decoder.decode(chunk, {
                     stream: true
-                }), controller);
+                }));
             },
-            flush (controller) {
-                bodyOpen = false;
-                emit(decoder.decode(), controller);
+            async flush () {
+                emit(decoder.decode());
                 if (shellChunkStatus !== external_shared_js_namespaceObject_1.ShellChunkStatus.FINISH) throw new Error('React SSR stream ended before the shell marker');
+                await deferredResolversComplete;
+                coordinator?.finish();
+                bodyOpen = false;
             }
         });
         bodyPipe = pendingSource.pipeTo(body.writable);
         bodyPipe.catch(()=>{});
         pendingSource = body.readable;
-        const activeDeferreds = node_namespaceObject.storage.useContext?.()?.activeDeferreds;
+        const storageContext = node_namespaceObject.storage.useContext?.();
+        const activeDeferreds = storageContext?.activeDeferreds;
+        const deferredScriptKeys = storageContext?.deferredScriptKeys;
         const entries = activeDeferreds instanceof Map ? Array.from(activeDeferreds.entries()) : [];
-        (0, external_deferredScript_js_namespaceObject.enqueueFromEntries)(entries, config.nonce, (script)=>{
+        if (entries.length > 0) deferredResolversComplete = (0, external_deferredScript_js_namespaceObject.enqueueFromEntries)(entries, deferredScriptKeys, config.nonce, (script)=>{
             if (!bodyOpen) return;
-            if (shellChunkStatus === external_shared_js_namespaceObject_1.ShellChunkStatus.FINISH) try {
-                bodyController.enqueue(encoder.encode(script));
-            } catch  {
-                bodyOpen = false;
-            }
+            if (shellChunkStatus === external_shared_js_namespaceObject_1.ShellChunkStatus.FINISH) coordinator?.enqueueResolver(script);
             else pendingScripts.push(script);
         });
         return (0, external_shared_js_namespaceObject.observeSSRStream)(pendingSource, {
             lifecycle,
             async onError (error) {
                 bodyOpen = false;
+                coordinator?.abort();
                 await bodyPipe?.catch(()=>{});
                 reportError(error);
             },
             signal: request.signal,
             async onCancel (reason) {
                 bodyOpen = false;
+                coordinator?.abort();
                 await bodyPipe?.catch((error)=>{
                     if (error !== reason) throw error;
                 });
@@ -189,6 +215,7 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
         });
     } catch (error) {
         bodyOpen = false;
+        coordinator?.abort();
         if (void 0 !== pendingSource) try {
             await pendingSource.cancel(error);
             await bodyPipe?.catch(()=>{});

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

@@ -82,24 +82,30 @@ function buildDeferredDataScript(nonce, args) {
     const nonceAttr = void 0 !== nonce && '' !== nonce ? ` nonce="${nonce}"` : '';
     return `<script async${nonceAttr} data-fn-name="r" data-script-src="modern-run-router-data-fn" data-fn-args='${escaped}' suppressHydrationWarning>${constants_js_namespaceObject.runRouterDataFnStr}</script>`;
 }
-function enqueueFromEntries(entries, nonce, emit) {
+function enqueueFromEntries(entries, deferredScriptKeys, nonce, emit) {
+    const pendingResolvers = [];
     entries.forEach(([routeId, value])=>{
         if (!isDeferredDataLike(value)) return;
-        const pendingKeys = new Set(value.pendingKeys ?? []);
-        pendingKeys.forEach((key)=>{
+        const serializedKeys = void 0 !== deferredScriptKeys ? deferredScriptKeys.get(routeId) ?? [] : value.pendingKeys ?? [];
+        serializedKeys.forEach((key)=>{
             const tracked = value.data?.[key];
-            if (isPromiseLike(tracked)) tracked.then((val)=>emit(buildDeferredDataScript(nonce, [
+            if (isPromiseLike(tracked)) pendingResolvers.push(Promise.resolve(tracked).then((val)=>{
+                emit(buildDeferredDataScript(nonce, [
                     routeId,
                     key,
                     val
-                ])), (err)=>emit(buildDeferredDataScript(nonce, [
+                ]));
+            }, (err)=>{
+                emit(buildDeferredDataScript(nonce, [
                     routeId,
                     key,
                     void 0,
                     toErrorInfo(err)
-                ])));
+                ]));
+            }));
         });
     });
+    return Promise.all(pendingResolvers).then(()=>void 0);
 }
 exports.buildDeferredDataScript = __webpack_exports__.buildDeferredDataScript;
 exports.enqueueFromEntries = __webpack_exports__.enqueueFromEntries;

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

@@ -0,0 +1,370 @@
+"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__, {
+    DeferredScriptOutputCoordinator: ()=>DeferredScriptOutputCoordinator
+});
+const constants_namespaceObject = require("@modern-js/utils/universal/constants");
+const VOID_ELEMENTS = new Set([
+    'area',
+    'base',
+    'br',
+    'col',
+    'embed',
+    'hr',
+    'img',
+    'input',
+    'link',
+    'meta',
+    'param',
+    'source',
+    'track',
+    'wbr'
+]);
+const RAW_TEXT_ELEMENTS = new Set([
+    'iframe',
+    'noembed',
+    'noframes',
+    "script",
+    'style',
+    'textarea',
+    'title',
+    'xmp'
+]);
+const REACT_SEGMENT_ID_PATTERN = new RegExp(`^${constants_namespaceObject.SSR_HYDRATION_ID_PREFIX}S:[0-9a-f]+$`);
+const TABLE_SEGMENT_CHILDREN = new Set([
+    'tbody',
+    'tr',
+    'colgroup'
+]);
+function isAsciiAlpha(char) {
+    return /[A-Za-z]/.test(char);
+}
+function isWhitespace(char) {
+    return /[\t\n\f\r ]/.test(char);
+}
+function getSuffix(value, pattern) {
+    const start = Math.max(0, value.length - pattern.length);
+    for(let index = start; index < value.length; index++){
+        const suffix = value.slice(index);
+        if (pattern.startsWith(suffix)) return suffix;
+    }
+    return '';
+}
+class DeferredScriptOutputCoordinator {
+    enqueueResolver(script) {
+        if (this.closed) return;
+        this.pendingResolvers.push(script);
+        this.flushResolvers();
+    }
+    markShellFinished() {
+        if (this.closed) return;
+        this.shellFinished = true;
+        this.flushResolvers();
+    }
+    writeReact(chunk) {
+        if (this.closed || '' === chunk) return;
+        this.flushResolvers();
+        let emittedUntil = 0;
+        for(let index = 0; index < chunk.length; index++){
+            const wasSafe = this.isSafeBoundary();
+            this.consume(chunk[index]);
+            if (!wasSafe && this.isSafeBoundary() && this.pendingResolvers.length > 0) {
+                this.emit(chunk.slice(emittedUntil, index + 1));
+                emittedUntil = index + 1;
+                this.flushResolvers();
+            }
+        }
+        if (emittedUntil < chunk.length) this.emit(chunk.slice(emittedUntil));
+    }
+    finish() {
+        if (this.closed) return;
+        this.flushResolvers();
+        this.closed = true;
+        if (this.pendingResolvers.length > 0) throw new Error("Cannot emit deferred resolver scripts because the React stream ended outside a safe HTML boundary.");
+    }
+    abort() {
+        this.closed = true;
+        this.pendingResolvers.length = 0;
+    }
+    isSafeBoundary() {
+        return this.shellFinished && 'data' === this.state && 0 === this.openElements.length && !this.awaitingContinuationProtocol;
+    }
+    flushResolvers() {
+        if (!this.isSafeBoundary() || 0 === this.pendingResolvers.length) return;
+        while(this.pendingResolvers.length > 0){
+            const resolver = this.pendingResolvers.shift();
+            if (void 0 !== resolver) this.emit(resolver);
+        }
+    }
+    consume(char) {
+        switch(this.state){
+            case 'data':
+                if ('<' === char) this.state = 'tag-open';
+                return;
+            case 'tag-open':
+                if ('/' === char) {
+                    this.currentTagName = '';
+                    this.state = 'end-tag-name';
+                } else if ('!' === char) {
+                    this.declarationPrefix = '';
+                    this.state = 'markup-declaration';
+                } else if ('?' === char) this.state = 'bogus-comment';
+                else if (isAsciiAlpha(char)) {
+                    this.startTag(char);
+                    this.state = 'start-tag-name';
+                } else this.state = 'data';
+                return;
+            case 'start-tag-name':
+                if (isWhitespace(char)) this.state = 'before-attribute-name';
+                else if ('/' === char) this.state = 'self-closing-start-tag';
+                else if ('>' === char) this.completeStartTag(false);
+                else this.currentTagName += char.toLowerCase();
+                return;
+            case 'before-attribute-name':
+                if (isWhitespace(char)) return;
+                if ('/' === char) this.state = 'self-closing-start-tag';
+                else if ('>' === char) this.completeStartTag(false);
+                else {
+                    this.startAttribute(char);
+                    this.state = 'attribute-name';
+                }
+                return;
+            case 'attribute-name':
+                if (isWhitespace(char)) this.state = 'after-attribute-name';
+                else if ('=' === char) {
+                    this.currentAttributeHasValue = true;
+                    this.state = 'before-attribute-value';
+                } else if ('/' === char) {
+                    this.completeAttribute();
+                    this.state = 'self-closing-start-tag';
+                } else if ('>' === char) this.completeStartTag(false);
+                else this.currentAttributeName += char.toLowerCase();
+                return;
+            case 'after-attribute-name':
+                if (isWhitespace(char)) return;
+                if ('=' === char) {
+                    this.currentAttributeHasValue = true;
+                    this.state = 'before-attribute-value';
+                } else if ('/' === char) {
+                    this.completeAttribute();
+                    this.state = 'self-closing-start-tag';
+                } else if ('>' === char) this.completeStartTag(false);
+                else {
+                    this.completeAttribute();
+                    this.startAttribute(char);
+                    this.state = 'attribute-name';
+                }
+                return;
+            case 'before-attribute-value':
+                if (isWhitespace(char)) return;
+                if ('"' === char) this.state = 'attribute-value-double-quoted';
+                else if ("'" === char) this.state = 'attribute-value-single-quoted';
+                else if ('>' === char) this.completeStartTag(false);
+                else {
+                    this.currentAttributeValue += char;
+                    this.state = 'attribute-value-unquoted';
+                }
+                return;
+            case 'attribute-value-double-quoted':
+                if ('"' === char) {
+                    this.completeAttribute();
+                    this.state = 'before-attribute-name';
+                } else this.currentAttributeValue += char;
+                return;
+            case 'attribute-value-single-quoted':
+                if ("'" === char) {
+                    this.completeAttribute();
+                    this.state = 'before-attribute-name';
+                } else this.currentAttributeValue += char;
+                return;
+            case 'attribute-value-unquoted':
+                if (isWhitespace(char)) {
+                    this.completeAttribute();
+                    this.state = 'before-attribute-name';
+                } else if ('>' === char) this.completeStartTag(false);
+                else this.currentAttributeValue += char;
+                return;
+            case 'self-closing-start-tag':
+                if ('>' === char) this.completeStartTag(true);
+                else if (!isWhitespace(char)) {
+                    this.startAttribute(char);
+                    this.state = 'attribute-name';
+                }
+                return;
+            case 'end-tag-name':
+                if (isWhitespace(char)) this.state = 'after-end-tag-name';
+                else if ('>' === char) this.completeEndTag();
+                else this.currentTagName += char.toLowerCase();
+                return;
+            case 'after-end-tag-name':
+                if ('>' === char) this.completeEndTag();
+                return;
+            case 'markup-declaration':
+                if (this.declarationPrefix.length < 2 && '-' === char) {
+                    this.declarationPrefix += char;
+                    if ('--' === this.declarationPrefix) {
+                        this.commentTail = '';
+                        this.state = 'comment';
+                    }
+                } else this.state = '>' === char ? 'data' : 'declaration';
+                return;
+            case 'declaration':
+                if ('>' === char) this.state = 'data';
+                return;
+            case 'comment':
+                this.commentTail = `${this.commentTail}${char}`.slice(-3);
+                if ('-->' === this.commentTail) this.state = 'data';
+                return;
+            case 'bogus-comment':
+                if ('>' === char) this.state = 'data';
+                return;
+            case 'raw-text':
+                this.consumeRawText(char);
+                return;
+            case 'raw-end-tag':
+                if ('>' === char) this.completeRawTextEndTag();
+                else if (!isWhitespace(char)) {
+                    this.state = 'raw-text';
+                    this.rawTextSearch = getSuffix(`${this.rawTextSearch}${char.toLowerCase()}`, `</${this.rawTextElement}`);
+                }
+        }
+    }
+    startTag(char) {
+        this.currentTagName = char.toLowerCase();
+        this.currentAttributes = new Map();
+        this.currentAttributeName = '';
+        this.currentAttributeValue = '';
+        this.currentAttributeHasValue = false;
+    }
+    startAttribute(char) {
+        this.currentAttributeName = char.toLowerCase();
+        this.currentAttributeValue = '';
+        this.currentAttributeHasValue = false;
+    }
+    completeAttribute() {
+        if ('' === this.currentAttributeName) return;
+        this.currentAttributes.set(this.currentAttributeName, this.currentAttributeHasValue ? this.currentAttributeValue : true);
+        this.currentAttributeName = '';
+        this.currentAttributeValue = '';
+        this.currentAttributeHasValue = false;
+    }
+    completeStartTag(selfClosing) {
+        this.completeAttribute();
+        const tagName = this.currentTagName;
+        const id = this.currentAttributes.get('id');
+        const hasReactSegmentId = 'string' == typeof id && REACT_SEGMENT_ID_PATTERN.test(id);
+        const hasHiddenAttribute = this.currentAttributes.has('hidden');
+        const isHiddenSegmentTable = 'table' === tagName && hasHiddenAttribute && !hasReactSegmentId;
+        const isTableSegmentChild = hasReactSegmentId && TABLE_SEGMENT_CHILDREN.has(tagName) && this.openElements[this.openElements.length - 1]?.isSegmentTableWrapper === true;
+        const isContinuationContainer = hasReactSegmentId && ('div' === tagName && hasHiddenAttribute || ('svg' === tagName || 'math' === tagName) && void 0 !== id && 'true' === this.currentAttributes.get('aria-hidden') && 'display:none' === this.currentAttributes.get('style') || 'table' === tagName && hasHiddenAttribute || isTableSegmentChild);
+        this.continuationProtocolScript = "script" === tagName && this.awaitingContinuationProtocol;
+        this.continuationProtocolTail = '';
+        this.hasContinuationProtocolCall = false;
+        if (!selfClosing && !VOID_ELEMENTS.has(tagName)) this.openElements.push({
+            tagName,
+            isContinuationContainer,
+            isSegmentTableWrapper: isHiddenSegmentTable
+        });
+        this.currentTagName = '';
+        this.currentAttributes = new Map();
+        this.currentAttributeName = '';
+        this.currentAttributeValue = '';
+        this.currentAttributeHasValue = false;
+        if (!selfClosing && RAW_TEXT_ELEMENTS.has(tagName)) {
+            this.rawTextElement = tagName;
+            this.rawTextSearch = '';
+            this.state = 'raw-text';
+        } else this.state = 'data';
+    }
+    completeEndTag() {
+        this.closeOpenElement(this.currentTagName);
+        this.currentTagName = '';
+        this.state = 'data';
+    }
+    consumeRawText(char) {
+        const rawTextElement = this.rawTextElement;
+        if (void 0 === rawTextElement) {
+            this.state = 'data';
+            return;
+        }
+        const endTagPrefix = `</${rawTextElement}`;
+        if (this.continuationProtocolScript) {
+            this.continuationProtocolTail = `${this.continuationProtocolTail}${char}`.slice(-4);
+            if (/\$(?:RC|RS|RX|RB|RR)\b/.test(this.continuationProtocolTail)) this.hasContinuationProtocolCall = true;
+        }
+        this.rawTextSearch = getSuffix(`${this.rawTextSearch}${char.toLowerCase()}`, endTagPrefix);
+        if (this.rawTextSearch === endTagPrefix) this.state = 'raw-end-tag';
+    }
+    completeRawTextEndTag() {
+        const rawTextElement = this.rawTextElement;
+        if (void 0 !== rawTextElement) this.closeOpenElement(rawTextElement);
+        if ("script" === rawTextElement && this.continuationProtocolScript && this.hasContinuationProtocolCall) this.awaitingContinuationProtocol = false;
+        this.rawTextElement = void 0;
+        this.rawTextSearch = '';
+        this.continuationProtocolScript = false;
+        this.continuationProtocolTail = '';
+        this.hasContinuationProtocolCall = false;
+        this.state = 'data';
+    }
+    closeOpenElement(tagName) {
+        const matchingIndex = this.openElements.map((element)=>element.tagName).lastIndexOf(tagName);
+        if (-1 === matchingIndex) return;
+        const closedElements = this.openElements.splice(matchingIndex);
+        const closedContinuation = closedElements.some((element)=>element.isContinuationContainer);
+        if (closedContinuation) this.awaitingContinuationProtocol = true;
+    }
+    constructor(emit){
+        this.emit = emit;
+        this.pendingResolvers = [];
+        this.openElements = [];
+        this.shellFinished = false;
+        this.closed = false;
+        this.state = 'data';
+        this.currentTagName = '';
+        this.currentAttributes = new Map();
+        this.currentAttributeName = '';
+        this.currentAttributeValue = '';
+        this.currentAttributeHasValue = false;
+        this.declarationPrefix = '';
+        this.commentTail = '';
+        this.rawTextSearch = '';
+        this.continuationProtocolScript = false;
+        this.continuationProtocolTail = '';
+        this.hasContinuationProtocolCall = false;
+        this.awaitingContinuationProtocol = false;
+    }
+}
+exports.DeferredScriptOutputCoordinator = __webpack_exports__.DeferredScriptOutputCoordinator;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DeferredScriptOutputCoordinator"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -28,6 +28,7 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    SHELL_PROGRESSIVE_CHUNK_SIZE: ()=>SHELL_PROGRESSIVE_CHUNK_SIZE,
     ShellChunkStatus: ()=>shared_ShellChunkStatus,
     createRenderStreaming: ()=>createRenderStreaming,
     encodeForWebStream: ()=>encodeForWebStream,
@@ -46,6 +47,7 @@ var shared_ShellChunkStatus = /*#__PURE__*/ function(ShellChunkStatus) {
     ShellChunkStatus[ShellChunkStatus["FINISH"] = 1] = "FINISH";
     return ShellChunkStatus;
 }({});
+const SHELL_PROGRESSIVE_CHUNK_SIZE = Number.MAX_SAFE_INTEGER;
 const SHOULD_STREAM_ALL_HEADER = 'x-should-stream-all';
 function parseShouldStreamAllFlag(value) {
     if (!value) return;
@@ -143,12 +145,14 @@ function createRenderStreaming(createReadableStreamPromise) {
         return stream;
     };
 }
+exports.SHELL_PROGRESSIVE_CHUNK_SIZE = __webpack_exports__.SHELL_PROGRESSIVE_CHUNK_SIZE;
 exports.ShellChunkStatus = __webpack_exports__.ShellChunkStatus;
 exports.createRenderStreaming = __webpack_exports__.createRenderStreaming;
 exports.encodeForWebStream = __webpack_exports__.encodeForWebStream;
 exports.getReadableStreamFromString = __webpack_exports__.getReadableStreamFromString;
 exports.resolveStreamingMode = __webpack_exports__.resolveStreamingMode;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "SHELL_PROGRESSIVE_CHUNK_SIZE",
     "ShellChunkStatus",
     "createRenderStreaming",
     "encodeForWebStream",

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;
 };