@nuxt/nitro-server-nightly 5.0.0-29662437.89c933ea → 5.0.0-29664396.5668d45c

package/dist/index.d.mts

@@ -2,7 +2,7 @@ import { EventHandler, H3Event } from "nitro/h3";
 import { Nuxt } from "@nuxt/schema";
 import { Nitro, NitroConfig, NitroDevEventHandler, NitroEventHandler, NitroOptions, NitroRouteConfig, NitroRuntimeConfig, NitroRuntimeConfigApp } from "nitro/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";
 
 //#region src/augments.d.ts
@@ -14,6 +14,7 @@ declare module "nitro/types" {
   }
   interface NitroRouteRules {
     ssr?: boolean;
+    streaming?: boolean;
     noScripts?: boolean;
     /** @deprecated Use `noScripts` instead */
     experimentalNoScripts?: boolean;
@@ -24,6 +25,7 @@ declare module "nitro/types" {
   interface NitroRuntimeConfig extends RuntimeConfig {}
   interface NitroRouteConfig {
     ssr?: boolean;
+    streaming?: boolean;
     noScripts?: boolean;
     /** @deprecated Use `noScripts` instead */
     experimentalNoScripts?: boolean;
@@ -35,6 +37,16 @@ declare module "nitro/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

@@ -19,7 +19,7 @@ import { resolveModulePath } from "exsolve";
 import { runtimeDependencies } from "nitro/meta";
 import { resolveModuleExportNames } from "mlly";
 //#region package.json
-var version = "5.0.0-29662437.89c933ea";
+var version = "5.0.0-29664396.5668d45c";
 //#endregion
 //#region src/utils.ts
 function toArray(value) {
@@ -124,7 +124,7 @@ ${[...references.map((ref) => renderReference(ref, typesDir)), ...declarations].
 import type { RuntimeConfig } from 'nuxt/schema'
 import type { H3Event } from 'nitro/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 'nitro/types' {
   interface NitroRuntimeConfigApp {
@@ -135,12 +135,14 @@ declare module 'nitro/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
@@ -149,7 +151,10 @@ declare module 'nitro/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>
   }
 }
@@ -337,6 +342,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 = nitro.routing.routeRules.routes.some((r) => r.data.isr || r.data.cache);
@@ -350,12 +356,17 @@ 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: {
-			"/**": { ssr: true },
+			"/**": typeof nuxt.options.experimental.ssrStreaming === "object" && nuxt.options.experimental.ssrStreaming.enabled ? {
+				ssr: true,
+				streaming: true
+			} : { ssr: true },
 			"/__nuxt_error": { cache: false }
 		},
 		rolldownConfig: { tsconfig: false },

package/dist/runtime/handlers/renderer.mjs

@@ -1,9 +1,9 @@
 import { payloadCache, prerenderRenderingURLs } from "../utils/cache.mjs";
 import { createSSRContext, setSSRError } from "../utils/renderer/app.mjs";
 import { buildAssetsURL, publicAssetsURL } from "../utils/paths.mjs";
-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 { renderInlineStyles } from "../utils/renderer/inline-styles.mjs";
-import { replaceIslandTeleports } from "../utils/renderer/islands.mjs";
+import { renderStreamedIslandTeleports, replaceIslandTeleports } from "../utils/renderer/islands.mjs";
 import { renderPayloadJsonScript, renderPayloadResponse, splitPayload } from "../utils/renderer/payload.mjs";
 import { getQuery, joinURL } from "ufo";
 import { getRouteRules, useNitroHooks } from "nitro/app";
@@ -11,13 +11,17 @@ import destr$1 from "destr";
 import { HTTPError, defineEventHandler, getQuery as getQuery$1, writeEarlyHints } from "nitro/h3";
 import { getPrefetchLinks, getPreloadLinks, getRequestDependencies, renderResourceHeaders } from "vue-bundle-renderer/runtime";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { NUXT_ASYNC_CONTEXT, NUXT_EARLY_HINTS, NUXT_INLINE_STYLES, 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_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";
 import { propsToString, renderSSRHead } from "@unhead/vue/server";
-import { appHead, appTeleportAttrs, appTeleportTag, componentIslands } from "#internal/nuxt.config.mjs";
+import { renderToWebStream } from "vue/server-renderer";
+import { appHead, appTeleportAttrs, appTeleportTag, componentIslands, componentIslandsActive } from "#internal/nuxt.config.mjs";
+import { createBootstrapScript, renderSSRHeadSuspenseChunk, renderShell } from "@unhead/vue/stream/server";
+import { streamingIifeCode } from "@unhead/vue/stream/iife";
 import { relative } from "pathe";
 import { renderSSRHeadOptions } from "#internal/unhead.config.mjs";
 import entryIds from "#internal/nuxt/entry-ids.mjs";
 import { entryFileName } from "#internal/entry-chunk.mjs";
+import { iifeChunkFileName } from "#internal/streaming-iife-chunk.mjs";
 //#region src/runtime/handlers/renderer.ts
 globalThis.__buildAssetsURL = buildAssetsURL;
 globalThis.__publicAssetsURL = publicAssetsURL;
@@ -28,6 +32,7 @@ const APP_TELEPORT_CLOSE_TAG = HAS_APP_TELEPORTS ? `</${appTeleportTag}>` : "";
 const PAYLOAD_URL_RE = /^[^?]*\/_payload.json(?:\?.*)?$/;
 const PAYLOAD_FILENAME = "_payload.json";
 let entryPath;
+const SSR_BOT_RE = NUXT_SSR_STREAMING_BOT_RE;
 const handler = defineEventHandler((event) => {
 	const ssrError = event.url.pathname.startsWith("/__nuxt_error") ? getQuery$1(event) : null;
 	if (ssrError && !event.context.nuxt?.["~internal"]) throw new HTTPError({
@@ -72,17 +77,37 @@ async function renderRoute(event, ssrError) {
 		if (link) writeEarlyHints(event, { link });
 	}
 	if (NUXT_INLINE_STYLES) for (const id of entryIds) 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(event.req.headers.get("user-agent") || ""))
+	};
+	const nitroHooks = useNitroHooks();
+	const renderRouteResult = nitroHooks.callHook("render:route", renderRouteContext, { event });
+	if (renderRouteResult instanceof Promise) await renderRouteResult;
+	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) => {
 		if (ssrContext["~renderResponse"] && error.message === "skipping render") return {};
 		const _err = !ssrError && ssrContext.payload?.error || error;
-		await ssrContext.nuxt?.hooks.callHook("app:error", _err);
+		const r = ssrContext.nuxt?.hooks.callHook("app:error", _err);
+		if (r instanceof Promise) await r;
 		throw _err;
 	});
 	const inlinedStyles = NUXT_INLINE_STYLES && !ssrContext["~renderResponse"] && !isRenderingPayload ? await renderInlineStyles(ssrContext.modules ?? []) : [];
-	await ssrContext.nuxt?.hooks.callHook("app:rendered", {
+	const appRenderedResult = ssrContext.nuxt?.hooks.callHook("app:rendered", {
 		ssrContext,
 		renderResult: _rendered
 	});
+	if (appRenderedResult instanceof Promise) await appRenderedResult;
 	if (ssrContext["~renderResponse"]) return returnResponse(event, ssrContext["~renderResponse"]);
 	if (ssrContext.payload?.error && !ssrError) throw ssrContext.payload.error;
 	if (isRenderingPayload) {
@@ -107,6 +132,8 @@ async function renderRoute(event, ssrError) {
 			}
 		}
 		ssrContext.head.push({ script: [{
+			tagPosition: "head",
+			tagPriority: "critical",
 			type: "importmap",
 			innerHTML: { imports: { "#entry": path } }
 		}] });
@@ -160,11 +187,272 @@ async function renderRoute(event, ssrError) {
 		body: [componentIslands ? replaceIslandTeleports(ssrContext, _rendered.html) : _rendered.html, APP_TELEPORT_OPEN_TAG + (HAS_APP_TELEPORTS ? joinTags([ssrContext.teleports?.[`#${appTeleportAttrs.id}`]]) : "") + APP_TELEPORT_CLOSE_TAG],
 		bodyAppend: [bodyTags]
 	};
-	await useNitroHooks().callHook("render:html", htmlContext, { event });
+	const renderHtmlResult = nitroHooks.callHook("render:html", htmlContext, { event });
+	if (renderHtmlResult instanceof Promise) await renderHtmlResult;
 	event.res.headers.set("content-type", "text/html;charset=utf-8");
 	event.res.headers.set("x-powered-by", "Nuxt");
 	return renderHTMLDocument(htmlContext);
 }
+async function renderStreamedResponse(ctx) {
+	const { event, ssrContext, renderer, routeOptions, ssrError, _PAYLOAD_EXTRACTION, _PAYLOAD_INLINE, payloadURL } = ctx;
+	const NO_SCRIPTS = NUXT_NO_SCRIPTS || !!routeOptions?.noScripts;
+	const { link: linkHeader } = renderResourceHeaders({}, renderer.rendererContext);
+	if (linkHeader) event.res.headers.append("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 getQuery(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.url.pathname.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: [{
+		rel: "preload",
+		as: "fetch",
+		crossorigin: "anonymous",
+		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"] && error?.message === "skipping render") {
+			event.res.headers.delete("link");
+			return returnResponse(event, ssrContext["~renderResponse"]);
+		}
+		const r = ssrContext.nuxt?.hooks.callHook("app:error", error);
+		if (r instanceof Promise) await r;
+		throw error;
+	}
+	if (ssrContext["~renderResponse"]) {
+		event.res.headers.delete("link");
+		return returnResponse(event, 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(void 0, 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: []
+	};
+	const nitroHooks = useNitroHooks();
+	if (import.meta.dev) {
+		const initialBodyLen = shellContext.body.length;
+		const initialAppendLen = shellContext.bodyAppend.length;
+		const r = nitroHooks.callHook("render:html", shellContext, {
+			event,
+			streaming: true
+		});
+		if (r instanceof Promise) await r;
+		if (shellContext.body.length !== initialBodyLen || shellContext.bodyAppend.length !== initialAppendLen) console.warn(`[nuxt] \`render:html\` mutated \`body\`/\`bodyAppend\` while streaming (${event.url.pathname}). These fields are silently dropped because the body is about to stream - use the \`render:html:close\` hook instead.`);
+	} else {
+		const r = nitroHooks.callHook("render:html", shellContext, {
+			event,
+			streaming: true
+		});
+		if (r instanceof Promise) await r;
+	}
+	const shellHtml = `<!DOCTYPE html><html${joinAttrs(shellContext.htmlAttrs)}><head>${joinTags(shellContext.head)}</head><body${joinAttrs(shellContext.bodyAttrs)}>` + joinTags(shellContext.bodyPrepend);
+	const reader = renderToWebStream(vueApp, ssrContext).getReader();
+	let firstChunk;
+	try {
+		const { done, value } = await reader.read();
+		if (!done) firstChunk = value;
+	} catch (error) {
+		reader.releaseLock();
+		event.res.headers.delete("link");
+		if (ssrContext["~renderResponse"]) return returnResponse(event, ssrContext["~renderResponse"]);
+		const _err = !ssrError && ssrContext.payload?.error || error;
+		const r = ssrContext.nuxt?.hooks.callHook("app:error", _err);
+		if (r instanceof Promise) await r;
+		throw _err;
+	}
+	if (ssrContext["~renderResponse"]) {
+		reader.cancel().catch(() => {});
+		event.res.headers.delete("link");
+		return returnResponse(event, ssrContext["~renderResponse"]);
+	}
+	if (ssrContext.payload?.error && !ssrError) {
+		reader.cancel().catch(() => {});
+		event.res.headers.delete("link");
+		throw ssrContext.payload.error;
+	}
+	const committedSnapshot = import.meta.dev ? {
+		status: event.res.status,
+		statusText: event.res.statusText,
+		headers: Array.from(event.res.headers.entries()).sort().map(([k, v]) => `${k}: ${v}`).join("\n")
+	} : null;
+	const encoder = new TextEncoder();
+	let chunkIndex = 0;
+	const enqueueChunk = (controller, chunk) => {
+		const chunkContext = {
+			chunk,
+			index: chunkIndex++
+		};
+		const result = nitroHooks.callHook("render:html:chunk", chunkContext, { event });
+		if (result instanceof Promise) return result.then(() => {
+			controller.enqueue(chunkContext.chunk);
+		});
+		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 getQuery(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>`));
+				}
+				const appRenderedResult = ssrContext.nuxt?.hooks.callHook("app:rendered", {
+					ssrContext,
+					renderResult: {}
+				});
+				if (appRenderedResult instanceof Promise) await appRenderedResult;
+				if (ssrContext.payload?.error && !ssrError) {
+					const r = ssrContext.nuxt?.hooks.callHook("app:error", ssrContext.payload.error);
+					if (r instanceof Promise) await r;
+				}
+				if (!NO_SCRIPTS) ssrContext.head.push({ script: _PAYLOAD_INLINE ? renderPayloadJsonScript({
+					ssrContext,
+					data: ssrContext.payload
+				}) : renderPayloadJsonScript({
+					ssrContext,
+					data: splitPayload(ssrContext).initial,
+					src: payloadURL
+				}) }, {
+					tagPosition: "bodyClose",
+					tagPriority: "high"
+				});
+				const closeContext = { bodyAppend: normalizeChunks([bodyTags, applyRenderOptions(ssrContext.head.render(), renderSSRHeadOptions).bodyTags]) };
+				const closeResult = nitroHooks.callHook("render:html:close", closeContext, { event });
+				if (closeResult instanceof Promise) await closeResult;
+				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 currentHeaders = Array.from(event.res.headers.entries()).sort().map(([k, v]) => `${k}: ${v}`).join("\n");
+					const lateMutations = [];
+					if (event.res.status !== committedSnapshot.status) lateMutations.push(`response status changed from ${committedSnapshot.status || 200} to ${event.res.status} (e.g. \`setResponseStatus\`)`);
+					if (event.res.statusText !== 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.url.pathname}\n  Move the mutation into a plugin (which runs before the shell is flushed), or opt this route out of streaming with \`routeRules: { '${event.url.pathname}': { 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: renderPayloadJsonScript({
+							ssrContext,
+							data: ssrContext.payload
+						}) }, {
+							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(() => {});
+		}
+	});
+	event.res.headers.set("content-type", "text/html;charset=utf-8");
+	event.res.headers.set("x-powered-by", "Nuxt");
+	return outputStream;
+}
 function normalizeChunks(chunks) {
 	const result = [];
 	for (const _chunk of chunks) {
@@ -183,6 +471,16 @@ function joinAttrs(chunks) {
 function renderHTMLDocument(html) {
 	return `<!DOCTYPE html><html${joinAttrs(html.htmlAttrs)}><head>${joinTags(html.head)}</head><body${joinAttrs(html.bodyAttrs)}>${joinTags(html.bodyPrepend)}${joinTags(html.body)}${joinTags(html.bodyAppend)}</body></html>`;
 }
+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 stripInlineOnlyPayloadFields(payload) {
 	if (!payload.prefetchLinks) return payload;
 	const { prefetchLinks: _, ...rest } = payload;

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

@@ -73,6 +73,7 @@ function lazyCachedFunction(fn) {
 function getRenderer(ssrContext) {
 	return NUXT_NO_SSR || ssrContext.noSSR ? getSPARenderer() : getSSRRenderer();
 }
+const getServerApp = lazyCachedFunction(getServerEntry);
 const getSSRStyles = lazyCachedFunction(() => import("#build/dist/server/styles.mjs").then((r) => r.default || r));
 //#endregion
-export { getRenderer, getSSRRenderer, getSSRStyles };
+export { APP_ROOT_CLOSE_TAG, APP_ROOT_OPEN_TAG, getRenderer, getSSRRenderer, getSSRStyles, getServerApp };

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

@@ -45,6 +45,34 @@ 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()}})()`;
+/**
+* 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.
+*/
+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>`;
+}
 function replaceIslandTeleports(ssrContext, html) {
 	const { teleports, islandContext } = ssrContext;
 	if (islandContext || !teleports) return html;
@@ -70,4 +98,4 @@ function replaceIslandTeleports(ssrContext, html) {
 	return html;
 }
 //#endregion
-export { getClientIslandResponse, getComponentSlotTeleport, getServerComponentHTML, getSlotIslandResponse, replaceIslandTeleports };
+export { getClientIslandResponse, getComponentSlotTeleport, getServerComponentHTML, getSlotIslandResponse, renderStreamedIslandTeleports, replaceIslandTeleports };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuxt/nitro-server-nightly",
-  "version": "5.0.0-29662437.89c933ea",
+  "version": "5.0.0-29664396.5668d45c",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nuxt/nuxt.git",
@@ -27,7 +27,7 @@
     "dist"
   ],
   "dependencies": {
-    "@nuxt/kit": "npm:@nuxt/kit-nightly@5.0.0-29662437.89c933ea",
+    "@nuxt/kit": "npm:@nuxt/kit-nightly@5.0.0-29664396.5668d45c",
     "@unhead/vue": "^3.1.0",
     "@vue/shared": "3.5.34",
     "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@5.0.0-29662437.89c933ea"
+    "nuxt": "npm:nuxt-nightly@5.0.0-29664396.5668d45c"
   },
   "peerDependenciesMeta": {
     "@babel/plugin-proposal-decorators": {
@@ -74,10 +74,10 @@
   "devDependencies": {
     "@babel/plugin-proposal-decorators": "7.29.0",
     "@babel/plugin-syntax-typescript": "7.28.6",
-    "@nuxt/schema": "npm:@nuxt/schema-nightly@5.0.0-29662437.89c933ea",
+    "@nuxt/schema": "npm:@nuxt/schema-nightly@5.0.0-29664396.5668d45c",
     "@rollup/plugin-babel": "7.0.0",
     "hookable": "6.1.1",
-    "nuxt": "npm:nuxt-nightly@5.0.0-29662437.89c933ea",
+    "nuxt": "npm:nuxt-nightly@5.0.0-29664396.5668d45c",
     "tsdown": "0.22.0",
     "vitest": "4.1.7"
   },