@nuxt/nitro-server-nightly 4.5.0-29673761.f253a70d → 4.5.0-29673775.d239dbcd

package/dist/index.d.mts

@@ -2,7 +2,7 @@ import { EventHandler, H3Event } from "h3";
 import { Nuxt } from "@nuxt/schema";
 import { Nitro, NitroConfig, NitroDevEventHandler, NitroEventHandler, NitroOptions, NitroRouteConfig, NitroRuntimeConfig, NitroRuntimeConfigApp } from "nitropack/types";
 import { LogObject } from "consola";
-import { NuxtIslandContext, NuxtIslandResponse, NuxtRenderHTMLContext } from "nuxt/app";
+import { NuxtIslandContext, NuxtIslandResponse, NuxtRenderChunkContext, NuxtRenderCloseContext, NuxtRenderHTMLContext, NuxtRenderRouteContext } from "nuxt/app";
 import { HookResult, RuntimeConfig, TSReference } from "nuxt/schema";
 declare module "nitropack" {
   interface NitroRuntimeConfigApp {
@@ -11,6 +11,7 @@ declare module "nitropack" {
   }
   interface NitroRouteRules {
     ssr?: boolean;
+    streaming?: boolean;
     noScripts?: boolean;
     /** @deprecated Use `noScripts` instead */
     experimentalNoScripts?: boolean;
@@ -25,6 +26,7 @@ declare module "nitropack/types" {
   }
   interface NitroRouteRules {
     ssr?: boolean;
+    streaming?: boolean;
     noScripts?: boolean;
     /** @deprecated Use `noScripts` instead */
     experimentalNoScripts?: boolean;
@@ -36,6 +38,7 @@ declare module "nitropack" {
   interface NitroRuntimeConfig extends RuntimeConfig {}
   interface NitroRouteConfig {
     ssr?: boolean;
+    streaming?: boolean;
     noScripts?: boolean;
     /** @deprecated Use `noScripts` instead */
     experimentalNoScripts?: boolean;
@@ -47,6 +50,16 @@ declare module "nitropack" {
     }) => void | Promise<void>;
     "render:html": (htmlContext: NuxtRenderHTMLContext, context: {
       event: H3Event;
+      streaming?: boolean;
+    }) => void | Promise<void>;
+    "render:html:chunk": (chunkContext: NuxtRenderChunkContext, context: {
+      event: H3Event;
+    }) => void | Promise<void>;
+    "render:html:close": (closeContext: NuxtRenderCloseContext, context: {
+      event: H3Event;
+    }) => void | Promise<void>;
+    "render:route": (renderRouteContext: NuxtRenderRouteContext, context: {
+      event: H3Event;
     }) => void | Promise<void>;
     "render:island": (islandResponse: NuxtIslandResponse, context: {
       event: H3Event;
@@ -58,6 +71,7 @@ declare module "nitropack/types" {
   interface NitroRuntimeConfig extends RuntimeConfig {}
   interface NitroRouteConfig {
     ssr?: boolean;
+    streaming?: boolean;
     noScripts?: boolean;
     /** @deprecated Use `noScripts` instead */
     experimentalNoScripts?: boolean;
@@ -69,6 +83,16 @@ declare module "nitropack/types" {
     }) => void | Promise<void>;
     "render:html": (htmlContext: NuxtRenderHTMLContext, context: {
       event: H3Event;
+      streaming?: boolean;
+    }) => void | Promise<void>;
+    "render:html:chunk": (chunkContext: NuxtRenderChunkContext, context: {
+      event: H3Event;
+    }) => void | Promise<void>;
+    "render:html:close": (closeContext: NuxtRenderCloseContext, context: {
+      event: H3Event;
+    }) => void | Promise<void>;
+    "render:route": (renderRouteContext: NuxtRenderRouteContext, context: {
+      event: H3Event;
     }) => void | Promise<void>;
     "render:island": (islandResponse: NuxtIslandResponse, context: {
       event: H3Event;

package/dist/index.mjs

@@ -21,7 +21,7 @@ import { hasTTY, isCI, isWindows } from "std-env";
 import { ImpoundPlugin } from "impound";
 import { resolveModulePath } from "exsolve";
 import { runtimeDependencies } from "nitropack/runtime/meta";
-var version = "4.5.0-29673761.f253a70d";
+var version = "4.5.0-29673775.d239dbcd";
 function toArray(value) {
 	return Array.isArray(value) ? value : [value];
 }
@@ -106,7 +106,7 @@ ${[...references.map((ref) => renderReference(ref, typesDir)), ...declarations].
 import type { RuntimeConfig } from 'nuxt/schema'
 import type { H3Event } from 'h3'
 import type { LogObject } from 'consola'
-import type { NuxtIslandContext, NuxtIslandResponse, NuxtRenderHTMLContext } from 'nuxt/app'
+import type { NuxtIslandContext, NuxtIslandResponse, NuxtRenderChunkContext, NuxtRenderCloseContext, NuxtRenderHTMLContext, NuxtRenderRouteContext } from 'nuxt/app'
 
 declare module 'nitropack' {
   interface NitroRuntimeConfigApp {
@@ -116,12 +116,14 @@ declare module 'nitropack' {
   interface NitroRuntimeConfig extends RuntimeConfig {}
   interface NitroRouteConfig {
     ssr?: boolean
+    streaming?: boolean
     noScripts?: boolean
     /** @deprecated Use \`noScripts\` instead */
     experimentalNoScripts?: boolean
   }
   interface NitroRouteRules {
     ssr?: boolean
+    streaming?: boolean
     noScripts?: boolean
     /** @deprecated Use \`noScripts\` instead */
     experimentalNoScripts?: boolean
@@ -130,7 +132,10 @@ declare module 'nitropack' {
   }
   interface NitroRuntimeHooks {
     'dev:ssr-logs': (ctx: { logs: LogObject[], path: string }) => void | Promise<void>
-    'render:html': (htmlContext: NuxtRenderHTMLContext, context: { event: H3Event }) => void | Promise<void>
+    'render:html': (htmlContext: NuxtRenderHTMLContext, context: { event: H3Event, streaming?: boolean }) => void | Promise<void>
+    'render:html:chunk': (chunkContext: NuxtRenderChunkContext, context: { event: H3Event }) => void | Promise<void>
+    'render:html:close': (closeContext: NuxtRenderCloseContext, context: { event: H3Event }) => void | Promise<void>
+    'render:route': (renderRouteContext: NuxtRenderRouteContext, context: { event: H3Event }) => void | Promise<void>
     'render:island': (islandResponse: NuxtIslandResponse, context: { event: H3Event, islandContext: NuxtIslandContext }) => void | Promise<void>
   }
 }
@@ -142,12 +147,14 @@ declare module 'nitropack/types' {
   interface NitroRuntimeConfig extends RuntimeConfig {}
   interface NitroRouteConfig {
     ssr?: boolean
+    streaming?: boolean
     noScripts?: boolean
     /** @deprecated Use \`noScripts\` instead */
     experimentalNoScripts?: boolean
   }
   interface NitroRouteRules {
     ssr?: boolean
+    streaming?: boolean
     noScripts?: boolean
     /** @deprecated Use \`noScripts\` instead */
     experimentalNoScripts?: boolean
@@ -156,7 +163,10 @@ declare module 'nitropack/types' {
   }
   interface NitroRuntimeHooks {
     'dev:ssr-logs': (ctx: { logs: LogObject[], path: string }) => void | Promise<void>
-    'render:html': (htmlContext: NuxtRenderHTMLContext, context: { event: H3Event }) => void | Promise<void>
+    'render:html': (htmlContext: NuxtRenderHTMLContext, context: { event: H3Event, streaming?: boolean }) => void | Promise<void>
+    'render:html:chunk': (chunkContext: NuxtRenderChunkContext, context: { event: H3Event }) => void | Promise<void>
+    'render:html:close': (closeContext: NuxtRenderCloseContext, context: { event: H3Event }) => void | Promise<void>
+    'render:route': (renderRouteContext: NuxtRenderRouteContext, context: { event: H3Event }) => void | Promise<void>
     'render:island': (islandResponse: NuxtIslandResponse, context: { event: H3Event, islandContext: NuxtIslandContext }) => void | Promise<void>
   }
 }
@@ -292,6 +302,7 @@ async function bundle(nuxt) {
 			"#internal/nuxt/app-config": () => nuxt.vfs["#build/app.config.mjs"]?.replace(/\/\*\* client \*\*\/[\s\S]*\/\*\* client-end \*\*\//, "") || "",
 			"#spa-template": async () => `export const template = ${JSON.stringify(await spaLoadingTemplate(nuxt))}`,
 			"#internal/entry-chunk.mjs": () => `export const entryFileName = undefined`,
+			"#internal/streaming-iife-chunk.mjs": () => `export const iifeChunkFileName = undefined`,
 			"#internal/nuxt/entry-ids.mjs": () => `export default []`,
 			"#internal/nuxt/nitro-config.mjs": () => {
 				const hasCachedRoutes = Object.values(nitro.options.routeRules).some((r) => r.isr || r.cache);
@@ -306,11 +317,16 @@ async function bundle(nuxt) {
 					`export const NUXT_SHARED_DATA = ${!!nuxt.options.experimental.sharedPrerenderData}`,
 					`export const NUXT_PAYLOAD_EXTRACTION = ${nuxt.options.experimental.payloadExtraction !== false}`,
 					`export const NUXT_PAYLOAD_INLINE = ${nuxt.options.experimental.payloadExtraction !== true}`,
-					`export const NUXT_RUNTIME_PAYLOAD_EXTRACTION = ${hasCachedRoutes}`
+					`export const NUXT_RUNTIME_PAYLOAD_EXTRACTION = ${hasCachedRoutes}`,
+					`export const NUXT_SSR_STREAMING = ${!!(typeof nuxt.options.experimental.ssrStreaming === "object" && nuxt.options.experimental.ssrStreaming.enabled)}`,
+					`export const NUXT_SSR_STREAMING_BOT_RE = ${typeof nuxt.options.experimental.ssrStreaming === "object" && nuxt.options.experimental.ssrStreaming.botRegex instanceof RegExp ? String(nuxt.options.experimental.ssrStreaming.botRegex) : "/^$/"}`
 				].join("\n");
 			}
 		},
-		routeRules: { "/__nuxt_error": { cache: false } },
+		routeRules: {
+			...typeof nuxt.options.experimental.ssrStreaming === "object" && nuxt.options.experimental.ssrStreaming.enabled ? { "/**": { streaming: true } } : {},
+			"/__nuxt_error": { cache: false }
+		},
 		appConfig: nuxt.options.appConfig,
 		appConfigFiles: layerDirs.map((dirs) => join(dirs.app, "app.config")),
 		typescript: {

package/dist/runtime/handlers/renderer.mjs

@@ -1,26 +1,31 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { getPrefetchLinks, getPreloadLinks, getRequestDependencies, renderResourceHeaders } from "vue-bundle-renderer/runtime";
-import { appendResponseHeader, createError, getQuery, getResponseStatus, getResponseStatusText, writeEarlyHints } from "h3";
+import { renderToWebStream } from "vue/server-renderer";
+import { appendResponseHeader, createError, getQuery, getRequestHeader, getResponseStatus, getResponseStatusText, removeResponseHeader, setResponseHeader, writeEarlyHints } from "h3";
 import { getQuery as getURLQuery, joinURL } from "ufo";
 import { propsToString, renderSSRHead } from "@unhead/vue/server";
+import { createBootstrapScript, renderSSRHeadSuspenseChunk, renderShell } from "@unhead/vue/stream/server";
+import { streamingIifeCode } from "@unhead/vue/stream/iife";
 import destr from "destr";
 import { defineRenderHandler, getRouteRules, useNitroApp } from "nitropack/runtime";
-import { getRenderer } from "../utils/renderer/build-files.mjs";
+import { APP_ROOT_CLOSE_TAG, APP_ROOT_OPEN_TAG, getRenderer, getServerApp } from "../utils/renderer/build-files.mjs";
 import { payloadCache, prerenderRenderingURLs } from "../utils/cache.mjs";
 import { renderPayloadJsonScript, renderPayloadResponse, renderPayloadScript, splitPayload } from "../utils/renderer/payload.mjs";
 import { createSSRContext, setSSRError } from "../utils/renderer/app.mjs";
 import { renderInlineStyles } from "../utils/renderer/inline-styles.mjs";
-import { replaceIslandTeleports } from "../utils/renderer/islands.mjs";
+import { renderStreamedIslandTeleports, replaceIslandTeleports } from "../utils/renderer/islands.mjs";
 // @ts-expect-error virtual file
 import { renderSSRHeadOptions } from "#internal/unhead.config.mjs";
 // @ts-expect-error virtual file
-import { NUXT_ASYNC_CONTEXT, NUXT_EARLY_HINTS, NUXT_INLINE_STYLES, NUXT_JSON_PAYLOADS, NUXT_NO_SCRIPTS, NUXT_PAYLOAD_EXTRACTION, NUXT_PAYLOAD_INLINE, NUXT_RUNTIME_PAYLOAD_EXTRACTION, PARSE_ERROR_DATA } from "#internal/nuxt/nitro-config.mjs";
+import { NUXT_ASYNC_CONTEXT, NUXT_EARLY_HINTS, NUXT_INLINE_STYLES, NUXT_JSON_PAYLOADS, NUXT_NO_SCRIPTS, NUXT_PAYLOAD_EXTRACTION, NUXT_PAYLOAD_INLINE, NUXT_RUNTIME_PAYLOAD_EXTRACTION, NUXT_SSR_STREAMING, NUXT_SSR_STREAMING_BOT_RE, PARSE_ERROR_DATA } from "#internal/nuxt/nitro-config.mjs";
 // @ts-expect-error virtual file
-import { appHead, appTeleportAttrs, appTeleportTag, componentIslands } from "#internal/nuxt.config.mjs";
+import { appHead, appTeleportAttrs, appTeleportTag, componentIslands, componentIslandsActive } from "#internal/nuxt.config.mjs";
 // @ts-expect-error virtual file
 import entryIds from "#internal/nuxt/entry-ids.mjs";
 // @ts-expect-error virtual file
 import { entryFileName } from "#internal/entry-chunk.mjs";
+// @ts-expect-error virtual file
+import { iifeChunkFileName } from "#internal/streaming-iife-chunk.mjs";
 import { buildAssetsURL, publicAssetsURL } from "../utils/paths.mjs";
 import { relative } from "pathe";
 // @ts-expect-error private property consumed by vite-generated url helpers
@@ -37,6 +42,8 @@ const APP_TELEPORT_CLOSE_TAG = HAS_APP_TELEPORTS ? `</${appTeleportTag}>` : "";
 const PAYLOAD_URL_RE = NUXT_JSON_PAYLOADS ? /^[^?]*\/_payload.json(?:\?.*)?$/ : /^[^?]*\/_payload.js(?:\?.*)?$/;
 const PAYLOAD_FILENAME = NUXT_JSON_PAYLOADS ? "_payload.json" : "_payload.js";
 let entryPath;
+
+const SSR_BOT_RE = NUXT_SSR_STREAMING_BOT_RE;
 const handler = defineRenderHandler((event) => {
 	
 	const ssrError = event.path.startsWith("/__nuxt_error") ? getQuery(event) : null;
@@ -119,6 +126,27 @@ async function renderRoute(event, ssrError) {
 			ssrContext.modules.add(id);
 		}
 	}
+	
+	
+	
+	const canStream = NUXT_SSR_STREAMING && !ssrContext.noSSR && !ssrError && !isRenderingPayload && !import.meta.prerender && !(NUXT_NO_SCRIPTS && componentIslandsActive) && !routeOptions.noScripts && !!routeOptions.streaming && !routeOptions.cache && !routeOptions.isr && !routeOptions.redirect;
+	const renderRouteContext = {
+		canStream,
+		prefersStream: !!(NUXT_SSR_STREAMING && !SSR_BOT_RE.test(getRequestHeader(event, "user-agent") || ""))
+	};
+	await nitroApp.hooks.callHook("render:route", renderRouteContext, { event });
+	if (NUXT_SSR_STREAMING && canStream && renderRouteContext.prefersStream) {
+		return renderStreamedResponse({
+			event,
+			ssrContext,
+			renderer,
+			routeOptions,
+			ssrError,
+			_PAYLOAD_EXTRACTION,
+			_PAYLOAD_INLINE,
+			payloadURL
+		});
+	}
 	const _rendered = await renderer.renderToString(ssrContext).catch(async (error) => {
 		
 		
@@ -299,6 +327,439 @@ async function renderRoute(event, ssrError) {
 	};
 }
 export default handler;
+async function renderStreamedResponse(ctx) {
+	const { event, ssrContext, renderer, routeOptions, ssrError, _PAYLOAD_EXTRACTION, _PAYLOAD_INLINE, payloadURL } = ctx;
+	const nitroApp = useNitroApp();
+	const NO_SCRIPTS = NUXT_NO_SCRIPTS || !!routeOptions?.noScripts;
+	
+	const { link: linkHeader } = renderResourceHeaders({}, renderer.rendererContext);
+	if (linkHeader) {
+		appendResponseHeader(event, "link", linkHeader);
+	}
+	
+	const entryInlineStyles = NUXT_INLINE_STYLES ? await renderInlineStyles(new Set(entryIds)) : [];
+	
+	if (entryInlineStyles.length) {
+		ssrContext.head.push({ style: entryInlineStyles });
+	}
+	
+	const { styles: entryStyles, scripts: entryScripts } = getRequestDependencies({}, renderer.rendererContext);
+	const shellLinks = [];
+	for (const resource of Object.values(entryStyles)) {
+		if (import.meta.dev && "inline" in getURLQuery(resource.file)) {
+			continue;
+		}
+		shellLinks.push({
+			rel: "stylesheet",
+			href: renderer.rendererContext.buildAssetsURL(resource.file),
+			crossorigin: ""
+		});
+	}
+	if (shellLinks.length) {
+		ssrContext.head.push({ link: shellLinks });
+	}
+	
+	if (entryFileName && !NO_SCRIPTS) {
+		let path = entryPath;
+		if (!path) {
+			path = buildAssetsURL(entryFileName);
+			if (ssrContext.runtimeConfig.app.cdnURL || /^(?:\/|\.+\/)/.test(path)) {
+				entryPath = path;
+			} else {
+				path = relative(event.path.replace(/\/[^/]+$/, "/"), joinURL("/", path));
+				if (!/^(?:\/|\.+\/)/.test(path)) {
+					path = `./${path}`;
+				}
+			}
+		}
+		ssrContext.head.push({ script: [{
+			tagPosition: "head",
+			tagPriority: "critical",
+			type: "importmap",
+			
+			innerHTML: { imports: { "#entry": path } }
+		}] });
+	}
+	
+	if (_PAYLOAD_EXTRACTION && !_PAYLOAD_INLINE && !NO_SCRIPTS) {
+		ssrContext.head.push({ link: [NUXT_JSON_PAYLOADS ? {
+			rel: "preload",
+			as: "fetch",
+			crossorigin: "anonymous",
+			href: payloadURL
+		} : {
+			rel: "modulepreload",
+			crossorigin: "",
+			href: payloadURL
+		}] });
+	}
+	
+	if (!NO_SCRIPTS) {
+		ssrContext.head.push({ link: getPreloadLinks({}, renderer.rendererContext) });
+		ssrContext.head.push({ link: getPrefetchLinks({}, renderer.rendererContext) });
+	}
+	
+	if (!NO_SCRIPTS) {
+		ssrContext.head.push({ script: Object.values(entryScripts).map((resource) => ({
+			type: resource.module ? "module" : null,
+			src: renderer.rendererContext.buildAssetsURL(resource.file),
+			defer: resource.module ? null : true,
+			tagPosition: "head",
+			crossorigin: ""
+		})) });
+	}
+	
+	if (!NO_SCRIPTS && !import.meta.dev && iifeChunkFileName) {
+		ssrContext.head.push({ link: [{
+			rel: "preload",
+			as: "script",
+			href: buildAssetsURL(iifeChunkFileName)
+		}] });
+	}
+	
+	
+	
+	
+	
+	const createSSRApp = await getServerApp();
+	let vueApp;
+	try {
+		vueApp = await createSSRApp(ssrContext);
+	} catch (error) {
+		
+		if ((ssrContext["~renderResponse"] || ssrContext._renderResponse) && error?.message === "skipping render") {
+			
+			
+			removeResponseHeader(event, "link");
+			return ssrContext["~renderResponse"] || ssrContext._renderResponse;
+		}
+		await ssrContext.nuxt?.hooks.callHook("app:error", error);
+		throw error;
+	}
+	if (ssrContext["~renderResponse"] || ssrContext._renderResponse) {
+		removeResponseHeader(event, "link");
+		return ssrContext["~renderResponse"] || ssrContext._renderResponse;
+	}
+	
+	
+	const { headTags, bodyTags, bodyTagsOpen, htmlAttrs, bodyAttrs } = renderShell(ssrContext.head);
+	
+	
+	
+	
+	
+	const cspNonce = headTags.match(/<script[^>]+\bnonce="([^"]*)"/)?.[1];
+	const nonceAttr = cspNonce ? ` nonce="${cspNonce}"` : "";
+	
+	
+	
+	
+	
+	const bootstrapScript = NO_SCRIPTS ? "" : createBootstrapScript(undefined, cspNonce);
+	let iifeScript = "";
+	if (!NO_SCRIPTS) {
+		if (!import.meta.dev && iifeChunkFileName) {
+			iifeScript = `<script async${nonceAttr} src="${buildAssetsURL(iifeChunkFileName)}"><\/script>`;
+		} else {
+			iifeScript = `<script${nonceAttr}>${streamingIifeCode}<\/script>`;
+		}
+	}
+	const shellContext = {
+		htmlAttrs: htmlAttrs ? [htmlAttrs] : [],
+		head: normalizeChunks([bootstrapScript, headTags]),
+		bodyAttrs: bodyAttrs ? [bodyAttrs] : [],
+		bodyPrepend: normalizeChunks([iifeScript, bodyTagsOpen]),
+		body: [],
+		bodyAppend: []
+	};
+	if (import.meta.dev) {
+		const initialBodyLen = shellContext.body.length;
+		const initialAppendLen = shellContext.bodyAppend.length;
+		await nitroApp.hooks.callHook("render:html", shellContext, {
+			event,
+			streaming: true
+		});
+		if (shellContext.body.length !== initialBodyLen || shellContext.bodyAppend.length !== initialAppendLen) {
+			console.warn(`[nuxt] \`render:html\` mutated \`body\`/\`bodyAppend\` while streaming (${event.path}). These fields are silently dropped because the body is about to stream - use the \`render:html:close\` hook instead.`);
+		}
+	} else {
+		await nitroApp.hooks.callHook("render:html", shellContext, {
+			event,
+			streaming: true
+		});
+	}
+	const shellHtml = "<!DOCTYPE html>" + `<html${joinAttrs(shellContext.htmlAttrs)}>` + `<head>${joinTags(shellContext.head)}</head>` + `<body${joinAttrs(shellContext.bodyAttrs)}>` + joinTags(shellContext.bodyPrepend);
+	
+	const vueStream = renderToWebStream(vueApp, ssrContext);
+	const reader = vueStream.getReader();
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	let firstChunk;
+	try {
+		const { done, value } = await reader.read();
+		if (!done) {
+			firstChunk = value;
+		}
+	} catch (error) {
+		reader.releaseLock();
+		removeResponseHeader(event, "link");
+		if (ssrContext["~renderResponse"] || ssrContext._renderResponse) {
+			return ssrContext["~renderResponse"] || ssrContext._renderResponse;
+		}
+		const _err = !ssrError && ssrContext.payload?.error || error;
+		await ssrContext.nuxt?.hooks.callHook("app:error", _err);
+		throw _err;
+	}
+	if (ssrContext["~renderResponse"] || ssrContext._renderResponse) {
+		reader.cancel().catch(() => {});
+		removeResponseHeader(event, "link");
+		return ssrContext["~renderResponse"] || ssrContext._renderResponse;
+	}
+	if (ssrContext.payload?.error && !ssrError) {
+		reader.cancel().catch(() => {});
+		removeResponseHeader(event, "link");
+		throw ssrContext.payload.error;
+	}
+	
+	
+	
+	
+	const committedSnapshot = import.meta.dev ? {
+		status: getResponseStatus(event),
+		statusText: getResponseStatusText(event),
+		headers: snapshotResponseHeaders(event)
+	} : null;
+	
+	const encoder = new TextEncoder();
+	let chunkIndex = 0;
+	
+	
+	
+	const enqueueChunk = async (controller, chunk) => {
+		const chunkContext = {
+			chunk,
+			index: chunkIndex++
+		};
+		await nitroApp.hooks.callHook("render:html:chunk", chunkContext, { event });
+		controller.enqueue(chunkContext.chunk);
+	};
+	
+	
+	
+	
+	
+	
+	
+	const emittedStyles = new Set(Object.values(entryStyles).map((r) => r.file));
+	const inlinedCss = new Set(entryInlineStyles.map((s) => String(s.innerHTML)));
+	const renderRouteStyles = async () => {
+		let tags = "";
+		if (NUXT_INLINE_STYLES) {
+			for (const style of await renderInlineStyles(ssrContext.modules ?? [])) {
+				const css = String(style.innerHTML);
+				if (!css || inlinedCss.has(css)) {
+					continue;
+				}
+				inlinedCss.add(css);
+				tags += `<style${nonceAttr}>${css}</style>`;
+			}
+			return tags;
+		}
+		for (const resource of Object.values(getRequestDependencies(ssrContext, renderer.rendererContext).styles)) {
+			if (emittedStyles.has(resource.file)) {
+				continue;
+			}
+			if (import.meta.dev && "inline" in getURLQuery(resource.file)) {
+				continue;
+			}
+			emittedStyles.add(resource.file);
+			tags += `<link rel="stylesheet" crossorigin href="${renderer.rendererContext.buildAssetsURL(resource.file)}">`;
+		}
+		return tags;
+	};
+	const outputStream = new ReadableStream({
+		async start(controller) {
+			try {
+				
+				
+				
+				await enqueueChunk(controller, encoder.encode(shellHtml));
+				await enqueueChunk(controller, encoder.encode(await renderRouteStyles() + APP_ROOT_OPEN_TAG));
+				if (firstChunk) {
+					await enqueueChunk(controller, firstChunk);
+					const headChunk = renderSSRHeadSuspenseChunk(ssrContext.head);
+					if (headChunk && !NO_SCRIPTS) {
+						await enqueueChunk(controller, encoder.encode(`<script${nonceAttr}>${headChunk};document.currentScript.remove()<\/script>`));
+					}
+				}
+				
+				try {
+					while (true) {
+						const { done, value } = await reader.read();
+						if (done) {
+							break;
+						}
+						await enqueueChunk(controller, value);
+						
+						const headChunk = renderSSRHeadSuspenseChunk(ssrContext.head);
+						if (headChunk && !NO_SCRIPTS) {
+							await enqueueChunk(controller, encoder.encode(`<script${nonceAttr}>${headChunk};document.currentScript.remove()<\/script>`));
+						}
+					}
+				} finally {
+					reader.releaseLock();
+				}
+				
+				
+				
+				if (!NO_SCRIPTS) {
+					const finalHeadChunk = renderSSRHeadSuspenseChunk(ssrContext.head);
+					if (finalHeadChunk) {
+						await enqueueChunk(controller, encoder.encode(`<script${nonceAttr}>${finalHeadChunk};document.currentScript.remove()<\/script>`));
+					}
+				}
+				
+				await ssrContext.nuxt?.hooks.callHook("app:rendered", {
+					ssrContext,
+					renderResult: {}
+				});
+				
+				
+				
+				if (ssrContext.payload?.error && !ssrError) {
+					await ssrContext.nuxt?.hooks.callHook("app:error", ssrContext.payload.error);
+				}
+				
+				if (!NO_SCRIPTS) {
+					ssrContext.head.push({ script: _PAYLOAD_INLINE ? NUXT_JSON_PAYLOADS ? renderPayloadJsonScript({
+						ssrContext,
+						data: ssrContext.payload
+					}) : renderPayloadScript({
+						ssrContext,
+						data: ssrContext.payload,
+						routeOptions
+					}) : NUXT_JSON_PAYLOADS ? renderPayloadJsonScript({
+						ssrContext,
+						data: splitPayload(ssrContext).initial,
+						src: payloadURL
+					}) : renderPayloadScript({
+						ssrContext,
+						data: splitPayload(ssrContext).initial,
+						routeOptions,
+						src: payloadURL
+					}) }, {
+						tagPosition: "bodyClose",
+						tagPriority: "high"
+					});
+				}
+				
+				
+				
+				const closingHead = applyRenderOptions(ssrContext.head.render(), renderSSRHeadOptions);
+				const closeContext = { bodyAppend: normalizeChunks([bodyTags, closingHead.bodyTags]) };
+				await nitroApp.hooks.callHook("render:html:close", closeContext, { event });
+				
+				
+				
+				
+				
+				const teleportHtml = APP_TELEPORT_OPEN_TAG + (HAS_APP_TELEPORTS ? joinTags([ssrContext.teleports?.[`#${appTeleportAttrs.id}`]]) : "") + APP_TELEPORT_CLOSE_TAG;
+				
+				
+				
+				
+				
+				const islandTeleports = NO_SCRIPTS ? "" : renderStreamedIslandTeleports(ssrContext, nonceAttr);
+				const closingHtml = APP_ROOT_CLOSE_TAG + await renderRouteStyles() + teleportHtml + (ssrContext.teleports?.body || "") + islandTeleports + joinTags(closeContext.bodyAppend) + "</body></html>";
+				await enqueueChunk(controller, encoder.encode(closingHtml));
+				controller.close();
+				if (committedSnapshot) {
+					const currentStatus = getResponseStatus(event);
+					const currentStatusText = getResponseStatusText(event);
+					const currentHeaders = snapshotResponseHeaders(event);
+					const lateMutations = [];
+					if (currentStatus !== committedSnapshot.status) {
+						lateMutations.push(`response status changed from ${committedSnapshot.status || 200} to ${currentStatus} (e.g. \`setResponseStatus\`)`);
+					}
+					if (currentStatusText !== committedSnapshot.statusText) {
+						lateMutations.push(`response statusText changed (e.g. \`setResponseStatus\`)`);
+					}
+					if (currentHeaders !== committedSnapshot.headers) {
+						lateMutations.push(`response headers changed during render (e.g. \`useCookie\`, \`useResponseHeader\`, \`setHeader\`)`);
+					}
+					if (lateMutations.length) {
+						console.warn(`[nuxt] SSR streaming committed the response before render completed. The following mutations did not reach the client and were dropped:\n  - ${lateMutations.join("\n  - ")}\n  Path: ${event.path}\n  Move the mutation into a plugin (which runs before the shell is flushed), or opt this route out of streaming with \`routeRules: { '${event.path}': { streaming: false } }\` or the \`render:route\` hook.`);
+					}
+				}
+			} catch (error) {
+				
+				
+				
+				
+				
+				await Promise.resolve(ssrContext.nuxt?.hooks.callHook("app:error", error)).catch(() => {});
+				ssrContext.payload ||= {};
+				ssrContext.payload.error ||= error;
+				try {
+					if (!NO_SCRIPTS) {
+						ssrContext.head.push({ script: NUXT_JSON_PAYLOADS ? renderPayloadJsonScript({
+							ssrContext,
+							data: ssrContext.payload
+						}) : renderPayloadScript({
+							ssrContext,
+							data: ssrContext.payload,
+							routeOptions
+						}) }, {
+							tagPosition: "bodyClose",
+							tagPriority: "high"
+						});
+						const tail = applyRenderOptions(ssrContext.head.render(), renderSSRHeadOptions);
+						controller.enqueue(encoder.encode(tail.bodyTags));
+					}
+				} catch {}
+				controller.enqueue(encoder.encode(APP_ROOT_CLOSE_TAG + "</body></html>"));
+				controller.close();
+			}
+		},
+		cancel(reason) {
+			
+			
+			
+			reader.cancel(reason).catch(() => {});
+		}
+	});
+	setResponseHeader(event, "content-type", "text/html;charset=utf-8");
+	setResponseHeader(event, "x-powered-by", "Nuxt");
+	return { body: outputStream };
+}
+
+
+
+
+
+function applyRenderOptions(payload, options) {
+	if (!options.omitLineBreaks) {
+		return payload;
+	}
+	return {
+		headTags: payload.headTags.replaceAll("\n", ""),
+		bodyTags: payload.bodyTags.replaceAll("\n", ""),
+		bodyTagsOpen: payload.bodyTagsOpen.replaceAll("\n", ""),
+		htmlAttrs: payload.htmlAttrs,
+		bodyAttrs: payload.bodyAttrs
+	};
+}
+function snapshotResponseHeaders(event) {
+	const headers = event.node.res.getHeaders();
+	return Object.entries(headers).map(([k, v]) => `${k}: ${Array.isArray(v) ? v.join(", ") : v}`).sort().join("\n");
+}
 function normalizeChunks(chunks) {
 	const result = [];
 	for (const _chunk of chunks) {

package/dist/runtime/utils/renderer/build-files.d.mts

@@ -1,5 +1,9 @@
 import type { RendererContext } from "vue-bundle-renderer/runtime";
+import type { App } from "vue";
 import type { NuxtSSRContext } from "nuxt/app";
+type Entry = (ssrContext?: NuxtSSRContext) => Promise<App>;
+export declare const APP_ROOT_OPEN_TAG: string;
+export declare const APP_ROOT_CLOSE_TAG: string;
 interface Renderer {
 	rendererContext: RendererContext;
 	renderToString(ssrContext: NuxtSSRContext): Promise<{
@@ -12,5 +16,6 @@ interface Renderer {
 }
 export declare const getSSRRenderer: () => Promise<Renderer>;
 export declare function getRenderer(ssrContext: NuxtSSRContext): Promise<Renderer>;
+export declare const getServerApp: () => Promise<Entry>;
 export declare const getSSRStyles: () => Promise<Record<string, () => Promise<string[]>>>;
 export {};

package/dist/runtime/utils/renderer/build-files.mjs

@@ -11,8 +11,8 @@ import { buildAssetsURL, publicAssetsURL } from "../paths.mjs";
 globalThis.__buildAssetsURL = buildAssetsURL;
 // @ts-expect-error private property consumed by vite-generated url helpers
 globalThis.__publicAssetsURL = publicAssetsURL;
-const APP_ROOT_OPEN_TAG = `<${appRootTag}${propsToString(appRootAttrs)}>`;
-const APP_ROOT_CLOSE_TAG = `</${appRootTag}>`;
+export const APP_ROOT_OPEN_TAG = `<${appRootTag}${propsToString(appRootAttrs)}>`;
+export const APP_ROOT_CLOSE_TAG = `</${appRootTag}>`;
 // @ts-expect-error file will be produced after app build
 const getServerEntry = () => import("#build/dist/server/server.mjs").then((r) => r.default || r);
 // @ts-expect-error file will be produced after app build
@@ -99,5 +99,7 @@ function lazyCachedFunction(fn) {
 export function getRenderer(ssrContext) {
 	return NUXT_NO_SSR || ssrContext.noSSR ? getSPARenderer() : getSSRRenderer();
 }
+
+export const getServerApp = lazyCachedFunction(getServerEntry);
 // @ts-expect-error file will be produced after app build
 export const getSSRStyles = lazyCachedFunction(() => import("#build/dist/server/styles.mjs").then((r) => r.default || r));

package/dist/runtime/utils/renderer/islands.d.mts

@@ -6,4 +6,10 @@ export declare function getServerComponentHTML(body: string): string;
 export declare function getSlotIslandResponse(ssrContext: NuxtSSRContext): NuxtIslandResponse["slots"];
 export declare function getClientIslandResponse(ssrContext: NuxtSSRContext): NuxtIslandResponse["components"];
 export declare function getComponentSlotTeleport(clientUid: string, teleports: Record<string, string>): Record<string, string>;
+/**
+* Emit each island teleport as an inert `<template>` keyed by its anchor,
+* followed by a relocation script that moves the content into place before
+* hydration. Returns an empty string when there are no island teleports.
+*/
+export declare function renderStreamedIslandTeleports(ssrContext: NuxtSSRContext, nonceAttr?: string): string;
 export declare function replaceIslandTeleports(ssrContext: NuxtSSRContext, html: string): string;

package/dist/runtime/utils/renderer/islands.mjs

@@ -53,6 +53,43 @@ export function getComponentSlotTeleport(clientUid, teleports) {
 	}
 	return slots;
 }
+
+
+
+
+
+const ISLAND_TELEPORT_RELOCATE_SCRIPT = `(()=>{for(const t of document.querySelectorAll('template[data-island-uid]')){const u=t.getAttribute('data-island-uid'),s=t.getAttribute('data-island-slot'),c=t.getAttribute('data-island-component'),a=document.querySelector('[data-island-uid="'+u+'"]'+(s!==null?'[data-island-slot="'+s+'"]':'[data-island-component="'+c+'"]'));if(a){a.insertBefore(t.content,a.firstChild)}t.remove()}})()`;
+
+export function renderStreamedIslandTeleports(ssrContext, nonceAttr = "") {
+	const { teleports, islandContext } = ssrContext;
+	if (islandContext || !teleports) {
+		return "";
+	}
+	let templates = "";
+	for (const key in teleports) {
+		const matchClientComp = key.match(SSR_CLIENT_TELEPORT_MARKER);
+		if (matchClientComp) {
+			const [, uid, clientId] = matchClientComp;
+			if (!uid || !clientId) {
+				continue;
+			}
+			templates += `<template data-island-uid="${uid}" data-island-component="${clientId}">${teleports[key]}</template>`;
+			continue;
+		}
+		const matchSlot = key.match(SSR_SLOT_TELEPORT_MARKER);
+		if (matchSlot) {
+			const [, uid, slot] = matchSlot;
+			if (!uid || !slot) {
+				continue;
+			}
+			templates += `<template data-island-uid="${uid}" data-island-slot="${slot}">${teleports[key]}</template>`;
+		}
+	}
+	if (!templates) {
+		return "";
+	}
+	return templates + `<script${nonceAttr}>${ISLAND_TELEPORT_RELOCATE_SCRIPT}<\/script>`;
+}
 export function replaceIslandTeleports(ssrContext, html) {
 	const { teleports, islandContext } = ssrContext;
 	if (islandContext || !teleports) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuxt/nitro-server-nightly",
-  "version": "4.5.0-29673761.f253a70d",
+  "version": "4.5.0-29673775.d239dbcd",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nuxt/nuxt.git",
@@ -27,7 +27,7 @@
   ],
   "dependencies": {
     "@nuxt/devalue": "^2.0.2",
-    "@nuxt/kit": "npm:@nuxt/kit-nightly@4.5.0-29673761.f253a70d",
+    "@nuxt/kit": "npm:@nuxt/kit-nightly@4.5.0-29673775.d239dbcd",
     "@unhead/vue": "^3.1.0",
     "@vue/shared": "^3.5.35",
     "consola": "^3.4.2",
@@ -58,7 +58,7 @@
     "@babel/plugin-proposal-decorators": "^7.25.0",
     "@babel/plugin-syntax-typescript": "^7.25.0",
     "@rollup/plugin-babel": "^6.0.0 || ^7.0.0",
-    "nuxt": "npm:nuxt-nightly@4.5.0-29673761.f253a70d"
+    "nuxt": "npm:nuxt-nightly@4.5.0-29673775.d239dbcd"
   },
   "peerDependenciesMeta": {
     "@babel/plugin-proposal-decorators": {
@@ -74,9 +74,9 @@
   "devDependencies": {
     "@babel/plugin-proposal-decorators": "7.29.7",
     "@babel/plugin-syntax-typescript": "7.29.7",
-    "@nuxt/schema": "npm:@nuxt/schema-nightly@4.5.0-29673761.f253a70d",
+    "@nuxt/schema": "npm:@nuxt/schema-nightly@4.5.0-29673775.d239dbcd",
     "@rollup/plugin-babel": "7.1.0",
-    "nuxt": "npm:nuxt-nightly@4.5.0-29673761.f253a70d",
+    "nuxt": "npm:nuxt-nightly@4.5.0-29673775.d239dbcd",
     "obuild": "0.4.36",
     "vitest": "4.1.7"
   },