vinext 1.2.1 → 1.3.1

package/dist/server/app-ssr-stream.js

@@ -1,8 +1,10 @@
-import { createInlineScriptTag, escapeHtmlAttr, htmlTokenListContains, safeJsonStringify } from "./html.js";
+import { createNonceAttribute, escapeHtmlAttr, htmlTokenListContains, safeJsonStringify, scriptSafeJsonStringify } from "./html.js";
+import { getVinextRscCompatibilityId } from "./app-rsc-cache-busting.js";
 import { bytesToBase64, concatUint8Arrays } from "./app-rsc-embedded-chunks.js";
 import { NAVIGATION_RUNTIME_SYMBOL_DESCRIPTION } from "../client/browser-globals.js";
+import { Buffer, isUtf8 } from "node:buffer";
 //#region src/server/app-ssr-stream.ts
-const RSC_EMBED_TEXT_BATCH_MAX_LENGTH = 65536;
+const RSC_EMBED_TEXT_BATCH_MAX_BYTES = 65536;
 function waitAtLeastOneReactRenderTask() {
 	return new Promise((resolve) => setTimeout(resolve, 0));
 }
@@ -14,6 +16,17 @@ function createNavigationRuntimeRscMetadataScript(params, nav, dynamicStaleTimeS
 	return "Object.assign(" + navigationRuntimeRscBootstrapExpression() + ",{params:" + safeJsonStringify(params) + ",nav:" + safeJsonStringify(nav) + (searchParamsFromBrowser === void 0 ? "" : ",searchParamsFromBrowser:" + safeJsonStringify(searchParamsFromBrowser)) + (dynamicStaleTimeSeconds === void 0 ? "" : ",dynamicStaleTimeSeconds:" + safeJsonStringify(dynamicStaleTimeSeconds)) + "})";
 }
 /**
+* The compatibility ID of the server rendering this page. The browser compares
+* RSC responses against it, so it is sent with the page rather than inlined
+* into the client bundle, where a per-build value would rename chunks on every
+* build. Static export skips the check, so its pages omit it.
+*/
+function createNavigationRuntimeRscCompatibilityScript() {
+	const compatibilityId = getVinextRscCompatibilityId();
+	if (compatibilityId === null || process.env.NODE_ENV === "production" && process.env.__NEXT_CONFIG_OUTPUT === "export") return "";
+	return "Object.assign(" + navigationRuntimeRscBootstrapExpression() + ",{compatibilityId:" + safeJsonStringify(compatibilityId) + "})";
+}
+/**
 * The query a client page read during SSR, for a render that turned dynamic
 * after its head told the browser to read the query from its own URL.
 */
