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

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

@@ -0,0 +1,333 @@
+import "node:module";
+import { SSR_HYDRATION_ID_PREFIX } from "@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(`^${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;
+    }
+}
+export { DeferredScriptOutputCoordinator };

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

@@ -11,6 +11,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;
@@ -108,4 +109,4 @@ function createRenderStreaming(createReadableStreamPromise) {
         return stream;
     };
 }
-export { createRenderStreaming, encodeForWebStream, getReadableStreamFromString, resolveStreamingMode, shared_ShellChunkStatus as ShellChunkStatus };
+export { SHELL_PROGRESSIVE_CHUNK_SIZE, createRenderStreaming, encodeForWebStream, getReadableStreamFromString, resolveStreamingMode, shared_ShellChunkStatus as ShellChunkStatus };

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

@@ -1,9 +1,10 @@
 import "node:module";
+import { getGlobalEnableRsc, getGlobalInternalRuntimeContext } from "@modern-js/runtime/context";
 import { time } from "@modern-js/runtime-utils/time";
 import { SSR_HYDRATION_ID_PREFIX } from "@modern-js/utils/universal/constants";
 import server from "react-dom/server";
 import { RenderLevel } from "../../constants.mjs";
-import { getGlobalEnableRsc, getGlobalInternalRuntimeContext } from "../../context/index.mjs";
+import { getMonitors } from "../../context/monitors/index.mjs";
 import { wrapRuntimeComponentResolver, wrapRuntimeContextProvider } from "../../react/wrapper.mjs";
 import { CHUNK_CSS_PLACEHOLDER, CHUNK_JS_PLACEHOLDER, HTML_PLACEHOLDER, SSR_DATA_PLACEHOLDER } from "../constants.mjs";
 import { createReplaceHelemt, getHelmetData } from "../helmet.mjs";
@@ -61,6 +62,7 @@ const renderString = async (request, serverRoot, options)=>{
             config,
             platform: 'node',
             mode: 'string',
+            monitors: getMonitors(),
             isRsc: true === getGlobalEnableRsc()
         }
     });

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

