@reckona/mreact-router 0.0.188 → 0.0.190

package/dist/render.js

@@ -13,7 +13,7 @@ import { matchRoute, scanAppRoutes } from "./routes.js";
 import { appFileConventionContentType } from "./file-conventions.js";
 import { dispatchServerActionRequest, prepareRouteServerActionPlaceholders, prepareRouteServerActions, } from "./actions.js";
 import { serverActionCookie } from "./csrf.js";
-import { beginRouteCacheContext, cachedRouteResponse, cacheRouteResponse, routeCacheKey, routeCachePolicyFromSource, } from "./cache.js";
+import { activeRouteCacheContext, withRouteCacheContext, cachedRouteResponse, cacheRouteResponse, routeCacheKey, routeCachePolicyFromSource, } from "./cache.js";
 import { resolveRouterCacheLimit } from "./cache-config.js";
 import { importAppRouterBuiltFileModule, importAppRouterFileModule, importAppRouterSourceModule, fileImportMetaUrlPlugin, rewriteCompatVendorPlaceholderImportsForRunner, } from "./module-runner.js";
 import { bytesResponse, htmlResponse } from "./http.js";
@@ -489,335 +489,430 @@ async function renderAppRequestInternal(options) {
     }
     const queryClient = options.queryClient ?? createQueryClient();
     let recoveryRoute;