@@ -21,7 +34,30 @@ function createNavigationRuntimeRenderedSearchScript(search) {
 	return "Object.assign(" + navigationRuntimeRscBootstrapExpression() + ",{renderedSearch:" + safeJsonStringify(search) + "})";
 }
 function createNavigationRuntimeRscChunkScript(chunk) {
-	return navigationRuntimeRscBootstrapExpression() + ".rsc.push(" + safeJsonStringify(chunk) + ")";
+	return navigationRuntimeRscBootstrapExpression() + ".rsc.push(" + scriptSafeJsonStringify(chunk) + ")";
+}
+const SCRIPT_UNSAFE_BYTE_STRING_RE = /<(?=!--|\/?[Ss][Cc][Rr][Ii][Pp][Tt])|\u00e2\u0080[\u00a8\u00a9]/g;
+function escapeScriptUnsafeByteString(match) {
+	if (match === "<") return "\\u003c";
+	return match.charCodeAt(2) === 168 ? "\\u2028" : "\\u2029";
+}
+function bytesToByteString(bytes) {
+	return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("latin1");
+}
+const NON_ASCII_RE = /[\u0080-\uffff]/;
+function textToByteString(text) {
+	return NON_ASCII_RE.test(text) ? Buffer.from(text, "utf8").toString("latin1") : text;
+}
+function byteStringToBytes(byteString) {
+	const bytes = Buffer.allocUnsafeSlow(byteString.length);
+	bytes.write(byteString, "latin1");
+	return bytes;
+}
+const NAVIGATION_RUNTIME_RSC_PUSH_PREFIX = textToByteString(navigationRuntimeRscBootstrapExpression() + ".rsc.push(");
+/** createNavigationRuntimeRscChunkScript for valid UTF-8 text, as a byte string. */
+function createNavigationRuntimeRscTextChunkByteScript(text) {
+	const json = JSON.stringify(bytesToByteString(text)).replace(SCRIPT_UNSAFE_BYTE_STRING_RE, escapeScriptUnsafeByteString);
+	return NAVIGATION_RUNTIME_RSC_PUSH_PREFIX + json + ")";
 }
 function createNavigationRuntimeRscDoneScript(metadata) {
 	const bootstrap = navigationRuntimeRscBootstrapExpression();
@@ -40,6 +76,18 @@ function createNextFlightChunkScript(chunk) {
 function createNextFlightCleanupScript() {
 	return "self.addEventListener(\"DOMContentLoaded\",()=>{if(self.__next_f?.push===Array.prototype.push)self.__next_f.length=0},{once:true})";
 }
+function utf8CharacterLength(byte) {
+	return byte >= 248 ? 1 : byte >= 240 ? 4 : byte >= 224 ? 3 : byte >= 192 ? 2 : 1;
+}
+function utf8CompleteEnd(bytes) {
+	const length = bytes.byteLength;
+	for (let index = length - 1; index >= 0 && index >= length - 3; index--) {
+		const byte = bytes[index];
+		if ((byte & 192) === 128) continue;
+		return index + utf8CharacterLength(byte) > length ? index : length;
+	}
+	return length;
+}
 /**
 * Create a helper that progressively embeds RSC chunks as inline <script> tags.
 * The browser entry turns the embedded chunks back into Uint8Array data.
@@ -48,34 +96,115 @@ function createRscEmbedTransform(embedStream, optionsOrNonce = {}) {
 	const options = typeof optionsOrNonce === "string" ? { scriptNonce: optionsOrNonce } : optionsOrNonce;
 	const reader = embedStream.getReader();
 	let pendingChunks = [];
+	let pendingRawChunkCount = 0;
 	const rawChunks = [];
 	let embeddedRawChunkCount = 0;
 	let rawBufferTaken = false;
+	let rawChunksReleased = false;
 	let finalized = false;
 	let reading = false;
+	let readDone = false;
+	let readError = null;
+	const replays = [];
 	let mirroredNextFlightBootstrap = false;
-	const textDecoder = new TextDecoder("utf-8", {
-		fatal: true,
-		ignoreBOM: true
-	});
-	function decodeChunk(bytes) {
-		try {
-			return textDecoder.decode(bytes);
-		} catch {
-			return [3, bytesToBase64(bytes)];
+	const textDecoder = new TextDecoder("utf-8", { ignoreBOM: true });
+	const nonceAttribute = textToByteString(createNonceAttribute(options.scriptNonce));
+	function toBinaryChunk(bytes) {
+		return [3, bytesToBase64(bytes)];
+	}
+	function splitChunk(bytes, chunks) {
+		if (isUtf8(bytes)) {
+			chunks.push(bytes);
+			return;
 		}
+		const pushRange = (start, end, text) => {
+			const range = bytes.subarray(start, end);
+			chunks.push(text ? range : toBinaryChunk(range));
+		};
+		let rangeStart = 0;
+		let rangeIsText = false;
+		let start = 0;
+		while (start < bytes.byteLength) {
+			const newline = bytes.indexOf(10, start);
+			const end = newline === -1 ? bytes.byteLength : newline + 1;
+			const isText = isUtf8(bytes.subarray(start, end));
+			if (start > rangeStart && isText !== rangeIsText) {
+				pushRange(rangeStart, start, rangeIsText);
+				rangeStart = start;
+			}
+			rangeIsText = isText;
+			start = end;
+		}
+		pushRange(rangeStart, bytes.byteLength, rangeIsText);
+	}
+	/**
+	* React cuts its output into fixed-size chunks wherever they fall, even
+	* inside a character, so a chunk's last incomplete character is decoded with
+	* the next chunk, which React writes in the same flush. Bytes are never held
+	* past an embed flush, though: they may be the end of a binary row, which the
+	* browser needs before React writes anything else. They're embedded as
+	* binary then, and so are the bytes that complete them.
+	*/
+	function createChunkDecoder() {
+		let carry = null;
+		let missing = 0;
+		return {
+			decode(raw, chunks) {
+				let bytes = raw;
+				if (missing > 0) {
+					let count = 0;
+					while (count < missing && count < bytes.byteLength && (bytes[count] & 192) === 128) count++;
+					missing = 0;
+					if (count > 0) {
+						chunks.push(toBinaryChunk(bytes.subarray(0, count)));
+						bytes = bytes.subarray(count);
+					}
+				}
+				if (carry) {
+					bytes = concatUint8Arrays([carry, bytes]);
+					carry = null;
+				}
+				const end = utf8CompleteEnd(bytes);
+				if (end < bytes.byteLength) {
+					carry = bytes.slice(end);
+					bytes = bytes.subarray(0, end);
+				}
+				if (bytes.byteLength > 0) splitChunk(bytes, chunks);
+			},
+			flush(chunks) {
+				if (!carry) return;
+				chunks.push(toBinaryChunk(carry));
+				missing = utf8CharacterLength(carry[0]) - carry.byteLength;
+				carry = null;
+			}
+		};
+	}
+	const chunkDecoder = createChunkDecoder();
+	function inlineScript(byteScript) {
+		return "<script" + nonceAttribute + ">" + byteScript + "<\/script>";
 	}
 	function releaseRawChunks() {
 		const mayStartMirror = typeof options.mirrorNextFlight === "function" && !mirroredNextFlightBootstrap && !finalized;
-		if (rawBufferTaken && !mayStartMirror) rawChunks.length = 0;
+		if (rawBufferTaken && !mayStartMirror) {
+			rawChunks.length = 0;
+			rawChunksReleased = true;
+		}
 	}
+	/** The mirror's opening scripts, as a byte string. */
 	function startNextFlightMirror() {
 		if (mirroredNextFlightBootstrap) return "";
 		const mirror = options.mirrorNextFlight;
 		if (mirror !== true && (typeof mirror !== "function" || !mirror())) return "";
 		mirroredNextFlightBootstrap = true;
-		let scripts = createInlineScriptTag(createNextFlightBootstrapScript(), options.scriptNonce) + createInlineScriptTag(createNextFlightCleanupScript(), options.scriptNonce);
-		for (let index = 0; index < embeddedRawChunkCount; index++) scripts += createInlineScriptTag(createNextFlightChunkScript(decodeChunk(rawChunks[index])), options.scriptNonce);
+		let scripts = inlineScript(createNextFlightBootstrapScript()) + inlineScript(createNextFlightCleanupScript());
+		const embeddedChunks = [];
+		const replayDecoder = createChunkDecoder();
+		for (let index = 0; index < embeddedRawChunkCount; index++) replayDecoder.decode(rawChunks[index], embeddedChunks);
+		replayDecoder.flush(embeddedChunks);
+		for (const chunk of embeddedChunks) {
+			const nextChunk = chunk instanceof Uint8Array ? textDecoder.decode(chunk) : chunk;
+			scripts += inlineScript(textToByteString(createNextFlightChunkScript(nextChunk)));
+		}
 		releaseRawChunks();
 		return scripts;
 	}
@@ -87,56 +216,67 @@ function createRscEmbedTransform(embedStream, optionsOrNonce = {}) {
 				const result = await reader.read();
 				if (result.done) break;
 				rawChunks.push(result.value);
-				pendingChunks.push(decodeChunk(result.value));
+				for (const replay of replays) replay.controller.enqueue(result.value);
+				chunkDecoder.decode(result.value, pendingChunks);
+				pendingRawChunkCount++;
 			}
+			readDone = true;
+			for (const replay of replays.splice(0)) if (!replay.keepOpen) replay.controller.close();
 		} catch (error) {
 			if (process.env.NODE_ENV !== "production") console.warn("[vinext] RSC embed stream read error:", error);
+			readError = { error };
+			for (const replay of replays.splice(0)) replay.controller.error(error);
 			throw error;
 		} finally {
 			reading = false;
 		}
 	}
 	const pumpPromise = pumpReader();