@@ -20,8 +20,8 @@ const assetToChunk = (asset)=>({
     });
 const checkIsInline = (chunk, enableInline)=>{
     if ('production' !== process.env.NODE_ENV) return false;
-    if (enableInline instanceof RegExp) return enableInline.test(chunk.url);
-    return Boolean(enableInline);
+    else if (enableInline instanceof RegExp) return enableInline.test(chunk.url);
+    else return Boolean(enableInline);
 };
 const readAsset = async (chunk)=>{
     const fs = await import("fs/promises");
@@ -114,7 +114,7 @@ class LoadableCollector {
         const scripts = await Promise.all(chunks.filter((chunk)=>!existedScript.includes(chunk.url) && !this.existsAssets?.includes(chunk.path)).map(async (chunk)=>{
             const script = `<script${attributes} src="${chunk.url}"></script>`;
             if (checkIsNode() && checkIsInline(chunk, inlineStyles)) return readAsset(chunk).then((content)=>`<script>${content}</script>`).catch((_)=>script);
-            return script;
+            else return script;
         }));
         chunkSet.jsChunk += scripts.filter((script)=>Boolean(script)).join('');
     }
@@ -131,7 +131,7 @@ class LoadableCollector {
         const css = await Promise.all(emittedChunks.map(async (chunk)=>{
             const link = `<link${atrributes} href="${chunk.url}" rel="stylesheet" />`;
             if (checkIsNode() && checkIsInline(chunk, inlineStyles)) return readAsset(chunk).then((content)=>`<style>${content}</style>`).catch((_)=>link);
-            return link;
+            else return link;
         }));
         chunkSet.cssChunk += css.filter((css)=>Boolean(css)).join('');
         this.stylesheetInfo.emittedAssets = emittedChunks.map((chunk)=>chunk.url);

package/dist/esm-node/document/cli/index.mjs

@@ -126,6 +126,7 @@ g.__MODERN_DOC_RENDERERS__[${JSON.stringify(_entryName)}] = render;
 
 export default { render: render };`;
 };
+const getDocumentTempEntry = (internalDirectory, compilerName, entryName)=>path.join(internalDirectory, CONSTANTS.DOCUMENT_OUTPUT_DIR, compilerName ?? '', `${CONSTANTS.TEMP_ENTRY_PREFIX}${entryName}.js`);
 const processChildCompilation = async (entryName, docPath, compilation, compiler, appDirectory, internalDirectory)=>new Promise((resolve, reject)=>{
         const outFile = path.posix.join(CONSTANTS.DOCUMENT_OUTPUT_DIR, `${CONSTANTS.HTML_OUTPUT_PREFIX}${entryName}${CONSTANTS.HTML_OUTPUT_SUFFIX}`);
         const child = compilation.createChildCompiler(`${CONSTANTS.CHILD_COMPILER_PREFIX}${entryName}`, {
@@ -136,8 +137,7 @@ const processChildCompilation = async (entryName, docPath, compilation, compiler
         }, []);
         configureChildCompiler(child, compiler, appDirectory);
         applyExternalsPlugin(child, compiler);
-        const entryDir = path.join(internalDirectory, CONSTANTS.DOCUMENT_OUTPUT_DIR);
-        const tempEntry = path.join(entryDir, `${CONSTANTS.TEMP_ENTRY_PREFIX}${entryName}.js`);
+        const tempEntry = getDocumentTempEntry(internalDirectory, compiler.name, entryName);
         const finalize = ()=>{
             try {
                 const EntryPlugin = compiler.rspack?.EntryPlugin;
@@ -204,6 +204,7 @@ const documentPlugin = ()=>({
                             const tasks = [];
                             for (const ep of entrypoints || []){
                                 const entryName = ep.entryName;
+                                if (!this.htmlEntryNames.has(entryName)) continue;
                                 const docPath = getDocumentByEntryName(entrypoints, entryName, appDirectory);
                                 if (docPath) {
                                     compilation.fileDependencies?.add?.(docPath);
@@ -220,14 +221,19 @@ const documentPlugin = ()=>({
                         }
                     });
                 }
-                constructor(){
+                constructor(htmlEntryNames){
+                    this.htmlEntryNames = htmlEntryNames;
                     this.name = 'ModernJsDocumentChildCompilerPlugin';
                 }
             }
             api.config(()=>({
                     tools: {
-                        bundlerChain: (chain)=>{
-                            chain.plugin('modernjs-document-child-compiler').use(ModernJsDocumentChildCompilerPlugin, []);
+                        bundlerChain: (chain, { environment })=>{
+                            const htmlEntryNames = new Set(Object.keys(environment.htmlPaths));
+                            if (0 === htmlEntryNames.size) return;
+                            chain.plugin('modernjs-document-child-compiler').use(ModernJsDocumentChildCompilerPlugin, [
+                                htmlEntryNames
+                            ]);
                         }
                     }
                 }));
@@ -348,4 +354,4 @@ const documentPlugin = ()=>({
     });
 const cli = documentPlugin;
 export default cli;
-export { documentPlugin, getDocumentByEntryName, processScriptPlaceholders };
+export { documentPlugin, getDocumentByEntryName, getDocumentTempEntry, processScriptPlaceholders };

package/dist/esm-node/exports/head.mjs

@@ -1,8 +1,8 @@
 import "node:module";
 "use client";
+import { RuntimeComponentResolverContext } from "@modern-js/runtime/context";
 import react from "react";
 import { Helmet, HelmetData, HelmetProvider } from "react-helmet-async";
-import { RuntimeComponentResolverContext } from "../core/context/runtime.mjs";
 const head_Helmet = (props)=>{
     const resolveComponent = react.useContext(RuntimeComponentResolverContext);
     const Component = resolveComponent?.(Helmet, {

package/dist/esm-node/internal.mjs

@@ -1,2 +1,2 @@
 import "node:module";
-export { InternalRuntimeContext } from "./core/context/runtime.mjs";
+export { InternalRuntimeContext } from "@modern-js/runtime/context";

package/dist/esm-node/router/cli/code/nestedRoutes.mjs

@@ -43,8 +43,7 @@ const optimizeRoute = (routeTree)=>{
                 children: optimizedChildren
             }
         ];
-    }
-    {
+    } else {
         const newRoutes = children.map((child)=>{
             const routePath = routeTree.path ? `${routeTree.path}${child.path ? `/${child.path}` : ''}` : child.path || '';
             const newRoute = {

package/dist/esm-node/router/cli/code/templates.mjs

@@ -353,7 +353,7 @@ const runtimeGlobalContext = async ({ entryName, metaName, srcDirectory, nestedR
                 source: rootLayout.toString(),
                 filename: rootLayoutFile
             });
-            const hasAppInit = moduleExports.some((e)=>e.n === APP_INIT_EXPORTED);
+            const hasAppInit = moduleExports.some((e)=>'reexport-all' !== e.type && e.name === APP_INIT_EXPORTED);
             const layoutPath = formatImportPath(getPathWithoutExt(replaceWithAlias(srcDirectory, rootLayoutFile, internalSrcAlias)));
             if (hasAppInit) imports.push(`import { init as appInit } from '${layoutPath}';`);
             else imports.push("let appInit;");
@@ -379,7 +379,7 @@ const runtimeGlobalContext = async ({ entryName, metaName, srcDirectory, nestedR
         enableRsc: true,
       });
     `;
-    return `${imports.join('\n')}
+    else return `${imports.join('\n')}
 
     import { routes } from '${routesImportPath}';
 

package/dist/esm-node/router/cli/code/utils.mjs

@@ -1,6 +1,6 @@
 import "node:module";
 import { JS_EXTENSIONS, fs, normalizeToPosixPath } from "@modern-js/utils";
-import { parse } from "es-module-lexer";
+import { init, parse } from "es-module-lexer";
 import { transform } from "esbuild";
 import fs_0 from "fs";
 import path from "path";
@@ -11,7 +11,7 @@ const walkDirectory = (dir)=>fs_0.readdirSync(dir).reduce((previous, filename)=>
             ...previous,
             ...walkDirectory(filePath)
         ];
-        return [
+        else return [
             ...previous,
             filePath
         ];
@@ -28,7 +28,7 @@ const isPageComponentFile = (filePath)=>{
 };
 const replaceWithAlias = (base, filePath, alias)=>{
     if (filePath.includes(base)) return normalizeToPosixPath(path.join(alias, path.relative(base, filePath)));
-    return filePath;
+    else return filePath;
 };
 const parseModule = async ({ source, filename })=>{
     let content = source;
@@ -48,6 +48,7 @@ const parseModule = async ({ source, filename })=>{
         });
         content = result.code;
     }
+    await init();
     return parse(content);
 };
 const hasLoader = async (filename, source)=>{
@@ -58,7 +59,7 @@ const hasLoader = async (filename, source)=>{
             source: content.toString(),
             filename
         });
-        return moduleExports.some((e)=>e.n === LOADER_EXPORT_NAME);
+        return moduleExports.some((e)=>'reexport-all' !== e.type && e.name === LOADER_EXPORT_NAME);
     }
     return false;
 };