-    let routeCacheContext;
-    try {
-        if (matched.route.kind === "asset") {
-            return await dispatchConventionAssetRoute({
-                file: matched.route.file,
-                request: options.request,
-            });
-        }
-        if (matched.route.kind === "metadata") {
-            return await dispatchMetadataRoute({
-                appDir: options.appDir,
-                file: matched.route.file,
-                importPolicy: options.importPolicy,
-                params: matched.params,
-                request: options.request,
-                route: matched.route,
-                serverModules: options.serverModules,
-                serverModuleCacheVersion: options.serverModuleCacheVersion,
-                serverSourceFiles: options.serverSourceFiles,
-                vitePlugins: options.vitePlugins,
-            });
-        }
-        if (matched.route.kind === "server") {
-            return await dispatchServerRoute({
-                appDir: options.appDir,
-                env: options.env,
-                file: matched.route.file,
-                importPolicy: options.importPolicy,
-                params: matched.params,
-                request: options.request,
-                route: matched.route,
-                serverModules: options.serverModules,
-                serverModuleCacheVersion: options.serverModuleCacheVersion,
-                serverSourceFiles: options.serverSourceFiles,
-                vitePlugins: options.vitePlugins,
-            });
-        }
-        // Issue 080: page routes render HTML for GET / HEAD only. Other
-        // methods (PUT, PATCH, DELETE, PROPFIND, ...) get 405 with an
-        // Allow header so the response shape complies with RFC 9110 §9
-        // and so caching intermediaries do not cross-cache method results.
-        const methodResponse = pageRouteMethodResponse(options.request.method);
-        if (methodResponse !== undefined) {
-            return methodResponse;
-        }
-        routeCacheContext = beginRouteCacheContext(options.routeCache);
-        const clientScript = options.clientScripts?.get(matched.route.path);
-        const clientStyleSheets = options.clientStyles?.get(matched.route.path);
-        phaseStartedAt = renderTimingPhaseStartedAt(timing);
-        const originalCode = await readServerSourceFile(matched.route.file, options.serverModuleCacheVersion, options.serverSourceFiles);
-        finishRenderTimingPhase(timing, phaseStartedAt, "readSourceMs");
-        phaseStartedAt = renderTimingPhaseStartedAt(timing);
-        const originalAnalysis = await analyzeRouteSource({
-            appDir: options.appDir,
-            artifact: options.serverModules?.get(matched.route.file)?.analysis,
-            code: originalCode,
-            filename: matched.route.file,
-            routePath: matched.route.path,
-            clientRouteInferenceCache,
-            serverModuleCacheVersion: options.serverModuleCacheVersion,
-            serverSourceFiles: options.serverSourceFiles,
-            define: options.define,
-            timing,
-            vitePlugins: options.vitePlugins,
-        });
-        finishRenderTimingPhase(timing, phaseStartedAt, "sourceAnalysisMs");
-        const cachePolicy = originalAnalysis.cachePolicy;
-        const navigationScript = options.navigationScripts?.get(matched.route.path);
-        const cacheKey = routeCacheKey(options.appDir, matched.route.path, url);
-        const mayUseRouteCache = cachePolicy === undefined
-            ? originalAnalysis.usesRuntimeCacheControl
-            : cachePolicy.revalidateSeconds !== 0;
-        const reloadRouteCache = isNavigationRouteCacheReloadRequest(options.request);
-        phaseStartedAt = renderTimingPhaseStartedAt(timing);
-        const cachedResponse = !mayUseRouteCache || reloadRouteCache
-            ? undefined
-            : await cachedRouteResponse({
-                cache: options.routeCache,
-                key: cacheKey,
-                request: options.request,
-            });
-        finishRenderTimingPhase(timing, phaseStartedAt, "routeCacheMs");
-        if (cachedResponse !== undefined) {
-            return cachedResponse;
-        }
-        phaseStartedAt = renderTimingPhaseStartedAt(timing);
-        const preparedActions = await prepareRouteServerActions({
-            appDir: options.appDir,
-            code: originalCode,
-            formActionReferences: options.serverActionReferencesByFile?.get(matched.route.file),
-            placeholders: true,
-            pageFile: matched.route.file,
-            request: options.request,
-        });
-        for (const diagnostic of preparedActions.diagnostics ?? []) {
-            console.warn(`${diagnostic.code}: ${diagnostic.message}`);
-        }
-        finishRenderTimingPhase(timing, phaseStartedAt, "serverActionsMs");
-        const code = preparedActions.code;
-        phaseStartedAt = renderTimingPhaseStartedAt(timing);
-        const routeAnalysis = code === originalCode
-            ? originalAnalysis
-            : await analyzeRouteSource({
+    return (await withRouteCacheContext(options.routeCache, async () => {
+        try {
+            if (matched.route.kind === "asset") {
+                return await dispatchConventionAssetRoute({
+                    file: matched.route.file,
+                    request: options.request,
+                });
+            }
+            if (matched.route.kind === "metadata") {
+                return await dispatchMetadataRoute({
+                    appDir: options.appDir,
+                    file: matched.route.file,
+                    importPolicy: options.importPolicy,
+                    params: matched.params,
+                    request: options.request,
+                    route: matched.route,
+                    serverModules: options.serverModules,
+                    serverModuleCacheVersion: options.serverModuleCacheVersion,
+                    serverSourceFiles: options.serverSourceFiles,
+                    vitePlugins: options.vitePlugins,
+                });
+            }
+            if (matched.route.kind === "server") {
+                return await dispatchServerRoute({
+                    appDir: options.appDir,
+                    env: options.env,
+                    file: matched.route.file,
+                    importPolicy: options.importPolicy,
+                    params: matched.params,
+                    request: options.request,
+                    route: matched.route,
+                    serverModules: options.serverModules,
+                    serverModuleCacheVersion: options.serverModuleCacheVersion,
+                    serverSourceFiles: options.serverSourceFiles,
+                    vitePlugins: options.vitePlugins,
+                });
+            }
+            // Issue 080: page routes render HTML for GET / HEAD only. Other
+            // methods (PUT, PATCH, DELETE, PROPFIND, ...) get 405 with an
+            // Allow header so the response shape complies with RFC 9110 §9
+            // and so caching intermediaries do not cross-cache method results.
+            const methodResponse = pageRouteMethodResponse(options.request.method);
+            if (methodResponse !== undefined) {
+                return methodResponse;
+            }
+            const clientScript = options.clientScripts?.get(matched.route.path);
+            const clientStyleSheets = options.clientStyles?.get(matched.route.path);
+            phaseStartedAt = renderTimingPhaseStartedAt(timing);
+            const originalCode = await readServerSourceFile(matched.route.file, options.serverModuleCacheVersion, options.serverSourceFiles);
+            finishRenderTimingPhase(timing, phaseStartedAt, "readSourceMs");
+            phaseStartedAt = renderTimingPhaseStartedAt(timing);
+            const originalAnalysis = await analyzeRouteSource({
                 appDir: options.appDir,
-                buildRenderCode: preparedActions.htmlReplacements !== undefined,
-                code,
+                artifact: options.serverModules?.get(matched.route.file)?.analysis,
+                code: originalCode,
                 filename: matched.route.file,
                 routePath: matched.route.path,
                 clientRouteInferenceCache,
-                serverModuleCacheVersion: undefined,
+                serverModuleCacheVersion: options.serverModuleCacheVersion,
                 serverSourceFiles: options.serverSourceFiles,
                 define: options.define,
+                timing,
                 vitePlugins: options.vitePlugins,
             });
-        finishRenderTimingPhase(timing, phaseStartedAt, "routeCodeAnalysisMs");
-        const routeCode = routeAnalysis.routeCode;
-        const streamRoute = routeAnalysis.streamRoute;
-        const clientInference = routeAnalysis.clientInference;
-        const clientRoute = clientInference.client;
-        phaseStartedAt = renderTimingPhaseStartedAt(timing);
-        const loaderReady = routeAnalysis.hasLoader ? createDeferredSignal() : undefined;
-        const dataPromise = routeAnalysis.hasLoader
-            ? loadRouteDataWithInstrumentation({
-                appDir: options.appDir,
-                code: originalCode,
-                context: {
-                    env: options.env,
-                    params: matched.params,
-                    queryClient,
+            finishRenderTimingPhase(timing, phaseStartedAt, "sourceAnalysisMs");
+            const cachePolicy = originalAnalysis.cachePolicy;
+            const navigationScript = options.navigationScripts?.get(matched.route.path);
+            const cacheKey = routeCacheKey(options.appDir, matched.route.path, url);
+            const mayUseRouteCache = cachePolicy === undefined
+                ? originalAnalysis.usesRuntimeCacheControl
+                : cachePolicy.revalidateSeconds !== 0;
+            const reloadRouteCache = isNavigationRouteCacheReloadRequest(options.request);
+            phaseStartedAt = renderTimingPhaseStartedAt(timing);
+            const cachedResponse = !mayUseRouteCache || reloadRouteCache
+                ? undefined
+                : await cachedRouteResponse({
+                    cache: options.routeCache,
+                    key: cacheKey,
                     request: options.request,
-                },
-                filename: matched.route.file,
-                importPolicy: options.importPolicy,
-                instrumentation: options.instrumentation,
-                devServerModuleCacheVersion: options.devServerModuleCacheVersion,
-                request: options.request,
-                routeId: routeIdForPath(matched.route.path),
-                routePath: matched.route.path,
-                serverModules: options.serverModules,
-                serverModuleCacheVersion: options.serverModuleCacheVersion,
-                define: options.define,
-                vitePlugins: options.vitePlugins,
-                timing,
-                onLoaderReady: loaderReady?.resolve,
-            })
-            : undefined;
-        finishRenderTimingPhase(timing, phaseStartedAt, "loaderStartMs");
-        recoveryRoute = {
-            clientRoute,
-            props: {
-                params: matched.params,
-                request: { url: options.request.url },
-            },
-            routePath: matched.route.path,
-            script: clientScript,
-        };
-        if (streamRoute) {
+                });
+            finishRenderTimingPhase(timing, phaseStartedAt, "routeCacheMs");
+            if (cachedResponse !== undefined) {
+                return cachedResponse;
+            }
             phaseStartedAt = renderTimingPhaseStartedAt(timing);
-            const loadingFile = await nearestExistingBoundaryFileForPage({
+            const preparedActions = await prepareRouteServerActions({
                 appDir: options.appDir,
-                filename: "loading.mreact.tsx",
+                code: originalCode,
+                formActionReferences: options.serverActionReferencesByFile?.get(matched.route.file),
+                placeholders: true,
                 pageFile: matched.route.file,
-                serverSourceFiles: options.serverSourceFiles,
+                request: options.request,
             });
-            finishRenderTimingPhase(timing, phaseStartedAt, "loadingBoundaryLookupMs");
-            const streamShellResponseHeaders = {
-                "content-type": "text/html; charset=utf-8",
-                "x-mreact-stream": "1",
-            };
+            for (const diagnostic of preparedActions.diagnostics ?? []) {
+                console.warn(`${diagnostic.code}: ${diagnostic.message}`);
+            }
+            finishRenderTimingPhase(timing, phaseStartedAt, "serverActionsMs");
+            const code = preparedActions.code;
             phaseStartedAt = renderTimingPhaseStartedAt(timing);
-            const mayRenderOutOfOrder = await mayRenderOutOfOrderBoundaryDeep({
-                code: routeCode,
-                filename: matched.route.file,
-                serverModuleCacheVersion: options.serverModuleCacheVersion,
-                serverSourceFiles: options.serverSourceFiles,
-            });
-            finishRenderTimingPhase(timing, phaseStartedAt, "outOfOrderAnalysisMs");
-            if (loadingFile === undefined && !mayRenderOutOfOrder) {
+            const routeAnalysis = code === originalCode
+                ? originalAnalysis
+                : await analyzeRouteSource({
+                    appDir: options.appDir,
+                    buildRenderCode: preparedActions.htmlReplacements !== undefined,
+                    code,
+                    filename: matched.route.file,
+                    routePath: matched.route.path,
+                    clientRouteInferenceCache,
+                    serverModuleCacheVersion: undefined,
+                    serverSourceFiles: options.serverSourceFiles,
+                    define: options.define,
+                    vitePlugins: options.vitePlugins,
+                });
+            finishRenderTimingPhase(timing, phaseStartedAt, "routeCodeAnalysisMs");
+            const routeCode = routeAnalysis.routeCode;
+            const streamRoute = routeAnalysis.streamRoute;
+            const clientInference = routeAnalysis.clientInference;
+            const clientRoute = clientInference.client;
+            phaseStartedAt = renderTimingPhaseStartedAt(timing);
+            const loaderReady = routeAnalysis.hasLoader ? createDeferredSignal() : undefined;
+            const dataPromise = routeAnalysis.hasLoader
+                ? loadRouteDataWithInstrumentation({
+                    appDir: options.appDir,
+                    code: originalCode,
+                    context: {
+                        env: options.env,
+                        params: matched.params,
+                        queryClient,
+                        request: options.request,
+                    },
+                    filename: matched.route.file,
+                    importPolicy: options.importPolicy,
+                    instrumentation: options.instrumentation,
+                    devServerModuleCacheVersion: options.devServerModuleCacheVersion,
+                    request: options.request,
+                    routeId: routeIdForPath(matched.route.path),
+                    routePath: matched.route.path,
+                    serverModules: options.serverModules,
+                    serverModuleCacheVersion: options.serverModuleCacheVersion,
+                    define: options.define,
+                    vitePlugins: options.vitePlugins,
+                    timing,
+                    onLoaderReady: loaderReady?.resolve,
+                })
+                : undefined;
+            finishRenderTimingPhase(timing, phaseStartedAt, "loaderStartMs");
+            recoveryRoute = {
+                clientRoute,
+                props: {
+                    params: matched.params,
+                    request: { url: options.request.url },
+                },
+                routePath: matched.route.path,
+                script: clientScript,
+            };
+            if (streamRoute) {
+                phaseStartedAt = renderTimingPhaseStartedAt(timing);
+                const loadingFile = await nearestExistingBoundaryFileForPage({
+                    appDir: options.appDir,
+                    filename: "loading.mreact.tsx",
+                    pageFile: matched.route.file,
+                    serverSourceFiles: options.serverSourceFiles,
+                });
+                finishRenderTimingPhase(timing, phaseStartedAt, "loadingBoundaryLookupMs");
+                const streamShellResponseHeaders = {
+                    "content-type": "text/html; charset=utf-8",
+                    "x-mreact-stream": "1",
+                };
                 phaseStartedAt = renderTimingPhaseStartedAt(timing);
-                let data;
-                try {
-                    data = dataPromise === undefined ? undefined : await dataPromise;
+                const mayRenderOutOfOrder = await mayRenderOutOfOrderBoundaryDeep({
+                    code: routeCode,
+                    filename: matched.route.file,
+                    serverModuleCacheVersion: options.serverModuleCacheVersion,
+                    serverSourceFiles: options.serverSourceFiles,
+                });
+                finishRenderTimingPhase(timing, phaseStartedAt, "outOfOrderAnalysisMs");
+                if (loadingFile === undefined && !mayRenderOutOfOrder) {
+                    phaseStartedAt = renderTimingPhaseStartedAt(timing);
+                    let data;
+                    try {
+                        data = dataPromise === undefined ? undefined : await dataPromise;
+                    }
+                    finally {
+                        finishRenderTimingPhase(timing, phaseStartedAt, "loaderWaitMs");
+                    }
+                    if (data instanceof Response) {
+                        emitRenderTiming(options, timing, data.status);
+                        return data;
+                    }
+                    await waitForRenderPreload(options, timing);
+                    await loadServerRenderArtifacts(options, matched.route.file, timing);
+                    phaseStartedAt = renderTimingPhaseStartedAt(timing);
+                    const stringOutput = transformServerModule({
+                        code: routeCode,
+                        clientBoundaryImports: clientInference.clientBoundaryImports,
+                        clientBoundaryFallbackImports: clientInference.clientBoundaryFallbackImports,
+                        filename: matched.route.file,
+                        serverModules: options.serverModules,
+                        serverOutput: "string",
+                    });
+                    finishRenderTimingPhase(timing, phaseStartedAt, "stringTransformMs");
+                    const stringFatalDiagnostics = fatalServerDiagnostics(stringOutput.diagnostics);
+                    if (stringFatalDiagnostics.length > 0) {
+                        return new Response(formatServerDiagnostics(matched.route.file, stringFatalDiagnostics), {
+                            status: 500,
+                            headers: { "content-type": "text/plain; charset=utf-8" },
+                        });
+                    }
+                    const renderedPage = await runWithQueryClient(queryClient, () => runServerModuleWithSlots(stringOutput.code, {
+                        data,
+                        params: matched.params,
+                        queryClient,
+                        request: options.request,
+                    }, matched.route.file, options.serverModules, options.serverModuleCacheVersion, options.define, options.vitePlugins, undefined, options.importPolicy, options.devServerModuleCacheVersion));
+                    const pageHtml = renderedPage.html;
+                    const pageHtmlForLayout = clientRoute
+                        ? withHydrationMarkers({
+                            assetBaseUrl: options.assetBaseUrl,
+                            clientReferenceManifest: stringOutput.metadata.clientReferenceManifest,
+                            html: pageHtml,
+                            routePath: matched.route.path,
+                            script: clientScript,
+                            props: {
+                                params: matched.params,
+                                request: { url: options.request.url },
+                                data,
+                            },
+                        })
+                        : isNavigationRequest(options.request)
+                            ? withRouteMarkers({
+                                html: pageHtml,
+                                routePath: matched.route.path,
+                            })
+                            : pageHtml;
+                    let html = await runWithQueryClient(queryClient, () => applyLayouts({
+                        appDir: options.appDir,
+                        pageFile: matched.route.file,
+                        html: pageHtmlForLayout,
+                        props: {
+                            data,
+                            params: matched.params,
+                            queryClient,
+                            request: options.request,
+                        },
+                        slots: renderedPage.slots,
+                        serverModules: options.serverModules,
+                        serverModuleCacheVersion: options.serverModuleCacheVersion,
+                        serverSourceFiles: options.serverSourceFiles,
+                        clientRouteInferenceCache,
+                        timing,
+                        vitePlugins: options.vitePlugins,
+                        importPolicy: options.importPolicy,
+                    }));
+                    const metadata = await loadComposedRouteMetadata({
+                        appDir: options.appDir,
+                        code: originalCode,
+                        context: {
+                            data,
+                            params: matched.params,
+                            request: options.request,
+                        },
+                        filename: matched.route.file,
+                        importPolicy: options.importPolicy,
+                        routes,
+                        serverModules: options.serverModules,
+                        serverModuleCacheVersion: options.serverModuleCacheVersion,
+                        devServerModuleCacheVersion: options.devServerModuleCacheVersion,
+                        serverSourceFiles: options.serverSourceFiles,
+                        define: options.define,
+                        vitePlugins: options.vitePlugins,
+                    });
+                    html = injectHeadMetadata(html, metadata);
+                    warnIfCspNonceWouldBlockInlineTags({
+                        html,
+                        logger: options.logger,
+                        metadata,
+                        request: options.request,
+                        serverModuleCacheVersion: options.serverModuleCacheVersion,
+                    });
+                    html = injectAuthSessionClaims(html, originalAnalysis.authIncludesClaims ? currentAuthClaims() : undefined);
+                    html = injectQueryState(html, dehydrate(queryClient));
+                    const response = withOptionalActionCookie(htmlResponse(applyActionHtmlReplacements(`<!DOCTYPE html>${clientNavigationHeadTags({
+                        assetBaseUrl: options.assetBaseUrl,
+                        currentStyleSheets: clientStyleSheets,
+                        currentScript: clientRoute ? clientScript : undefined,
+                        currentNavigationScript: navigationScript,
+                        routeScripts: options.clientScripts,
+                    })}${html}`, preparedActions.htmlReplacements), {
+                        headers: responseHeadersForMetadata(metadata, options.request, {
+                            "x-mreact-stream": "1",
+                        }),
+                    }), preparedActions.csrfToken, preparedActions.csrfTokenIsNew === true);
+                    emitRenderTiming(options, timing, response.status);
+                    return response;
                 }
-                finally {
-                    finishRenderTimingPhase(timing, phaseStartedAt, "loaderWaitMs");
+                let streamData;
+                let streamDataPromise = dataPromise ?? Promise.resolve(undefined);
+                phaseStartedAt = renderTimingPhaseStartedAt(timing);
+                if (loadingFile === undefined || routeLoaderMayReturnControlResponse(originalCode)) {
+                    try {
+                        streamData = dataPromise === undefined ? undefined : await dataPromise;
+                    }
+                    finally {
+                        finishRenderTimingPhase(timing, phaseStartedAt, "loaderWaitMs");
+                    }
+                    if (streamData instanceof Response) {
+                        emitRenderTiming(options, timing, streamData.status);
+                        return streamData;
+                    }
+                    streamDataPromise = Promise.resolve(streamData);
                 }
-                if (data instanceof Response) {
-                    emitRenderTiming(options, timing, data.status);
-                    return data;
+                else {
+                    try {
+                        const settledData = await readSettledPromiseAtNextTask(streamDataPromise);
+                        if (settledData.settled) {
+                            if (settledData.value instanceof Response) {
+                                emitRenderTiming(options, timing, settledData.value.status);
+                                return settledData.value;
+                            }
+                            streamDataPromise = Promise.resolve(settledData.value);
+                        }
+                        else {
+                            await waitForLoaderReadyOrSettled(streamDataPromise, loaderReady?.promise);
+                        }
+                    }
+                    finally {
+                        finishRenderTimingPhase(timing, phaseStartedAt, "loaderWaitMs");
+                    }
                 }
                 await waitForRenderPreload(options, timing);
                 await loadServerRenderArtifacts(options, matched.route.file, timing);
                 phaseStartedAt = renderTimingPhaseStartedAt(timing);
-                const stringOutput = transformServerModule({
+                const output = transformServerModule({
                     code: routeCode,
                     clientBoundaryImports: clientInference.clientBoundaryImports,
                     clientBoundaryFallbackImports: clientInference.clientBoundaryFallbackImports,
                     filename: matched.route.file,
                     serverModules: options.serverModules,
-                    serverOutput: "string",
+                    serverOutput: "stream",
+                    serverAwaitHydration: clientRoute,
                 });
-                finishRenderTimingPhase(timing, phaseStartedAt, "stringTransformMs");
-                const stringFatalDiagnostics = fatalServerDiagnostics(stringOutput.diagnostics);
-                if (stringFatalDiagnostics.length > 0) {
-                    return new Response(formatServerDiagnostics(matched.route.file, stringFatalDiagnostics), {
+                finishRenderTimingPhase(timing, phaseStartedAt, "streamTransformMs");
+                const fatalDiagnostics = fatalServerDiagnostics(output.diagnostics);
+                if (fatalDiagnostics.length > 0) {
+                    return new Response(formatServerDiagnostics(matched.route.file, fatalDiagnostics), {
                         status: 500,
                         headers: { "content-type": "text/plain; charset=utf-8" },
                     });
                 }
-                const renderedPage = await runWithQueryClient(queryClient, () => runServerModuleWithSlots(stringOutput.code, {
+                if (loadingFile !== undefined) {
+                    phaseStartedAt = renderTimingPhaseStartedAt(timing);
+                    const stream = await runServerStreamModuleWithLoading(output.code, {
+                        appDir: options.appDir,
+                        assetBaseUrl: options.assetBaseUrl,
+                        clientRoute,
+                        data: streamDataPromise,
+                        define: options.define,
+                        loadingFile,
+                        pageFile: matched.route.file,
+                        params: matched.params,
+                        queryClient,
+                        request: options.request,
+                        routePath: matched.route.path,
+                        routeScripts: options.clientScripts,
+                        serverModules: options.serverModules,
+                        serverModuleCacheVersion: options.serverModuleCacheVersion,
+                        serverSourceFiles: options.serverSourceFiles,
+                        vitePlugins: options.vitePlugins,
+                        clientRouteInferenceCache,
+                        importPolicy: options.importPolicy,
+                        script: clientScript,
+                        clientReferenceManifest: output.metadata.clientReferenceManifest,
+                    });
+                    finishRenderTimingPhase(timing, phaseStartedAt, "streamConstructionMs");
+                    const response = withOptionalActionCookie(new Response(stream, {
+                        headers: streamShellResponseHeaders,
+                    }), preparedActions.csrfToken, preparedActions.csrfTokenIsNew === true);
+                    emitRenderTiming(options, timing, response.status);
+                    return response;
+                }
+                const data = streamData;
+                const props = {
                     data,
                     params: matched.params,
                     queryClient,
                     request: options.request,
-                }, matched.route.file, options.serverModules, options.serverModuleCacheVersion, options.define, options.vitePlugins, undefined, options.importPolicy, options.devServerModuleCacheVersion));
-                const pageHtml = renderedPage.html;
-                const pageHtmlForLayout = clientRoute
-                    ? withHydrationMarkers({
-                        assetBaseUrl: options.assetBaseUrl,
-                        clientReferenceManifest: stringOutput.metadata.clientReferenceManifest,
-                        html: pageHtml,
-                        routePath: matched.route.path,
-                        script: clientScript,
-                        props: {
-                            params: matched.params,
-                            request: { url: options.request.url },
-                            data,
-                        },
-                    })
-                    : isNavigationRequest(options.request)
-                        ? withRouteMarkers({
-                            html: pageHtml,
-                            routePath: matched.route.path,
-                        })
-                        : pageHtml;
-                let html = await runWithQueryClient(queryClient, () => applyLayouts({
+                };
+                phaseStartedAt = renderTimingPhaseStartedAt(timing);
+                const stream = runServerStreamModule(output.code, {
                     appDir: options.appDir,
+                    assetBaseUrl: options.assetBaseUrl,
                     pageFile: matched.route.file,
-                    html: pageHtmlForLayout,
-                    props: {
-                        data,
-                        params: matched.params,
-                        queryClient,
-                        request: options.request,
-                    },
-                    slots: renderedPage.slots,
-                    serverModules: options.serverModules,
-                    serverModuleCacheVersion: options.serverModuleCacheVersion,
-                    serverSourceFiles: options.serverSourceFiles,
-                    clientRouteInferenceCache,
-                    timing,
-                    vitePlugins: options.vitePlugins,
-                    importPolicy: options.importPolicy,
-                }));
-                const metadata = await loadComposedRouteMetadata({
-                    appDir: options.appDir,
-                    code: originalCode,
-                    context: {
-                        data,
-                        params: matched.params,
-                        request: options.request,
-                    },
-                    filename: matched.route.file,
-                    importPolicy: options.importPolicy,
-                    routes,
+                    props,
+                    routePath: matched.route.path,
+                    routeScripts: options.clientScripts,
                     serverModules: options.serverModules,
                     serverModuleCacheVersion: options.serverModuleCacheVersion,
-                    devServerModuleCacheVersion: options.devServerModuleCacheVersion,
                     serverSourceFiles: options.serverSourceFiles,
                     define: options.define,
                     vitePlugins: options.vitePlugins,
+                    clientRouteInferenceCache,
+                    importPolicy: options.importPolicy,
+                    clientRoute,
+                    script: clientScript,
+                    clientReferenceManifest: output.metadata.clientReferenceManifest,
                 });
-                html = injectHeadMetadata(html, metadata);
-                warnIfCspNonceWouldBlockInlineTags({
-                    html,
-                    logger: options.logger,
-                    metadata,
-                    request: options.request,
-                    serverModuleCacheVersion: options.serverModuleCacheVersion,
-                });
-                html = injectAuthSessionClaims(html, originalAnalysis.authIncludesClaims ? currentAuthClaims() : undefined);
-                html = injectQueryState(html, dehydrate(queryClient));
-                const response = withOptionalActionCookie(htmlResponse(applyActionHtmlReplacements(`<!DOCTYPE html>${clientNavigationHeadTags({
-                    assetBaseUrl: options.assetBaseUrl,
-                    currentStyleSheets: clientStyleSheets,
-                    currentScript: clientRoute ? clientScript : undefined,
-                    currentNavigationScript: navigationScript,
-                    routeScripts: options.clientScripts,
-                })}${html}`, preparedActions.htmlReplacements), {
-                    headers: responseHeadersForMetadata(metadata, options.request, {
-                        "x-mreact-stream": "1",
-                    }),
+                finishRenderTimingPhase(timing, phaseStartedAt, "streamConstructionMs");
+                const response = withOptionalActionCookie(new Response(stream, {
+                    headers: streamShellResponseHeaders,
                 }), preparedActions.csrfToken, preparedActions.csrfTokenIsNew === true);
                 emitRenderTiming(options, timing, response.status);
                 return response;
             }
-            let streamData;
-            let streamDataPromise = dataPromise ?? Promise.resolve(undefined);
             phaseStartedAt = renderTimingPhaseStartedAt(timing);
-            if (loadingFile === undefined || routeLoaderMayReturnControlResponse(originalCode)) {
-                try {
-                    streamData = dataPromise === undefined ? undefined : await dataPromise;
-                }
-                finally {
-                    finishRenderTimingPhase(timing, phaseStartedAt, "loaderWaitMs");
-                }
-                if (streamData instanceof Response) {
-                    emitRenderTiming(options, timing, streamData.status);
-                    return streamData;
-                }
-                streamDataPromise = Promise.resolve(streamData);
+            let data;
+            try {
+                data = dataPromise === undefined ? undefined : await dataPromise;
             }
-            else {
-                try {
-                    const settledData = await readSettledPromiseAtNextTask(streamDataPromise);
-                    if (settledData.settled) {
-                        if (settledData.value instanceof Response) {
-                            emitRenderTiming(options, timing, settledData.value.status);
-                            return settledData.value;
-                        }
-                        streamDataPromise = Promise.resolve(settledData.value);
-                    }
-                    else {
-                        await waitForLoaderReadyOrSettled(streamDataPromise, loaderReady?.promise);
-                    }
-                }
-                finally {
-                    finishRenderTimingPhase(timing, phaseStartedAt, "loaderWaitMs");
-                }
+            finally {
+                finishRenderTimingPhase(timing, phaseStartedAt, "loaderWaitMs");
+            }
+            if (data instanceof Response) {
+                emitRenderTiming(options, timing, data.status);
+                return data;
             }
             await waitForRenderPreload(options, timing);
             await loadServerRenderArtifacts(options, matched.route.file, timing);
@@ -828,10 +923,9 @@ async function renderAppRequestInternal(options) {
                 clientBoundaryFallbackImports: clientInference.clientBoundaryFallbackImports,
                 filename: matched.route.file,
                 serverModules: options.serverModules,
-                serverOutput: "stream",
-                serverAwaitHydration: clientRoute,
+                serverOutput: "string",
             });
-            finishRenderTimingPhase(timing, phaseStartedAt, "streamTransformMs");
+            finishRenderTimingPhase(timing, phaseStartedAt, "stringTransformMs");
             const fatalDiagnostics = fatalServerDiagnostics(output.diagnostics);
             if (fatalDiagnostics.length > 0) {
                 return new Response(formatServerDiagnostics(matched.route.file, fatalDiagnostics), {
@@ -839,273 +933,176 @@ async function renderAppRequestInternal(options) {
                     headers: { "content-type": "text/plain; charset=utf-8" },
                 });
             }
-            if (loadingFile !== undefined) {
-                phaseStartedAt = renderTimingPhaseStartedAt(timing);
-                const stream = await runServerStreamModuleWithLoading(output.code, {
-                    appDir: options.appDir,
-                    assetBaseUrl: options.assetBaseUrl,
-                    clientRoute,
-                    data: streamDataPromise,
-                    define: options.define,
-                    loadingFile,
-                    pageFile: matched.route.file,
-                    params: matched.params,
-                    queryClient,
-                    request: options.request,
-                    routePath: matched.route.path,
-                    routeScripts: options.clientScripts,
-                    serverModules: options.serverModules,
-                    serverModuleCacheVersion: options.serverModuleCacheVersion,
-                    serverSourceFiles: options.serverSourceFiles,
-                    vitePlugins: options.vitePlugins,
-                    clientRouteInferenceCache,
-                    importPolicy: options.importPolicy,
-                    script: clientScript,
-                    clientReferenceManifest: output.metadata.clientReferenceManifest,
-                });
-                finishRenderTimingPhase(timing, phaseStartedAt, "streamConstructionMs");
-                const response = withOptionalActionCookie(new Response(stream, {
-                    headers: streamShellResponseHeaders,
-                }), preparedActions.csrfToken, preparedActions.csrfTokenIsNew === true);
-                emitRenderTiming(options, timing, response.status);
-                return response;
-            }
-            const data = streamData;
-            const props = {
+            phaseStartedAt = renderTimingPhaseStartedAt(timing);
+            const renderedPage = await runWithQueryClient(queryClient, () => runServerModuleWithSlots(output.code, {
                 data,
                 params: matched.params,
                 queryClient,
                 request: options.request,
-            };
+            }, matched.route.file, options.serverModules, options.serverModuleCacheVersion, options.define, options.vitePlugins, timing, options.importPolicy, options.devServerModuleCacheVersion));
+            finishRenderTimingPhase(timing, phaseStartedAt, "pageRenderMs");
+            const pageHtml = renderedPage.html;
+            // Wrap the page (not the full document) with the hydration marker so
+            // the marker sits inside <body>, not around <html>. Wrapping <html>
+            // forces the browser HTML parser to strip the wrappers and promote
+            // <head> / <body> children up to the marker, which flattens the
+            // layout into the marker and breaks the hydration target lookup.
+            const pageHtmlForLayout = clientRoute
+                ? withHydrationMarkers({
+                    assetBaseUrl: options.assetBaseUrl,
+                    clientReferenceManifest: output.metadata.clientReferenceManifest,
+                    html: pageHtml,
+                    routePath: matched.route.path,
+                    script: clientScript,
+                    props: {
+                        params: matched.params,
+                        request: { url: options.request.url },
+                        data,
+                    },
+                })
+                : isNavigationRequest(options.request)
+                    ? withRouteMarkers({
+                        html: pageHtml,
+                        routePath: matched.route.path,
+                    })
+                    : pageHtml;
             phaseStartedAt = renderTimingPhaseStartedAt(timing);
-            const stream = runServerStreamModule(output.code, {
+            let html = await runWithQueryClient(queryClient, () => applyLayouts({
                 appDir: options.appDir,
-                assetBaseUrl: options.assetBaseUrl,
                 pageFile: matched.route.file,
-                props,
-                routePath: matched.route.path,
-                routeScripts: options.clientScripts,
+                html: pageHtmlForLayout,
+                props: {
+                    data,
+                    params: matched.params,
+                    queryClient,
+                    request: options.request,
+                },
+                slots: renderedPage.slots,
                 serverModules: options.serverModules,
                 serverModuleCacheVersion: options.serverModuleCacheVersion,
                 serverSourceFiles: options.serverSourceFiles,
-                define: options.define,
-                vitePlugins: options.vitePlugins,
                 clientRouteInferenceCache,
-                importPolicy: options.importPolicy,
-                clientRoute,
-                script: clientScript,
-                clientReferenceManifest: output.metadata.clientReferenceManifest,
-            });
-            finishRenderTimingPhase(timing, phaseStartedAt, "streamConstructionMs");
-            const response = withOptionalActionCookie(new Response(stream, {
-                headers: streamShellResponseHeaders,
-            }), preparedActions.csrfToken, preparedActions.csrfTokenIsNew === true);
-            emitRenderTiming(options, timing, response.status);
-            return response;
-        }
-        phaseStartedAt = renderTimingPhaseStartedAt(timing);
-        let data;
-        try {
-            data = dataPromise === undefined ? undefined : await dataPromise;
-        }
-        finally {
-            finishRenderTimingPhase(timing, phaseStartedAt, "loaderWaitMs");
-        }
-        if (data instanceof Response) {
-            emitRenderTiming(options, timing, data.status);
-            return data;
-        }
-        await waitForRenderPreload(options, timing);
-        await loadServerRenderArtifacts(options, matched.route.file, timing);
-        phaseStartedAt = renderTimingPhaseStartedAt(timing);
-        const output = transformServerModule({
-            code: routeCode,
-            clientBoundaryImports: clientInference.clientBoundaryImports,
-            clientBoundaryFallbackImports: clientInference.clientBoundaryFallbackImports,
-            filename: matched.route.file,
-            serverModules: options.serverModules,
-            serverOutput: "string",
-        });
-        finishRenderTimingPhase(timing, phaseStartedAt, "stringTransformMs");
-        const fatalDiagnostics = fatalServerDiagnostics(output.diagnostics);
-        if (fatalDiagnostics.length > 0) {
-            return new Response(formatServerDiagnostics(matched.route.file, fatalDiagnostics), {
-                status: 500,
-                headers: { "content-type": "text/plain; charset=utf-8" },
-            });
-        }
-        phaseStartedAt = renderTimingPhaseStartedAt(timing);
-        const renderedPage = await runWithQueryClient(queryClient, () => runServerModuleWithSlots(output.code, {
-            data,
-            params: matched.params,
-            queryClient,
-            request: options.request,
-        }, matched.route.file, options.serverModules, options.serverModuleCacheVersion, options.define, options.vitePlugins, timing, options.importPolicy, options.devServerModuleCacheVersion));
-        finishRenderTimingPhase(timing, phaseStartedAt, "pageRenderMs");
-        const pageHtml = renderedPage.html;
-        // Wrap the page (not the full document) with the hydration marker so
-        // the marker sits inside <body>, not around <html>. Wrapping <html>
-        // forces the browser HTML parser to strip the wrappers and promote
-        // <head> / <body> children up to the marker, which flattens the
-        // layout into the marker and breaks the hydration target lookup.
-        const pageHtmlForLayout = clientRoute
-            ? withHydrationMarkers({
-                assetBaseUrl: options.assetBaseUrl,
-                clientReferenceManifest: output.metadata.clientReferenceManifest,
-                html: pageHtml,
-                routePath: matched.route.path,
-                script: clientScript,
-                props: {
-                    params: matched.params,
-                    request: { url: options.request.url },
+                timing,
+                vitePlugins: options.vitePlugins,
+            }));
+            finishRenderTimingPhase(timing, phaseStartedAt, "layoutRenderMs");
+            phaseStartedAt = renderTimingPhaseStartedAt(timing);
+            const metadata = await loadComposedRouteMetadata({
+                appDir: options.appDir,
+                code: originalCode,
+                context: {
                     data,
+                    params: matched.params,
+                    request: options.request,
                 },
-            })
-            : isNavigationRequest(options.request)
-                ? withRouteMarkers({
-                    html: pageHtml,
-                    routePath: matched.route.path,
-                })
-                : pageHtml;
-        phaseStartedAt = renderTimingPhaseStartedAt(timing);
-        let html = await runWithQueryClient(queryClient, () => applyLayouts({
-            appDir: options.appDir,
-            pageFile: matched.route.file,
-            html: pageHtmlForLayout,
-            props: {
-                data,
-                params: matched.params,
-                queryClient,
-                request: options.request,
-            },
-            slots: renderedPage.slots,
-            serverModules: options.serverModules,
-            serverModuleCacheVersion: options.serverModuleCacheVersion,
-            serverSourceFiles: options.serverSourceFiles,
-            clientRouteInferenceCache,
-            timing,
-            vitePlugins: options.vitePlugins,
-        }));
-        finishRenderTimingPhase(timing, phaseStartedAt, "layoutRenderMs");
-        phaseStartedAt = renderTimingPhaseStartedAt(timing);
-        const metadata = await loadComposedRouteMetadata({
-            appDir: options.appDir,
-            code: originalCode,
-            context: {
-                data,
-                params: matched.params,
-                request: options.request,
-            },
-            filename: matched.route.file,
-            importPolicy: options.importPolicy,
-            routes,
-            serverModules: options.serverModules,
-            serverModuleCacheVersion: options.serverModuleCacheVersion,
-            devServerModuleCacheVersion: options.devServerModuleCacheVersion,
-            serverSourceFiles: options.serverSourceFiles,
-            define: options.define,
-            vitePlugins: options.vitePlugins,
-        });
-        finishRenderTimingPhase(timing, phaseStartedAt, "metadataMs");
-        phaseStartedAt = renderTimingPhaseStartedAt(timing);
-        html = injectHeadMetadata(html, metadata);
-        warnIfCspNonceWouldBlockInlineTags({
-            html,
-            logger: options.logger,
-            metadata,
-            request: options.request,
-            serverModuleCacheVersion: options.serverModuleCacheVersion,
-        });
-        html = injectAuthSessionClaims(html, originalAnalysis.authIncludesClaims ? currentAuthClaims() : undefined);
-        html = injectQueryState(html, dehydrate(queryClient));
-        const response = withOptionalActionCookie(htmlResponse(applyActionHtmlReplacements(`<!DOCTYPE html>${clientNavigationHeadTags({
-            assetBaseUrl: options.assetBaseUrl,
-            currentStyleSheets: clientStyleSheets,
-            currentScript: clientRoute ? clientScript : undefined,
-            currentNavigationScript: navigationScript,
-            routeScripts: options.clientScripts,
-        })}${html}`, preparedActions.htmlReplacements), {
-            headers: responseHeadersForMetadata(metadata, options.request),
-        }), preparedActions.csrfToken, preparedActions.csrfTokenIsNew === true);
-        const effectiveCachePolicy = cachePolicy ?? routeCacheContext.cachePolicy;
-        const finalResponse = preparedActions.hasFormActions
-            ? withRouteCacheHeader(response, effectiveCachePolicy)
-            : await cacheRouteResponse({
-                key: cacheKey,
-                cache: options.routeCache,
-                path: matched.route.path,
-                policy: effectiveCachePolicy,
-                request: options.request,
-                response,
+                filename: matched.route.file,
+                importPolicy: options.importPolicy,
+                routes,
+                serverModules: options.serverModules,
+                serverModuleCacheVersion: options.serverModuleCacheVersion,
+                devServerModuleCacheVersion: options.devServerModuleCacheVersion,
+                serverSourceFiles: options.serverSourceFiles,
+                define: options.define,
+                vitePlugins: options.vitePlugins,
             });
-        finishRenderTimingPhase(timing, phaseStartedAt, "responseBuildMs");
-        emitRenderTiming(options, timing, finalResponse.status);
-        return finalResponse;
-    }
-    catch (error) {
-        if (isRedirectError(error)) {
-            const response = new Response(null, {
-                headers: { location: error.location },
-                status: error.status,
+            finishRenderTimingPhase(timing, phaseStartedAt, "metadataMs");
+            phaseStartedAt = renderTimingPhaseStartedAt(timing);
+            html = injectHeadMetadata(html, metadata);
+            warnIfCspNonceWouldBlockInlineTags({
+                html,
+                logger: options.logger,
+                metadata,
+                request: options.request,
+                serverModuleCacheVersion: options.serverModuleCacheVersion,
             });
-            emitRenderTiming(options, timing, response.status);
-            return response;
+            html = injectAuthSessionClaims(html, originalAnalysis.authIncludesClaims ? currentAuthClaims() : undefined);
+            html = injectQueryState(html, dehydrate(queryClient));
+            const response = withOptionalActionCookie(htmlResponse(applyActionHtmlReplacements(`<!DOCTYPE html>${clientNavigationHeadTags({
+                assetBaseUrl: options.assetBaseUrl,
+                currentStyleSheets: clientStyleSheets,
+                currentScript: clientRoute ? clientScript : undefined,
+                currentNavigationScript: navigationScript,
+                routeScripts: options.clientScripts,
+            })}${html}`, preparedActions.htmlReplacements), {
+                headers: responseHeadersForMetadata(metadata, options.request),
+            }), preparedActions.csrfToken, preparedActions.csrfTokenIsNew === true);
+            const effectiveCachePolicy = cachePolicy ?? activeRouteCacheContext()?.cachePolicy;
+            const finalResponse = preparedActions.hasFormActions
+                ? withRouteCacheHeader(response, effectiveCachePolicy)
+                : await cacheRouteResponse({
+                    key: cacheKey,
+                    cache: options.routeCache,
+                    path: matched.route.path,
+                    policy: effectiveCachePolicy,
+                    request: options.request,
+                    response,
+                });
+            finishRenderTimingPhase(timing, phaseStartedAt, "responseBuildMs");
+            emitRenderTiming(options, timing, finalResponse.status);
+            return finalResponse;
         }
-        if (isNotFoundError(error)) {
-            const notFoundFile = await nearestBoundaryFileForPage({
+        catch (error) {
+            if (isRedirectError(error)) {
+                const response = new Response(null, {
+                    headers: { location: error.location },
+                    status: error.status,
+                });
+                emitRenderTiming(options, timing, response.status);
+                return response;
+            }
+            if (isNotFoundError(error)) {
+                const notFoundFile = await nearestBoundaryFileForPage({
+                    appDir: options.appDir,
+                    filename: "not-found.mreact.tsx",
+                    pageFile: matched.route.file,
+                });
+                const response = await renderSpecialRoute({
+                    appDir: options.appDir,
+                    assetBaseUrl: options.assetBaseUrl,
+                    currentStyleSheets: options.clientStylesByFile?.get(notFoundFile),
+                    error: undefined,
+                    request: options.request,
+                    routePath: matched.route.path,
+                    routeFile: notFoundFile,
+                    routeScripts: options.clientScripts,
+                    serverModules: options.serverModules,
+                    serverModuleCacheVersion: options.serverModuleCacheVersion,
+                    serverSourceFiles: options.serverSourceFiles,
+                    vitePlugins: options.vitePlugins,
+                    navigation: recoveryRoute,
+                    status: 404,
+                    textFallback: "Not Found",
+                });
+                emitRenderTiming(options, timing, response.status);
+                return response;
+            }
+            const errorFile = await nearestBoundaryFileForPage({
                 appDir: options.appDir,
-                filename: "not-found.mreact.tsx",
+                filename: "error.mreact.tsx",
                 pageFile: matched.route.file,
             });
+            options.onRenderError?.(error);
             const response = await renderSpecialRoute({
                 appDir: options.appDir,
                 assetBaseUrl: options.assetBaseUrl,
-                currentStyleSheets: options.clientStylesByFile?.get(notFoundFile),
-                error: undefined,
+                currentStyleSheets: options.clientStylesByFile?.get(errorFile),
+                error,
                 request: options.request,
                 routePath: matched.route.path,
-                routeFile: notFoundFile,
+                routeFile: errorFile,
                 routeScripts: options.clientScripts,
                 serverModules: options.serverModules,
                 serverModuleCacheVersion: options.serverModuleCacheVersion,
                 serverSourceFiles: options.serverSourceFiles,
                 vitePlugins: options.vitePlugins,
                 navigation: recoveryRoute,
-                status: 404,
-                textFallback: "Not Found",
+                status: 500,
+                textFallback: "Internal Server Error",
             });
             emitRenderTiming(options, timing, response.status);
             return response;
         }
-        const errorFile = await nearestBoundaryFileForPage({
-            appDir: options.appDir,
-            filename: "error.mreact.tsx",
-            pageFile: matched.route.file,
-        });
-        options.onRenderError?.(error);
-        const response = await renderSpecialRoute({
-            appDir: options.appDir,
-            assetBaseUrl: options.assetBaseUrl,
-            currentStyleSheets: options.clientStylesByFile?.get(errorFile),
-            error,
-            request: options.request,
-            routePath: matched.route.path,
-            routeFile: errorFile,
-            routeScripts: options.clientScripts,
-            serverModules: options.serverModules,
-            serverModuleCacheVersion: options.serverModuleCacheVersion,
-            serverSourceFiles: options.serverSourceFiles,
-            vitePlugins: options.vitePlugins,
-            navigation: recoveryRoute,
-            status: 500,
-            textFallback: "Internal Server Error",
-        });
-        emitRenderTiming(options, timing, response.status);
-        return response;
-    }
-    finally {
-        await routeCacheContext?.dispose();
-    }
+    })).value;
 }
 async function applyAppRouterResponseHook(response, options) {
     const hooked = await options.onResponse?.(response, {