+	/** Scripts for the chunks read since the last flush, as a byte string. */
+	function flushByteScripts() {
+		chunkDecoder.flush(pendingChunks);
+		if (pendingChunks.length === 0) return "";
+		const mirrorScripts = startNextFlightMirror();
+		const chunks = pendingChunks;
+		pendingChunks = [];
+		embeddedRawChunkCount += pendingRawChunkCount;
+		pendingRawChunkCount = 0;
+		let scripts = mirrorScripts;
+		let textChunks = [];
+		let textBytes = 0;
+		const flushTextChunks = () => {
+			if (textChunks.length === 0) return;
+			const text = textChunks.length === 1 ? textChunks[0] : concatUint8Arrays(textChunks);
+			textChunks = [];
+			textBytes = 0;
+			scripts += inlineScript(createNavigationRuntimeRscTextChunkByteScript(text));
+			if (mirroredNextFlightBootstrap) scripts += inlineScript(textToByteString(createNextFlightChunkScript(textDecoder.decode(text))));
+		};
+		for (const chunk of chunks) if (chunk instanceof Uint8Array) {
+			if (textBytes > 0 && textBytes + chunk.byteLength > RSC_EMBED_TEXT_BATCH_MAX_BYTES) flushTextChunks();
+			textChunks.push(chunk);
+			textBytes += chunk.byteLength;
+		} else {
+			flushTextChunks();
+			scripts += inlineScript(textToByteString(createNavigationRuntimeRscChunkScript(chunk)));
+			if (mirroredNextFlightBootstrap) scripts += inlineScript(textToByteString(createNextFlightChunkScript(chunk)));
+		}
+		flushTextChunks();
+		return scripts;
+	}
 	return {
 		flush() {
-			if (pendingChunks.length === 0) return "";
-			const mirrorScripts = startNextFlightMirror();
-			const chunks = pendingChunks;
-			pendingChunks = [];
-			embeddedRawChunkCount += chunks.length;
-			const embeddedChunks = [];
-			let textChunks = [];
-			let textLength = 0;
-			const flushTextChunks = () => {
-				if (textChunks.length === 0) return;
-				embeddedChunks.push(textChunks.join(""));
-				textChunks = [];
-				textLength = 0;
-			};
-			for (const chunk of chunks) if (typeof chunk === "string") {
-				if (textLength > 0 && textLength + chunk.length > RSC_EMBED_TEXT_BATCH_MAX_LENGTH) flushTextChunks();
-				textChunks.push(chunk);
-				textLength += chunk.length;
-			} else {
-				flushTextChunks();
-				embeddedChunks.push(chunk);
-			}
-			flushTextChunks();
-			let scripts = mirrorScripts;
-			for (const chunk of embeddedChunks) {
-				scripts += createInlineScriptTag(createNavigationRuntimeRscChunkScript(chunk), options.scriptNonce);
-				if (mirroredNextFlightBootstrap) scripts += createInlineScriptTag(createNextFlightChunkScript(chunk), options.scriptNonce);
-			}
-			return scripts;
+			const scripts = flushByteScripts();
+			return scripts ? byteStringToBytes(scripts) : null;
 		},
 		async finalize() {
 			await pumpPromise;
-			let scripts = this.flush();
+			let scripts = flushByteScripts();
 			scripts += startNextFlightMirror();
 			finalized = true;
 			releaseRawChunks();
-			scripts += createInlineScriptTag(createNavigationRuntimeRscDoneScript(options.getInitialNavigationCacheMetadata?.()), options.scriptNonce);
-			return scripts;
+			scripts += inlineScript(textToByteString(createNavigationRuntimeRscDoneScript(options.getInitialNavigationCacheMetadata?.())));
+			return byteStringToBytes(scripts);
 		},
 		async getRawBuffer() {
 			await pumpPromise;
@@ -144,17 +284,33 @@ function createRscEmbedTransform(embedStream, optionsOrNonce = {}) {
 			rawBufferTaken = true;
 			releaseRawChunks();
 			return buffer.buffer;
+		},
+		replay(replayOptions) {
+			if (rawChunksReleased) return null;
+			const keepOpen = replayOptions?.keepOpen === true;
+			let replay;
+			return new ReadableStream({
+				start(controller) {
+					for (const chunk of rawChunks) controller.enqueue(chunk);
+					if (readError) controller.error(readError.error);
+					else if (readDone) {
+						if (!keepOpen) controller.close();
+					} else {
+						replay = {
+							controller,
+							keepOpen
+						};
+						replays.push(replay);
+					}
+				},
+				cancel() {
+					const index = replay ? replays.indexOf(replay) : -1;
+					if (index !== -1) replays.splice(index, 1);
+				}
+			});
 		}
 	};
 }
