vinext 0.1.2 → 0.1.4

package/dist/server/app-server-action-execution.js

@@ -7,7 +7,7 @@ import { validateCsrfOrigin, validateServerActionPayload } from "./request-pipel
 import { headersContextFromRequest, setHeadersContext } from "../shims/headers.js";
 import { getAndClearActionRevalidationKind } from "../shims/cache.js";
 import { APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI } from "./app-rsc-render-mode.js";
-import { setCurrentFetchCacheMode, setCurrentFetchSoftTags } from "../shims/fetch-cache.js";
+import { setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
 import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
 import { readStreamAsTextWithLimit } from "../utils/text-stream.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
@@ -15,9 +15,9 @@ import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 import { getNextErrorDigest, parseNextHttpErrorDigest, parseNextRedirectDigest } from "./next-error-digest.js";
 import { createServerActionNotFoundResponse, getServerActionNotFoundMessage, isServerActionNotFoundError } from "./server-action-not-found.js";
 import { deferUntilStreamConsumed } from "./app-page-stream.js";
+import { buildAppPageTags } from "./implicit-tags.js";
 import { resolveAppPageNavigationParams } from "./app-page-element-builder.js";
 import { resolveAppPageActionRerenderTarget } from "./app-page-request.js";
-import { buildPageCacheTags } from "./implicit-tags.js";
 import { getSetCookieName } from "./cookie-utils.js";
 //#region src/server/app-server-action-execution.ts
 /**
@@ -46,6 +46,10 @@ function resolveActionRevalidationKind(hasModifiedCookies) {
 	if (hasModifiedCookies) return ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC;
 	return revalidationKind;
 }
+function clearRejectedActionSideEffects(getAndClearPendingCookies) {
+	getAndClearPendingCookies();
+	getAndClearActionRevalidationKind();
+}
 function cloneActionRedirectHeaders(requestHeaders) {
 	const headers = new Headers(requestHeaders);
 	for (const header of ACTION_REDIRECT_RENDER_STRIPPED_HEADERS) headers.delete(header);
@@ -173,7 +177,7 @@ async function readActionFormDataWithLimit(request, maxBytes) {
 		if (result.done) break;
 		totalSize += result.value.byteLength;
 		if (totalSize > maxBytes) {
-			await reader.cancel();
+			reader.cancel();
 			throw new Error("Request body too large");
 		}
 		chunks.push(result.value);
@@ -233,7 +237,7 @@ function applyActionRedirectBasePath(url, basePath) {
 	return `${addBasePathToPathname(pathname, basePath)}${suffix}`;
 }
 function buildServerActionPageTags(route, pathname) {
-	return buildPageCacheTags(pathname, [], [...route.routeSegments ?? []], "page");
+	return buildAppPageTags(pathname, [], route.routeSegments ?? []);
 }
 function resolveInternalActionRedirectTarget(redirectUrl, requestUrl, basePath) {
 	if (isExternalUrl(redirectUrl)) {
@@ -331,6 +335,7 @@ async function handleProgressiveServerActionRequest(options) {
 		}
 		const payloadResponse = await validateServerActionPayload(body);
 		if (payloadResponse) {
+			clearRejectedActionSideEffects(options.getAndClearPendingCookies);
 			options.clearRequestContext();
 			return payloadResponse;
 		}
@@ -480,8 +485,29 @@ async function handleServerActionRscRequest(options) {
 	if (options.request.method.toUpperCase() !== "POST" || !options.actionId) return null;
 	const csrfResponse = validateCsrfOrigin(options.request, options.allowedOrigins);
 	if (csrfResponse) return csrfResponse;
-	if (parseInt(options.request.headers.get("content-length") || "0", 10) > options.maxActionBodySize) return renderFetchActionBodyExceededResponse(options);
+	if (parseInt(options.request.headers.get("content-length") || "0", 10) > options.maxActionBodySize) {
+		if (options.request.body) options.request.body.cancel().catch(() => {});
+		return renderFetchActionBodyExceededResponse(options);
+	}
 	try {
+		let action;
+		if (options.contentType.startsWith("multipart/form-data")) {
+			let loadedAction;
+			try {
+				loadedAction = await options.loadServerAction(options.actionId);
+			} catch (error) {
+				if (isServerActionNotFoundError(error, options.actionId)) return createActionNotFoundResponse(options.actionId, {
+					clearRequestContext: options.clearRequestContext,
+					getAndClearPendingCookies: options.getAndClearPendingCookies
+				});
+				throw error;
+			}
+			if (!isAppServerActionFunction(loadedAction)) return createActionNotFoundResponse(options.actionId, {
+				clearRequestContext: options.clearRequestContext,
+				getAndClearPendingCookies: options.getAndClearPendingCookies
+			});
+			action = loadedAction;
+		}
 		let body;
 		try {
 			body = options.contentType.startsWith("multipart/form-data") ? await options.readFormDataWithLimit(options.request, options.maxActionBodySize) : await options.readBodyWithLimit(options.request, options.maxActionBodySize);
@@ -491,23 +517,27 @@ async function handleServerActionRscRequest(options) {
 		}
 		const payloadResponse = await validateServerActionPayload(body);
 		if (payloadResponse) {
+			clearRejectedActionSideEffects(options.getAndClearPendingCookies);
 			options.clearRequestContext();
 			return payloadResponse;
 		}
-		let action;
-		try {
-			action = await options.loadServerAction(options.actionId);
-		} catch (error) {
-			if (isServerActionNotFoundError(error, options.actionId)) return createActionNotFoundResponse(options.actionId, {
+		if (action === void 0) {
+			let loadedAction;
+			try {
+				loadedAction = await options.loadServerAction(options.actionId);
+			} catch (error) {
+				if (isServerActionNotFoundError(error, options.actionId)) return createActionNotFoundResponse(options.actionId, {
+					clearRequestContext: options.clearRequestContext,
+					getAndClearPendingCookies: options.getAndClearPendingCookies
+				});
+				throw error;
+			}
+			if (!isAppServerActionFunction(loadedAction)) return createActionNotFoundResponse(options.actionId, {
 				clearRequestContext: options.clearRequestContext,
 				getAndClearPendingCookies: options.getAndClearPendingCookies
 			});
-			throw error;
+			action = loadedAction;
 		}
-		if (!isAppServerActionFunction(action)) return createActionNotFoundResponse(options.actionId, {
-			clearRequestContext: options.clearRequestContext,
-			getAndClearPendingCookies: options.getAndClearPendingCookies
-		});
 		const temporaryReferences = options.createTemporaryReferenceSet();
 		const args = await options.decodeReply(body, { temporaryReferences });
 		let returnValue;
@@ -599,6 +629,7 @@ async function handleServerActionRscRequest(options) {
 				params: redirectNavigationParams
 			});
 			setCurrentFetchCacheMode(options.resolveRouteFetchCacheMode?.(targetMatch.route) ?? null);
+			setCurrentForceDynamicFetchDefault(options.resolveRouteDynamicConfig?.(targetMatch.route) === "force-dynamic");
 			setCurrentFetchSoftTags(buildServerActionPageTags(targetMatch.route, targetPathname));
 			const element = options.buildPageElement({
 				cleanPathname: targetPathname,
@@ -677,6 +708,7 @@ async function handleServerActionRscRequest(options) {
 			});
 			await options.ensureRouteLoaded?.(actionRerenderTarget.route);
 			setCurrentFetchCacheMode(options.resolveRouteFetchCacheMode?.(actionRerenderTarget.route) ?? null);
+			setCurrentForceDynamicFetchDefault(options.resolveRouteDynamicConfig?.(actionRerenderTarget.route) === "force-dynamic");
 			setCurrentFetchSoftTags(buildServerActionPageTags(actionRerenderTarget.route, options.cleanPathname));
 			element = options.buildPageElement({
 				cleanPathname: options.cleanPathname,

package/dist/server/app-ssr-entry.d.ts

@@ -22,6 +22,7 @@ declare function handleSsr(rscStream: ReadableStream<Uint8Array>, navContext: Na
   capturedRscDataRef?: {
     value: Promise<ArrayBuffer> | null;
   };
+  pprFallbackShellSignal?: AbortSignal;
   formState?: ReactFormState | null;
   basePath?: string;
   /**
@@ -42,6 +43,7 @@ declare function handleSsr(rscStream: ReadableStream<Uint8Array>, navContext: Na
    *  to resolve before returning the HTML stream. Used for static prerender
    *  and ISR cache writes to avoid caching fallback content. */
   waitForAllReady?: boolean;
+  fallbackToErrorDocumentOnShellError?: boolean;
 }): Promise<AppSsrRenderResult>;
 declare const _default: {
   fetch(request: Request): Promise<Response>;

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

@@ -1,23 +1,27 @@
 import "./server-globals.js";
 import { notFoundResponse } from "./http-error-responses.js";
 import { isOpenRedirectShaped } from "./request-pipeline.js";
+import { isPprFallbackShellAbortError } from "../shims/ppr-fallback-shell.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { AppRouterContext } from "../shims/internal/app-router-context.js";
+import { appendAssetDeploymentIdQuery } from "../utils/deployment-id.js";
 import { ServerInsertedHTMLContext, appRouterInstance, clearServerInsertedHTML, getBfcacheIdMapContext, renderServerInsertedHTML, setNavigationContext, useServerInsertedHTML } from "../shims/navigation.js";
 import { runWithNavigationContext } from "../shims/navigation-state.js";
 import { withScriptNonce } from "../shims/script-nonce-context.js";
 import { createInlineScriptTag, createNonceAttribute, escapeHtmlAttr, safeJsonStringify } from "./html.js";
 import { getClientTraceMetadataHTML } from "./client-trace-metadata.js";
+import DefaultGlobalError from "../shims/default-global-error.js";
 import { BfcacheStateKeyMapContext, ElementsContext, Slot } from "../shims/slot.js";
 import { createSsrErrorMetaRenderer } from "./app-ssr-error-meta.js";
 import { createNavigationRuntimeRscMetadataScript, createRscEmbedTransform, createTickBufferedTransform } from "./app-ssr-stream.js";
+import { BeforeInteractiveContext } from "../shims/before-interactive-context.js";
+import { runWithRootParamsScope } from "../shims/root-params.js";
 import { createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap } from "./app-browser-state.js";
 import { RSC_FORM_STATE_GLOBAL } from "./app-browser-hydration.js";
 import { createClientReferencePreloader } from "./app-client-reference-preloader.js";
 import { deferUntilStreamConsumed } from "./app-page-stream.js";
-import { runWithRootParamsScope } from "../shims/root-params.js";
-import { BeforeInteractiveContext } from "../shims/before-interactive-context.js";
+import { renderBeforeInteractiveInlineScripts } from "./before-interactive-head.js";
 import { createInitialDevServerErrorScript } from "./dev-initial-server-error.js";
 import { Fragment, createElement, use } from "react";
 import { renderToReadableStream, renderToStaticMarkup } from "react-dom/server.edge";
@@ -31,6 +35,50 @@ import clientReferences from "virtual:vite-rsc/client-references";
 * the response-layer combine cap.
 */
 const DEFAULT_REACT_MAX_HEADERS_LENGTH = 6e3;
+function isReactDevelopmentRuntime() {
+	if (process.env.NODE_ENV === "production") return false;
+	if (process.env.NODE_ENV === "development") return true;
+	return Function.prototype.toString.call(createElement).includes("getOwner");
+}
+function isStaticPrerenderModule(value) {
+	return typeof value === "object" && value !== null && "prerender" in value && typeof value.prerender === "function";
+}
+async function loadStaticPrerender() {
+	const staticRenderer = await import("react-dom/static.edge");
+	if (isStaticPrerenderModule(staticRenderer)) return staticRenderer.prerender;
+	if (isReactDevelopmentRuntime()) try {
+		const [{ createRequire }, path] = await Promise.all([import("node:module"), import("node:path")]);
+		const reactDomPackageJson = createRequire(import.meta.url).resolve("react-dom/package.json");
+		const reactDomDir = path.dirname(reactDomPackageJson);
+		const devRenderer = await import(path.join(reactDomDir, "cjs/react-dom-server.edge.development.js"));
+		if (isStaticPrerenderModule(devRenderer)) return devRenderer.prerender;
+		const devRendererDefault = typeof devRenderer === "object" && devRenderer !== null && "default" in devRenderer && devRenderer.default;
+		if (isStaticPrerenderModule(devRendererDefault)) return devRendererDefault.prerender;
+		throw new Error("react-dom development renderer did not expose prerender().");
+	} catch (error) {
+		throw new Error("[vinext] Failed to load React static development renderer.", { cause: error });
+	}
+	throw new Error("[vinext] react-dom/static.edge did not expose prerender().");
+}
+function createUtf8Stream(html) {
+	const encoder = new TextEncoder();
+	return new ReadableStream({ start(controller) {
+		controller.enqueue(encoder.encode(html));
+		controller.close();
+	} });
+}
+function buildBootstrapModuleScript(bootstrapModuleUrl, nonce) {
+	if (!bootstrapModuleUrl) return "";
+	return `<script type="module"${createNonceAttribute(nonce)} src="` + escapeHtmlAttr(bootstrapModuleUrl) + "\" id=\"_R_\" async=\"\"><\/script>";
+}
+function renderSsrErrorDocumentShell(bootstrapModuleUrl, nonce) {
+	const html = renderToStaticMarkup(createElement(DefaultGlobalError, { error: null })).replace("<style>", "<style data-vinext-error-shell-style=\"\">");
+	const bootstrapScript = buildBootstrapModuleScript(bootstrapModuleUrl, nonce);
+	if (!bootstrapScript) return createUtf8Stream(`<!DOCTYPE html>${html}`);
+	const documentClose = "</body></html>";
+	if (!html.endsWith(documentClose)) return createUtf8Stream(`<!DOCTYPE html>${html}${bootstrapScript}`);
+	return createUtf8Stream(`<!DOCTYPE html>${html.slice(0, -14)}${bootstrapScript}${documentClose}`);
+}
 const clientReferencePreloader = createClientReferencePreloader({
 	getReferences() {
 		return clientReferences;
@@ -60,42 +108,13 @@ function renderInsertedHtml(insertedElements) {
 	} catch {}
 	return insertedHTML;
 }
-/**
-* Render captured `<Script strategy="beforeInteractive">` inline scripts to
-* HTML, ready to splice immediately after `<head ...>` opens. Each entry has
-* already had its inline content escaped via `escapeInlineContent(..., "script")`
-* inside the Script shim, so this function only quotes the attributes that
-* actually go on the tag (id, nonce, plus the residual passthroughs).
-*
-* Keeping this function colocated with the rest of the head-injection
-* helpers makes it obvious where the boundary is: anything passed through
-* here is being concatenated directly into HTML; treat the inputs
-* accordingly.
-*/
-const VALID_ATTR_NAME = /^[a-zA-Z][\w.-]*$/;
-function renderBeforeInteractiveInlineScripts(scripts) {
-	if (scripts.length === 0) return "";
-	let html = "";
-	for (const script of scripts) {
-		let attrs = "";
-		if (script.id) attrs += ` id="${escapeHtmlAttr(script.id)}"`;
-		attrs += createNonceAttribute(script.nonce);
-		if (script.attributes) for (const [key, value] of Object.entries(script.attributes)) {
-			if (!VALID_ATTR_NAME.test(key)) continue;
-			if (value === true) attrs += ` ${key}`;
-			else if (typeof value === "string") attrs += ` ${key}="${escapeHtmlAttr(value)}"`;
-		}
-		html += `<script${attrs}>${script.innerHTML}<\/script>`;
-	}
-	return html;
-}
 function renderFontHtml(fontData, nonce, options = {}) {
 	if (!fontData) return "";
 	let fontHTML = "";
 	const nonceAttr = createNonceAttribute(nonce);
 	const includeStyles = options.includeStyles ?? true;
-	for (const url of fontData.links ?? []) fontHTML += `<link rel="stylesheet"${nonceAttr} href="${escapeHtmlAttr(url)}" />\n`;
-	for (const preload of fontData.preloads ?? []) fontHTML += `<link rel="preload"${nonceAttr} href="${escapeHtmlAttr(preload.href)}" as="font" type="${escapeHtmlAttr(preload.type)}" crossorigin />\n`;
+	for (const url of fontData.links ?? []) fontHTML += `<link rel="stylesheet"${nonceAttr} href="${escapeHtmlAttr(appendAssetDeploymentIdQuery(url))}" />\n`;
+	for (const preload of fontData.preloads ?? []) fontHTML += `<link rel="preload"${nonceAttr} href="${escapeHtmlAttr(appendAssetDeploymentIdQuery(preload.href))}" as="font" type="${escapeHtmlAttr(preload.type)}" crossorigin />\n`;
 	if (includeStyles && fontData.styles && fontData.styles.length > 0) fontHTML += `<style data-vinext-fonts${nonceAttr}>${fontData.styles.join("\n")}</style>\n`;
 	return fontHTML;
 }
@@ -182,24 +201,50 @@ async function handleSsr(rscStream, navContext, fontData, options) {
 				const ssrRoot = withScriptNonce(createElement(BeforeInteractiveContext.Provider, { value: registerBeforeInteractiveInlineScript }, ssrTree), options?.scriptNonce);
 				const bootstrapModuleUrl = extractBootstrapModuleUrl(await import.meta.viteRsc.loadBootstrapScriptContent("index"));
 				const errorMetaRenderer = createSsrErrorMetaRenderer({ basePath: options?.basePath });
+				const pprFallbackShellSignal = options?.pprFallbackShellSignal;
 				let reactLinkHeader = "";
 				const maxHeadersLength = options?.reactMaxHeadersLength ?? DEFAULT_REACT_MAX_HEADERS_LENGTH;
 				const captureHeaders = maxHeadersLength > 0;
-				const htmlStream = await renderToReadableStream(ssrRoot, {
+				const renderOptions = {
+					bootstrapModules: bootstrapModuleUrl ? [bootstrapModuleUrl] : void 0,
+					formState: options?.formState ?? null,
+					nonce: options?.scriptNonce,
 					onHeaders: captureHeaders ? (headers) => {
 						const link = headers.get("Link");
 						if (link) reactLinkHeader = link;
 					} : void 0,
 					maxHeadersLength: captureHeaders ? maxHeadersLength : void 0,
-					bootstrapModules: bootstrapModuleUrl ? [bootstrapModuleUrl] : void 0,
-					formState: options?.formState ?? null,
-					nonce: options?.scriptNonce,
 					onError(error) {
+						if (pprFallbackShellSignal && isPprFallbackShellAbortError(error)) return;
 						errorMetaRenderer.capture(error);
 						if (error && typeof error === "object" && "digest" in error) return String(error.digest);
 						if (process.env.NODE_ENV === "production" && error) return ssrErrorDigest(getErrorMessage(error) + (error instanceof Error ? error.stack ?? "" : ""));
 					}
-				});
+				};
+				let htmlStream;
+				let shellErrorRecovered = false;
+				if (pprFallbackShellSignal) {
+					const prerender = await loadStaticPrerender();
+					const htmlAbortController = new AbortController();
+					const pendingHtml = prerender(ssrRoot, {
+						...renderOptions,
+						signal: htmlAbortController.signal
+					});
+					setTimeout(() => htmlAbortController.abort(), 0);
+					htmlStream = (await pendingHtml).prelude;
+				} else {
+					let streamingHtmlStream;
+					try {
+						streamingHtmlStream = await renderToReadableStream(ssrRoot, { ...renderOptions });
+						if (options?.waitForAllReady === true) await streamingHtmlStream.allReady;
+						htmlStream = streamingHtmlStream;
+					} catch (error) {
+						streamingHtmlStream?.cancel().catch(() => {});
+						if (options?.fallbackToErrorDocumentOnShellError !== true || options?.waitForAllReady === true || typeof error?.digest === "string") throw error;
+						shellErrorRecovered = true;
+						htmlStream = renderSsrErrorDocumentShell(bootstrapModuleUrl, options?.scriptNonce);
+					}
+				}
 				const inlineCssManifest = globalThis.__VINEXT_INLINE_CSS__;
 				const fontStyles = fontData?.styles ?? [];
 				const mergeFontStylesIntoInlineCss = fontStyles.length > 0 && hasInlineCssManifest(inlineCssManifest);
@@ -221,11 +266,11 @@ async function handleSsr(rscStream, navContext, fontData, options) {
 					return buildHeadInjectionHtml(ssrNavigationContext, bootstrapModuleUrl, options?.formState ?? null, insertedHTML + errorMetaHTML + getTraceMetaHTML() + initialDevServerErrorHTML, fontHTML, options?.scriptNonce);
 				};
 				const getBeforeInteractiveHeadHTML = () => renderBeforeInteractiveInlineScripts(beforeInteractiveInlineScripts);
-				if (options?.waitForAllReady === true) await htmlStream.allReady;
 				return {
 					htmlStream: deferUntilStreamConsumed(htmlStream.pipeThrough(createTickBufferedTransform(rscEmbed, getInsertedHTML, getBeforeInteractiveHeadHTML, inlineCssManifest, inlineCssFontStyles, inlineCssFontStyleFallbackHTML, options?.scriptNonce)), cleanup),
 					metadataReady: Promise.resolve(),
 					capturedRscData: options?.capturedRscDataRef?.value ?? null,
+					shellErrorRecovered,
 					linkHeader: reactLinkHeader
 				};
 			} catch (error) {

package/dist/server/before-interactive-head.d.ts

@@ -0,0 +1,17 @@
+import { BeforeInteractiveInlineScript } from "../shims/before-interactive-context.js";
+
+//#region src/server/before-interactive-head.d.ts
+/**
+ * Render captured `<Script strategy="beforeInteractive">` scripts to HTML,
+ * ready to splice immediately after `<head ...>` opens. Each entry has already
+ * had its inline content escaped via `escapeInlineContent(..., "script")`
+ * inside the Script shim, so this function only quotes the attributes that
+ * actually go on the tag (id, src, nonce, plus the residual passthroughs).
+ *
+ * Keeping this function in its own module makes the boundary obvious: anything
+ * passed through here is being concatenated directly into HTML; treat the
+ * inputs accordingly.
+ */
+declare function renderBeforeInteractiveInlineScripts(scripts: readonly BeforeInteractiveInlineScript[]): string;
+//#endregion
+export { renderBeforeInteractiveInlineScripts };

package/dist/server/before-interactive-head.js

@@ -0,0 +1,35 @@
+import { createNonceAttribute, escapeHtmlAttr } from "./html.js";
+//#region src/server/before-interactive-head.ts
+const VALID_ATTR_NAME = /^[a-zA-Z][\w.-]*$/;
+/**
+* Render captured `<Script strategy="beforeInteractive">` scripts to HTML,
+* ready to splice immediately after `<head ...>` opens. Each entry has already
+* had its inline content escaped via `escapeInlineContent(..., "script")`
+* inside the Script shim, so this function only quotes the attributes that
+* actually go on the tag (id, src, nonce, plus the residual passthroughs).
+*
+* Keeping this function in its own module makes the boundary obvious: anything
+* passed through here is being concatenated directly into HTML; treat the
+* inputs accordingly.
+*/
+function renderBeforeInteractiveInlineScripts(scripts) {
+	if (scripts.length === 0) return "";
+	let html = "";
+	for (const script of scripts) {
+		let attrs = "";
+		if (script.id) attrs += ` id="${escapeHtmlAttr(script.id)}"`;
+		if (script.src) attrs += ` src="${escapeHtmlAttr(script.src)}"`;
+		attrs += createNonceAttribute(script.nonce);
+		if (script.attributes) for (const [key, value] of Object.entries(script.attributes)) {
+			if (!VALID_ATTR_NAME.test(key)) continue;
+			if (key === "data-nscript") continue;
+			if (value === true) attrs += ` ${key}`;
+			else if (typeof value === "string") attrs += ` ${key}="${escapeHtmlAttr(value)}"`;
+		}
+		attrs += ` data-nscript="beforeInteractive"`;
+		html += `<script${attrs}>${script.innerHTML ?? ""}<\/script>`;
+	}
+	return html;
+}
+//#endregion
+export { renderBeforeInteractiveInlineScripts };

package/dist/server/cache-control.js

@@ -19,6 +19,10 @@ function applyCdnResponseHeaders(headers, input) {
 	headers.delete("Cache-Control");
 	const map = getCdnCacheAdapter().buildResponseHeaders(input);
 	for (const [name, value] of Object.entries(map)) {
+		if (value === null) {
+			headers.delete(name);
+			continue;
+		}
 		if (value === "") continue;
 		headers.set(name, value);
 	}

package/dist/server/csp.js

@@ -1,8 +1,5 @@
 //#region src/server/csp.ts
 const ESCAPE_REGEX = /[&><\u2028\u2029]/;
-function matchesDirectiveName(directive, name) {
-	return directive === name || directive.startsWith(`${name} `);
-}
 function getNodeHeaderValue(headers, key) {
 	const value = headers?.[key];
 	if (Array.isArray(value)) return value.join(", ");
@@ -11,7 +8,7 @@ function getNodeHeaderValue(headers, key) {
 }
 function getScriptNonceFromHeader(cspHeaderValue) {
 	const directives = cspHeaderValue.split(";").map((directive) => directive.trim());
-	const directive = directives.find((value) => matchesDirectiveName(value, "script-src")) ?? directives.find((value) => matchesDirectiveName(value, "default-src"));
+	const directive = directives.find((value) => value.startsWith("script-src")) ?? directives.find((value) => value.startsWith("default-src"));
 	if (!directive) return;
 	const nonce = directive.split(" ").slice(1).map((source) => source.trim()).find((source) => source.startsWith("'nonce-") && source.length > 8 && source.endsWith("'"))?.slice(7, -1);
 	if (!nonce) return;

package/dist/server/dev-server.d.ts

@@ -43,7 +43,7 @@ declare function createSSRHandler(server: ViteDevServer, runner: ModuleImporter,
  * `next.config`. When undefined or empty, no meta tags are emitted.
  */
 
-clientTraceMetadata?: readonly string[]): (req: IncomingMessage, res: ServerResponse, url: string, /** Status code override — propagated from middleware rewrite status. */
+clientTraceMetadata?: readonly string[], htmlLimitedBots?: string): (req: IncomingMessage, res: ServerResponse, url: string, /** Status code override — propagated from middleware rewrite status. */
 
 statusCode?: number,
 /**
@@ -53,6 +53,6 @@ statusCode?: number,
  * client-side navigations in the Pages Router.
  */
 
-isDataReq?: boolean) => Promise<void>;
+isDataReq?: boolean, originalUrl?: string) => Promise<void>;
 //#endregion
 export { createSSRHandler, detectLocaleFromHeaders, extractLocaleFromUrl, parseCookieLocale };