@@ -70,7 +71,7 @@ const hasAction = async (filename, source)=>{
             source: content.toString(),
             filename
         });
-        return moduleExports.some((e)=>e.n === ACTION_EXPORT_NAME);
+        return moduleExports.some((e)=>'reexport-all' !== e.type && e.name === ACTION_EXPORT_NAME);
     }
     return false;
 };

package/dist/esm-node/router/runtime/DeferredDataScripts.node.mjs

@@ -29,7 +29,8 @@ const DeferredDataScripts = (props)=>{
     }, []);
     const deferredScripts = useMemo(()=>{
         if (!staticContext) return null;
-        const activeDeferreds = storage.useContext().activeDeferreds;
+        const requestStorage = storage.useContext();
+        const activeDeferreds = requestStorage.activeDeferreds;
         const _ROUTER_DATA = {
             loaderData: staticContext.loaderData,
             errors: serializeErrors(staticContext.errors)
@@ -42,6 +43,7 @@ const DeferredDataScripts = (props)=>{
         const deferredDataScripts = [];
         const initialScripts = Array.from(activeDeferreds.entries()).map(([routeId, deferredData])=>{
             const pendingKeys = new Set(deferredData.pendingKeys);
+            requestStorage.deferredScriptKeys?.set(routeId, Array.from(pendingKeys));
             const { deferredKeys } = deferredData;
             const deferredKeyPromiseManifests = deferredKeys.map((key)=>{
                 if (pendingKeys.has(key)) return {
@@ -52,7 +54,7 @@ const DeferredDataScripts = (props)=>{
                         serializeJson(key)
                     ]
                 };
-                {
+                else {
                     const trackedPromise = deferredData.data[key];
                     if (void 0 !== trackedPromise._error) {
                         const error = toDeferredErrorInfo(trackedPromise._error);
@@ -64,15 +66,16 @@ const DeferredDataScripts = (props)=>{
                                 serializeJson(error)
                             ]
                         };
+                    } else {
+                        if (void 0 === trackedPromise._data) throw new Error(`The deferred data for ${key} was not resolved, did you forget to return data from a deferred promise`);
+                        return {
+                            key,
+                            routerDataFnName: 'p',
+                            routerDataFnArgs: [
+                                serializeJson(trackedPromise._data)
+                            ]
+                        };
                     }
-                    if (void 0 === trackedPromise._data) throw new Error(`The deferred data for ${key} was not resolved, did you forget to return data from a deferred promise`);
-                    return {
-                        key,
-                        routerDataFnName: 'p',
-                        routerDataFnArgs: [
-                            serializeJson(trackedPromise._data)
-                        ]
-                    };
                 }
             });
             return {

package/dist/esm-node/router/runtime/PrefetchLink.mjs

@@ -1,9 +1,9 @@
 import "node:module";
 "use client";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { InternalRuntimeContext } from "@modern-js/runtime/context";
 import { Link as router_Link, NavLink, matchRoutes, useHref, useMatches, useResolvedPath } from "@modern-js/runtime-utils/router";
 import react, { useContext, useMemo } from "react";
-import { InternalRuntimeContext } from "../../core/context/index.mjs";
 import { __webpack_require__ } from "../../rslib-runtime~0.mjs";
 const getWebpackChunkLoader = ()=>__webpack_chunk_load__;
 const getWebpackPublicPath = ()=>{

package/dist/esm-node/router/runtime/hooks.mjs

@@ -1,12 +1,11 @@
 import "node:module";
 import { createSyncHook } from "@modern-js/plugin";
-const createRouterSyncHook = ()=>createSyncHook();
-const modifyRoutes = createRouterSyncHook();
-const onBeforeCreateRoutes = createRouterSyncHook();
-const onBeforeCreateRouter = createRouterSyncHook();
-const onAfterCreateRouter = createRouterSyncHook();
-const onBeforeHydrateRouter = createRouterSyncHook();
-const onAfterHydrateRouter = createRouterSyncHook();
+const modifyRoutes = createSyncHook();
+const onBeforeCreateRoutes = createSyncHook();
+const onBeforeCreateRouter = createSyncHook();
+const onAfterCreateRouter = createSyncHook();
+const onBeforeHydrateRouter = createSyncHook();
+const onAfterHydrateRouter = createSyncHook();
 const routerProviderRegistryHooks = {
     modifyRoutes: modifyRoutes,
     onBeforeCreateRoutes: onBeforeCreateRoutes,