-/**
-* Fix invalid preload "as" values in server-rendered HTML.
-* React Fizz emits <link rel="preload" as="stylesheet"> for CSS, but the
-* HTML spec requires as="style" for <link rel="preload">.
-*/
-function fixPreloadAs(html) {
-	return html.replace(/<link(?=[^>]*\srel="preload")[^>]*>/g, (tag) => tag.replace(" as=\"stylesheet\"", " as=\"style\""));
-}
 const LINK_TAG_RE = /<link\b[^>]*>/gi;
 const HTML_REWRITE_EXCLUDED_REGION_RE = /<!--[\s\S]*?-->|<(script|style|textarea|title)\b[^>]*>[\s\S]*?<\/\1\s*>/gi;
 const HTML_REWRITE_EXCLUDED_REGION_START_RE = /<!--|<(script|style|textarea|title)\b[^>]*>/gi;
@@ -306,6 +462,42 @@ const HEAD_OPEN_RE = /<head\b[^>]*>/;
 * (see `createMoveSuffixStream` and `CLOSE_TAG`)
 */
 const DOCUMENT_CLOSE_SUFFIX = "</body></html>";
+const DOCUMENT_CLOSE_SUFFIX_BYTES = new TextEncoder().encode(DOCUMENT_CLOSE_SUFFIX);
+const HEAD_CLOSE_BYTES = new TextEncoder().encode("</head>");
+/**
+* Whether `chunks` end partway through a UTF-8 character, i.e. whether a
+* streaming TextDecoder may still be holding back their last bytes. Errs
+* towards true: when the batch has too few bytes to tell, the previous
+* batch's answer carries over.
+*/
+function endsWithIncompleteUtf8Character(chunks, previousBatchEndedIncomplete) {
+	let continuationBytes = 0;
+	for (let chunkIndex = chunks.length - 1; chunkIndex >= 0; chunkIndex--) {
+		const chunk = chunks[chunkIndex];
+		for (let index = chunk.byteLength - 1; index >= 0; index--) {
+			const byte = chunk[index];
+			if ((byte & 192) !== 128) {
+				const length = byte >= 240 ? 4 : byte >= 224 ? 3 : byte >= 192 ? 2 : 1;
+				return continuationBytes + 1 < length;
+			}
+			if (++continuationBytes === 3) return false;
+		}
+	}
+	return previousBatchEndedIncomplete;
+}
+/**
+* Find an ASCII `pattern` in UTF-8 `bytes`, starting at `from`. ASCII bytes
+* never occur inside a multi-byte character, so every byte match is a match
+* in the decoded text too.
+*/
+function indexOfAsciiBytes(bytes, pattern, from) {
+	const last = bytes.byteLength - pattern.byteLength;
+	search: for (let index = from; index <= last; index++) {
+		for (let offset = 0; offset < pattern.byteLength; offset++) if (bytes[index + offset] !== pattern[offset]) continue search;
+		return index;
+	}
+	return -1;
+}
 /**
 * Create the tick-buffered HTML transform that injects RSC scripts between
 * React Fizz flush cycles without corrupting split HTML chunks.
@@ -341,10 +533,44 @@ function createTickBufferedTransform(rscEmbed, injectHTML = "", injectAfterHeadO
 	let preHeadInjected = false;
 	let suffixStripped = false;
 	let buffered = [];
+	let bufferedBytes = [];
+	let decoderMayHoldBytes = false;
 	let pendingHtml = "";
 	let timeoutId = null;
 	const hasInlineCssManifest = inlineCssManifest !== void 0 && Object.keys(inlineCssManifest).length > 0;
 	/**
+	* Return this batch's bytes when they are exactly the UTF-8 encoding of its
+	* decoded text, so they can stand in for re-encoding that text. That needs
+	* the batch to start and end on character boundaries (the decoder holds no
+	* bytes across it) and to contain no invalid UTF-8, which the decoder would
+	* have replaced with U+FFFD.
+	*/
+	const takeBufferedBytes = (html) => {
+		if (hasInlineCssManifest) return null;
+		const chunks = bufferedBytes;
+		bufferedBytes = [];
+		const startsMidCharacter = decoderMayHoldBytes;
+		decoderMayHoldBytes = endsWithIncompleteUtf8Character(chunks, decoderMayHoldBytes);
+		if (startsMidCharacter || decoderMayHoldBytes || html.includes("�")) return null;
+		return chunks.length === 1 ? chunks[0] : concatUint8Arrays(chunks);
+	};
+	/**
+	* Byte form of `stripDocumentCloseSuffix(html.slice(htmlStart))` for a batch
+	* whose bytes encode `html`: returns the bytes from `byteStart` (the byte
+	* offset of `htmlStart`) with the first suffix removed.
+	*/
+	const stripDocumentCloseSuffixBytes = (bytes, byteStart, html, htmlStart) => {
+		const rest = bytes.subarray(byteStart);
+		if (suffixStripped) return rest;
+		const index = html.indexOf(DOCUMENT_CLOSE_SUFFIX, htmlStart);
+		if (index === -1) return rest;
+		suffixStripped = true;
+		const byteIndex = indexOfAsciiBytes(bytes, DOCUMENT_CLOSE_SUFFIX_BYTES, byteStart + index - htmlStart);
+		const before = bytes.subarray(byteStart, byteIndex);
+		const after = bytes.subarray(byteIndex + DOCUMENT_CLOSE_SUFFIX_BYTES.byteLength);
+		return after.byteLength === 0 ? before : concatUint8Arrays([before, after]);
+	};
+	/**
 	* Strip the first occurrence of `</body></html>` from `chunk` so it can be
 	* re-emitted at the very end of the stream. Returns the rewritten chunk and
 	* a flag indicating whether a suffix was found. If `suffixStripped` is
@@ -385,22 +611,26 @@ function createTickBufferedTransform(rscEmbed, injectHTML = "", injectAfterHeadO
 	const spliceAfterHeadOpen = (chunk) => {
 		if (preHeadInjected) return {
 			chunk,
-			spliced: false
+			spliced: false,
+			insertionEnd: 0
 		};
 		const insertion = readPreHeadInsertion();
 		if (!insertion) return {
 			chunk,
-			spliced: false
+			spliced: false,
+			insertionEnd: 0
 		};
 		const match = HEAD_OPEN_RE.exec(chunk);
 		if (!match) return {
 			chunk,
-			spliced: false
+			spliced: false,
+			insertionEnd: 0
 		};
 		const insertAt = match.index + match[0].length;
 		return {
 			chunk: chunk.slice(0, insertAt) + insertion + chunk.slice(insertAt),
-			spliced: true
+			spliced: true,
+			insertionEnd: insertAt + insertion.length
 		};
 	};
 	const flushBuffered = (controller, final = false) => {
@@ -408,6 +638,7 @@ function createTickBufferedTransform(rscEmbed, injectHTML = "", injectAfterHeadO
 		const rawHtml = pendingHtml + buffered.join("");
 		buffered = [];
 		pendingHtml = "";
+		const rawBytes = takeBufferedBytes(rawHtml);
 		const split = final || !hasInlineCssManifest ? {
 			complete: rawHtml,
 			trailing: ""
@@ -415,29 +646,42 @@ function createTickBufferedTransform(rscEmbed, injectHTML = "", injectAfterHeadO
 		if (split.trailing) pendingHtml = split.trailing;
 		if (!split.complete) return;
 		if (injected && insertsPerFlush) emitInsertion(controller);
-		const preparedHtml = fixPreloadAs(split.complete);
-		const inlineCssResult = hasInlineCssManifest ? rewriteInlineCssStylesheetLinks(preparedHtml, inlineCssManifest, inlineCssPrependCss, inlineCssScriptNonce) : {
-			html: preparedHtml,
+		const inlineCssResult = hasInlineCssManifest ? rewriteInlineCssStylesheetLinks(split.complete, inlineCssManifest, inlineCssPrependCss, inlineCssScriptNonce) : {
+			html: split.complete,
 			consumedPrependCss: false
 		};
 		if (inlineCssResult.consumedPrependCss) inlineCssPrependCss = "";
 		let working = inlineCssResult.html;
+		const unchangedBytes = working === rawHtml ? rawBytes : null;
+		let rawTextStart = 0;
 		if (!preHeadInjected) {
 			const result = spliceAfterHeadOpen(working);
 			if (result.spliced) {
 				working = result.chunk;
 				preHeadInjected = true;
+				rawTextStart = result.insertionEnd;
 			}
 		}
 		if (!injected) {
 			const headEnd = working.indexOf("</head>");
 			if (headEnd !== -1) {
 				const before = working.slice(0, headEnd);
+				if (unchangedBytes && headEnd >= rawTextStart) {
+					const rawHeadEnd = headEnd - (working.length - rawHtml.length);
+					const byteHeadEnd = indexOfAsciiBytes(unchangedBytes, HEAD_CLOSE_BYTES, rawHeadEnd);
+					controller.enqueue(encoder.encode(before + readInlineCssPrependFallback() + readInsertion()));
+					controller.enqueue(stripDocumentCloseSuffixBytes(unchangedBytes, byteHeadEnd, rawHtml, rawHeadEnd));
+					injected = true;
+					return;
+				}
 				const after = stripDocumentCloseSuffix(working.slice(headEnd));
 				controller.enqueue(encoder.encode(before + readInlineCssPrependFallback() + readInsertion() + after));
 				injected = true;
 				return;
 			}
+		} else if (unchangedBytes && rawTextStart === 0) {
+			controller.enqueue(stripDocumentCloseSuffixBytes(unchangedBytes, 0, rawHtml, 0));
+			return;
 		}
 		working = stripDocumentCloseSuffix(working);
 		controller.enqueue(encoder.encode(working));
@@ -445,12 +689,13 @@ function createTickBufferedTransform(rscEmbed, injectHTML = "", injectAfterHeadO
 	return new TransformStream({
 		transform(chunk, controller) {
 			buffered.push(decoder.decode(chunk, { stream: true }));
+			if (!hasInlineCssManifest) bufferedBytes.push(chunk);
 			if (timeoutId !== null) return;
 			timeoutId = setTimeout(() => {
 				try {
 					flushBuffered(controller);
 					const rscScripts = rscEmbed.flush();
-					if (rscScripts) controller.enqueue(encoder.encode(rscScripts));
+					if (rscScripts) controller.enqueue(rscScripts);
 				} catch {}
 				timeoutId = null;
 			}, 0);
@@ -467,11 +712,10 @@ function createTickBufferedTransform(rscEmbed, injectHTML = "", injectAfterHeadO
 				emitInsertion(controller);
 				injected = true;
 			} else if (insertsPerFlush) emitInsertion(controller);
-			const finalScripts = await rscEmbed.finalize();
-			if (finalScripts) controller.enqueue(encoder.encode(finalScripts));
+			controller.enqueue(await rscEmbed.finalize());
 			controller.enqueue(encoder.encode(DOCUMENT_CLOSE_SUFFIX));
 		}
 	});
 }
 //#endregion
-export { createNavigationRuntimeRenderedSearchScript, createNavigationRuntimeRscMetadataScript, createRscEmbedTransform, createTickBufferedTransform, fixPreloadAs, navigationRuntimeRscBootstrapExpression, waitAtLeastOneReactRenderTask };
+export { createNavigationRuntimeRenderedSearchScript, createNavigationRuntimeRscCompatibilityScript, createNavigationRuntimeRscMetadataScript, createRscEmbedTransform, createTickBufferedTransform, navigationRuntimeRscBootstrapExpression, rewriteInlineCssStylesheetLinks, waitAtLeastOneReactRenderTask };

package/dist/server/app-static-generation.d.ts

@@ -11,4 +11,5 @@ type CreateStaticGenerationHeadersContextOptions = {
 export declare function getAppPageStaticGenerationErrorMessage(): string;
 export declare function getAppRouteStaticGenerationErrorMessage(routePattern?: string, expression?: string): string;
 export declare function createStaticGenerationHeadersContext(options: CreateStaticGenerationHeadersContextOptions): HeadersContext;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-streamed-client-references.d.ts

@@ -0,0 +1,39 @@
+import { AssetCrossOrigin } from "./pages-client-assets.js";
+import { RouteClientReferenceSet } from "./app-client-reference-preloader.js";
+//#region src/server/app-streamed-client-references.d.ts
+type ClientReferenceLoader = () => Promise<unknown>;
+/** A render's streamed references, and the stylesheets the render linked. */
+export type StreamedClientReferences = {
+  /** The render's CSP nonce for the scripts it hints. */
+  nonce: string | undefined;
+  /** next.config's crossOrigin for the assets it links; "" when unset. */
+  crossOrigin: AssetCrossOrigin;
+  streamed: ReadonlySet<string>;
+  /** Each of the route's references' position in import order. */
+  positions: ReadonlyMap<string, number>;
+  /** Streamed references whose stylesheets aren't linked yet, in import order. */
+  unlinked: string[];
+  linkedStylesheets: Set<string>;
+};
+/**
+ * Wrap plugin-rsc's client-reference loader before any client reference
+ * loads; a production build calls this as its SSR entry starts. `asyncIds` are
+ * the references any route may stream, and `getLoader` returns a reference's
+ * own loader from the client-references module.
+ */
+export declare function wrapClientReferenceRequire(asyncIds: ReadonlySet<string>, getLoader: (id: string) => ClientReferenceLoader | undefined): void;
+export declare function createStreamedClientReferences(route: RouteClientReferenceSet | undefined, nonce: string | undefined, crossOrigin: AssetCrossOrigin): StreamedClientReferences;
+/**
+ * Forget the stylesheets a discarded render linked, so the render that
+ * replaces it links them again.
+ */
+export declare function resetStreamedClientReferences(render: StreamedClientReferences | null, route: RouteClientReferenceSet | undefined): void;
+/** Run a render, and the Flight stream it reads, with its streamed references. */
+export declare function runWithStreamedClientReferences<R>(render: StreamedClientReferences, fn: () => R): R;
+/**
+ * The `<head>` links of the streamed stylesheets a render's shell left
+ * unlinked, those of streamed references after every reference it rendered.
+ */
+export declare function renderStreamedStylesheets(render: StreamedClientReferences): string;
+//#endregion
+export {};