vinext 0.1.0 → 0.1.2

package/dist/server/app-rsc-handler.js

@@ -2,7 +2,7 @@ import { createRequestContext, runWithRequestContext } from "../shims/unified-re
 import { hasBasePath } from "../utils/base-path.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import { ACTION_REVALIDATED_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER } from "./headers.js";
-import { isExternalUrl, matchRedirect, matchRewrite, proxyExternalRequest, requestContextFromRequest, sanitizeDestination } from "../config/config-matchers.js";
+import { isExternalUrl, matchRedirect, matchRewrite, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, sanitizeDestination } from "../config/config-matchers.js";
 import { notFoundResponse } from "./http-error-responses.js";
 import { applyConfigHeadersToResponse, cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders, normalizeTrailingSlash, resolvePublicFileRoute, validateImageUrl } from "./request-pipeline.js";
 import { headersContextFromRequest } from "../shims/headers.js";
@@ -14,12 +14,12 @@ import { isImageOptimizationPath } from "./image-optimization.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import "./app-page-response.js";
 import { prerenderRouteParamsPayloadMatchesRoute, readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
-import { pickRootParams, setRootParams } from "../shims/root-params.js";
-import { flattenErrorCauses } from "../utils/error-cause.js";
 import { applyAppMiddleware } from "./app-middleware.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
 import { buildPostMwRequestContext } from "./app-post-middleware-context.js";
+import { pickRootParams, setRootParams } from "../shims/root-params.js";
 import { handleAppPrerenderEndpoint } from "./app-prerender-endpoints.js";
+import { flattenErrorCauses } from "../utils/error-cause.js";
 import { finalizeAppRscResponse } from "./app-rsc-response-finalizer.js";
 import { normalizeRscRequest } from "./app-rsc-request-normalization.js";
 import { handleMetadataRouteRequest } from "./metadata-route-response.js";
@@ -113,7 +113,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const redirect = matchRedirect(matchPathname(stripRscSuffix(pathname)), options.configRedirects, preMiddlewareRequestContext, basePathState);
 	if (redirect) {
 		const destination = sanitizeDestination(redirectDestinationWithBasePath(redirect.destination, options.basePath));
-		const location = isRscRequest && request.headers.get("RSC") === "1" ? await createRscRedirectLocation(destination, request) : destination;
+		const location = isRscRequest && request.headers.get("RSC") === "1" ? await createRscRedirectLocation(destination, request) : preserveRedirectDestinationQuery(destination, url.search);
 		return new Response(null, {
 			status: redirect.permanent ? 308 : 307,
 			headers: { Location: location }
@@ -302,6 +302,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const pageResponse = await options.dispatchMatchedPage({
 		clientReuseManifest,
 		cleanPathname,
+		displayPathname: canonicalPathname,
 		formState,
 		actionError,
 		actionFailed,

package/dist/server/app-rsc-response-finalizer.js

@@ -3,9 +3,9 @@ import { hasBasePath, stripBasePath } from "../utils/base-path.js";
 import "./headers.js";
 import { normalizePath } from "./normalize-path.js";
 import { applyConfigHeadersToResponse } from "./request-pipeline.js";
+import { applyCdnResponseHeaders } from "./cache-control.js";
 import { VINEXT_RSC_VARY_HEADER } from "./app-rsc-cache-busting.js";
 import { normalizeDefaultLocalePathname } from "./pages-i18n.js";
-import { applyCdnResponseHeaders } from "./cache-control.js";
 import { mergeVaryHeader } from "./middleware-response-headers.js";
 //#region src/server/app-rsc-response-finalizer.ts
 /**

package/dist/server/app-rsc-route-matching.d.ts

@@ -1,6 +1,12 @@
 import { RoutePatternParams } from "../routing/route-pattern.js";
 
 //#region src/server/app-rsc-route-matching.d.ts
+/**
+ * Sentinel slot key used for sibling-style interception entries.
+ * When a matched intercept carries this key, the render layer replaces the
+ * route's main page element instead of a parallel slot.
+ */
+declare const SIBLING_PAGE_INTERCEPT_SLOT_KEY = "__vinext_page_intercept";
 type AppRscRouteParams = RoutePatternParams;
 type AppRscInterceptForMatching = {
   targetPattern: string;
@@ -25,15 +31,27 @@ type AppRscInterceptForMatching = {
   sourceMatchPattern?: string;
   interceptLayouts: readonly unknown[];
   page: unknown;
+  __pageLoader?: (() => Promise<unknown>) | null;
   params: readonly string[];
 };
 type AppRscSlotForMatching = {
   id?: string | null;
   intercepts?: readonly AppRscInterceptForMatching[];
 };
+type AppRscSiblingInterceptForMatching = {
+  targetPattern: string;
+  sourceMatchPattern: string | null;
+  slotId: string | null;
+  interceptLayouts: readonly unknown[];
+  page: unknown;
+  __pageLoader?: (() => Promise<unknown>) | null;
+  params: readonly string[];
+};
 type AppRscRouteForMatching = {
+  pattern: string;
   patternParts: string[];
   slots?: Record<string, AppRscSlotForMatching>;
+  siblingIntercepts?: AppRscSiblingInterceptForMatching[];
 };
 type AppRscInterceptMatch = AppRscInterceptLookupEntry & {
   matchedParams: AppRscRouteParams;
@@ -47,6 +65,7 @@ type AppRscInterceptLookupEntry = {
   sourceMatchPatternParts: string[] | null;
   interceptLayouts: readonly unknown[];
   page: unknown;
+  __pageLoader?: (() => Promise<unknown>) | null;
   params: readonly string[];
   slotId: string | null;
 };
@@ -59,4 +78,4 @@ declare function createAppRscRouteMatcher<Route extends AppRscRouteForMatching>(
 };
 declare function matchAppRscRoutePattern(urlParts: string[], patternParts: string[]): AppRscRouteParams | null;
 //#endregion
-export { createAppRscRouteMatcher, matchAppRscRoutePattern };
+export { SIBLING_PAGE_INTERCEPT_SLOT_KEY, createAppRscRouteMatcher, matchAppRscRoutePattern };

package/dist/server/app-rsc-route-matching.js

@@ -2,6 +2,12 @@ import { splitPathnameForRouteMatch } from "../routing/utils.js";
 import { buildRouteTrie, trieMatch } from "../routing/route-trie.js";
 import { matchRoutePattern, matchRoutePatternPrefix } from "../routing/route-pattern.js";
 //#region src/server/app-rsc-route-matching.ts
+/**
+* Sentinel slot key used for sibling-style interception entries.
+* When a matched intercept carries this key, the render layer replaces the
+* route's main page element instead of a parallel slot.
+*/
+const SIBLING_PAGE_INTERCEPT_SLOT_KEY = "__vinext_page_intercept";
 function createRouteParams() {
 	return Object.create(null);
 }
@@ -54,17 +60,18 @@ function matchInterceptSource(sourceParts, entry) {
 	return matchRoutePatternPrefix(sourceParts, patternParts);
 }
 function createInterceptLookup(routes) {
+	const patternToIndex = new Map(routes.map((r, i) => [r.pattern, i]));
 	const interceptLookup = [];
 	for (let routeIndex = 0; routeIndex < routes.length; routeIndex++) {
 		const route = routes[routeIndex];
-		if (!route.slots) continue;
-		for (const [slotKey, slotModule] of Object.entries(route.slots)) {
+		if (route.slots) for (const [slotKey, slotModule] of Object.entries(route.slots)) {
 			if (!slotModule.intercepts) continue;
 			for (const intercept of slotModule.intercepts) {
 				const sourceMatchPattern = intercept.sourceMatchPattern ?? null;
 				const sourceMatchPatternParts = sourceMatchPattern ? sourceMatchPattern.split("/").filter(Boolean) : null;
+				const ownerRouteIndex = sourceMatchPattern !== null ? patternToIndex.get(sourceMatchPattern) ?? routeIndex : routeIndex;
 				interceptLookup.push({
-					sourceRouteIndex: routeIndex,
+					sourceRouteIndex: ownerRouteIndex,
 					slotKey,
 					slotId: typeof slotModule.id === "string" ? slotModule.id : null,
 					targetPattern: intercept.targetPattern,
@@ -73,10 +80,28 @@ function createInterceptLookup(routes) {
 					sourceMatchPatternParts,
 					interceptLayouts: intercept.interceptLayouts,
 					page: intercept.page,
+					__pageLoader: intercept.__pageLoader,
 					params: intercept.params
 				});
 			}
 		}
+		if (route.siblingIntercepts) for (const intercept of route.siblingIntercepts) {
+			const sourceMatchPattern = intercept.sourceMatchPattern ?? null;
+			const sourceMatchPatternParts = sourceMatchPattern ? sourceMatchPattern.split("/").filter(Boolean) : null;
+			interceptLookup.push({
+				sourceRouteIndex: routeIndex,
+				slotKey: SIBLING_PAGE_INTERCEPT_SLOT_KEY,
+				slotId: typeof intercept.slotId === "string" ? intercept.slotId : null,
+				targetPattern: intercept.targetPattern,
+				targetPatternParts: intercept.targetPattern.split("/").filter(Boolean),
+				sourceMatchPattern,
+				sourceMatchPatternParts,
+				interceptLayouts: intercept.interceptLayouts,
+				page: intercept.page,
+				__pageLoader: intercept.__pageLoader,
+				params: intercept.params
+			});
+		}
 	}
 	return interceptLookup;
 }
@@ -87,4 +112,4 @@ function mergeMatchedParams(sourceParams, targetParams) {
 	return Object.assign(createRouteParams(), sourceParams, targetParams);
 }
 //#endregion
-export { createAppRscRouteMatcher, matchAppRscRoutePattern };
+export { SIBLING_PAGE_INTERCEPT_SLOT_KEY, createAppRscRouteMatcher, matchAppRscRoutePattern };

package/dist/server/app-server-action-execution.d.ts

@@ -31,6 +31,17 @@ type AppServerActionRoute = {
   pattern: string;
   routeHandler?: unknown;
   routeSegments?: readonly string[];
+  params?: readonly string[] | null;
+  slots?: Readonly<Record<string, {
+    default?: {
+      default?: unknown;
+    } | null;
+    page?: {
+      default?: unknown;
+    } | null;
+    slotPatternParts?: readonly string[] | null;
+    slotParamNames?: readonly string[] | null;
+  }>> | null;
 };
 /**
  * Side-effect headers captured during a progressive (no-JS) server action's
@@ -108,6 +119,15 @@ type HandleProgressiveServerActionRequestOptions = {
   decodeFormState: AppServerActionFormStateDecoder;
   getAndClearPendingCookies: () => string[];
   getDraftModeCookieHeader: () => string | null | undefined;
+  /**
+   * Whether the posted-to route resolves to an App Router *page* (as opposed to
+   * a route handler or no match). Multipart form POSTs to a page are always
+   * server-action attempts in Next.js, so a body that decodes to no action must
+   * surface as 404 action-not-found rather than rendering the page. Route
+   * handlers (which run *after* this dispatch in vinext) legitimately receive
+   * raw multipart POSTs, so they must still fall through. See issue #1340.
+   */
+  hasPageRoute: boolean;
   maxActionBodySize: number;
   middlewareHeaders: Headers | null;
   readFormDataWithLimit: ReadFormDataWithLimit;
@@ -143,7 +163,8 @@ type HandleServerActionRscRequestOptions<TElement, TRoute extends AppServerActio
   isRscRequest: boolean;
   loadServerAction: (actionId: string) => Promise<unknown>;
   matchRoute: (pathname: string) => AppServerActionMatch<TRoute> | null;
-  maxActionBodySize: number;
+  maxActionBodySize: number; /** Verbatim `serverActions.bodySizeLimit` config string (e.g. "2mb") for the body-exceeded error. */
+  maxActionBodySizeLabel: string;
   middlewareHeaders: Headers | null;
   middlewareStatus: number | null | undefined;
   mountedSlotsHeader: string | null;

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

@@ -15,6 +15,7 @@ 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 { 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";
@@ -110,6 +111,15 @@ function isRequestBodyTooLarge(error) {
 	return error instanceof Error && error.message === "Request body too large";
 }
 /**
+* Build the error thrown when a server-action request body exceeds the
+* configured size limit. Matches Next.js' `Body exceeded {limit} limit.`
+* message + docs link (action-handler.ts) verbatim — including the original
+* config string (e.g. "2mb") — so it reads identically in logs.
+*/
+function createBodyExceededError(limitLabel) {
+	return /* @__PURE__ */ new Error(`Body exceeded ${limitLabel} limit.\nTo configure the body size limit for Server Actions, see: https://nextjs.org/docs/app/api-reference/next-config-js/serverActions#bodysizelimit`);
+}
+/**
 * Collapse repeated `cookies().set(name, ...)` / `cookies().delete(name)`
 * calls down to the last value per name, matching Next.js'
 * `MutableRequestCookiesAdapter` semantics. Next.js stores response cookies in
@@ -325,7 +335,13 @@ async function handleProgressiveServerActionRequest(options) {
 			return payloadResponse;
 		}
 		const action = await options.decodeAction(body);
-		if (!isAppServerActionFunction(action)) return null;
+		if (!isAppServerActionFunction(action)) {
+			if (options.hasPageRoute) return createActionNotFoundResponse(null, {
+				clearRequestContext: options.clearRequestContext,
+				getAndClearPendingCookies: options.getAndClearPendingCookies
+			});
+			return null;
+		}
 		let actionRedirect = null;
 		let actionError = void 0;
 		let actionFailed = false;
@@ -411,23 +427,66 @@ async function handleProgressiveServerActionRequest(options) {
 		return internalServerErrorResponse(process.env.NODE_ENV === "production" ? void 0 : "Server action parsing failed: " + getServerActionFailureMessage(error));
 	}
 }
+/**
+* Render the response for a fetch (client-invoked) server action whose request
+* body exceeds the configured `serverActions.bodySizeLimit`.
+*
+* Next.js does not return a bare 413 here: it throws the body-exceeded error
+* before the action runs, then — for fetch actions — emits a Flight response
+* with status 500 carrying the rejected action result, so the nearest client
+* error boundary catches it (see action-handler.ts, the `isFetchAction` branch
+* of the generic error path). vinext mirrors that by rendering a Flight stream
+* with `returnValue: { ok: false }` and no page root (the action never ran, so
+* nothing was revalidated and the page render is skipped). A bare 413 plain
+* response would bypass the boundary and surface the wrong status/content-type.
+*/
+async function renderFetchActionBodyExceededResponse(options) {
+	const error = createBodyExceededError(options.maxActionBodySizeLabel);
+	console.error("[vinext] Server action error:", error);
+	options.reportRequestError(normalizeError(error), {
+		path: options.cleanPathname,
+		method: options.request.method,
+		headers: Object.fromEntries(options.request.headers.entries())
+	}, {
+		routerKind: "App Router",
+		routePath: options.cleanPathname,
+		routeType: "action"
+	});
+	getAndClearActionRevalidationKind();
+	options.getAndClearPendingCookies();
+	const returnValue = {
+		ok: false,
+		data: options.sanitizeErrorForClient(error)
+	};
+	const temporaryReferences = options.createTemporaryReferenceSet();
+	const onRenderError = options.createRscOnErrorHandler(options.request, options.cleanPathname, options.cleanPathname);
+	const rscStream = await options.renderToReadableStream({ returnValue }, {
+		temporaryReferences,
+		onError: onRenderError
+	});
+	const headers = new Headers({
+		"Content-Type": VINEXT_RSC_CONTENT_TYPE,
+		Vary: VINEXT_RSC_VARY_HEADER
+	});
+	applyEdgeRuntimeHeader(headers, options.isEdgeRuntime);
+	mergeMiddlewareResponseHeaders(headers, options.middlewareHeaders);
+	applyRscCompatibilityIdHeader(headers);
+	return createServerActionRscResponse(rscStream, {
+		status: 500,
+		headers
+	}, options.clearRequestContext);
+}
 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) {
-		options.clearRequestContext();
-		return payloadTooLargeResponse();
-	}
+	if (parseInt(options.request.headers.get("content-length") || "0", 10) > options.maxActionBodySize) return renderFetchActionBodyExceededResponse(options);
 	try {
 		let body;
 		try {
 			body = options.contentType.startsWith("multipart/form-data") ? await options.readFormDataWithLimit(options.request, options.maxActionBodySize) : await options.readBodyWithLimit(options.request, options.maxActionBodySize);
 		} catch (error) {
-			if (isRequestBodyTooLarge(error)) {
-				options.clearRequestContext();
-				return payloadTooLargeResponse();
-			}
+			if (isRequestBodyTooLarge(error)) return renderFetchActionBodyExceededResponse(options);
 			throw error;
 		}
 		const payloadResponse = await validateServerActionPayload(body);
@@ -533,10 +592,11 @@ async function handleServerActionRscRequest(options) {
 				url: redirectTarget
 			});
 			setHeadersContext(headersContextFromRequest(redirectRenderRequest));
+			const redirectNavigationParams = resolveAppPageNavigationParams(targetMatch.route, targetMatch.params, targetPathname, null);
 			options.setNavigationContext({
 				pathname: targetPathname,
 				searchParams: redirectTarget.searchParams,
-				params: targetMatch.params
+				params: redirectNavigationParams
 			});
 			setCurrentFetchCacheMode(options.resolveRouteFetchCacheMode?.(targetMatch.route) ?? null);
 			setCurrentFetchSoftTags(buildServerActionPageTags(targetMatch.route, targetPathname));
@@ -599,7 +659,7 @@ async function handleServerActionRscRequest(options) {
 		let errorPattern = match ? match.route.pattern : options.cleanPathname;
 		if (match) {
 			const { route: actionRoute, params: actionParams } = match;
-			const actionRerenderTarget = resolveAppPageActionRerenderTarget({
+			const actionRerenderTarget = await resolveAppPageActionRerenderTarget({
 				cleanPathname: options.cleanPathname,
 				currentParams: actionParams,
 				currentRoute: actionRoute,
@@ -609,10 +669,11 @@ async function handleServerActionRscRequest(options) {
 				isRscRequest: options.isRscRequest,
 				toInterceptOpts: options.toInterceptOpts
 			});
+			const resolvedActionNavigationParams = resolveAppPageNavigationParams(actionRerenderTarget.route, actionRerenderTarget.navigationParams, options.cleanPathname, actionRerenderTarget.interceptOpts);
 			options.setNavigationContext({
 				pathname: options.cleanPathname,
 				searchParams: options.searchParams,
-				params: actionRerenderTarget.navigationParams
+				params: resolvedActionNavigationParams
 			});
 			await options.ensureRouteLoaded?.(actionRerenderTarget.route);
 			setCurrentFetchCacheMode(options.resolveRouteFetchCacheMode?.(actionRerenderTarget.route) ?? null);

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

@@ -30,6 +30,12 @@ declare function handleSsr(rscStream: ReadableStream<Uint8Array>, navContext: Na
    * SSR head. Undefined or empty disables emission entirely.
    */
   clientTraceMetadata?: readonly string[];
+  /**
+   * Maximum total length (in characters) of the preload `Link` header React
+   * emits during SSR. `0` disables emission. From `reactMaxHeadersLength` in
+   * `next.config`. Undefined falls back to React's own default.
+   */
+  reactMaxHeadersLength?: number;
   rootParams?: RootParams; /** Dev-only: original server error to surface in the browser overlay. */
   initialDevServerError?: unknown;
   /** When true, wait for the full React tree (including Suspense boundaries)

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

@@ -12,18 +12,25 @@ import { getClientTraceMetadataHTML } from "./client-trace-metadata.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 { createInitialDevServerErrorScript } from "./dev-initial-server-error.js";
 import { Fragment, createElement, use } from "react";
 import { renderToReadableStream, renderToStaticMarkup } from "react-dom/server.edge";
 import { createFromReadableStream } from "@vitejs/plugin-rsc/ssr";
 import clientReferences from "virtual:vite-rsc/client-references";
 //#region src/server/app-ssr-entry.ts
+/**
+* Default cap for the preload `Link` header, matching Next.js's
+* `defaultConfig.reactMaxHeadersLength`. Used when no config value threads
+* through (e.g. error-boundary renders) so React's internal cap agrees with
+* the response-layer combine cap.
+*/
+const DEFAULT_REACT_MAX_HEADERS_LENGTH = 6e3;
 const clientReferencePreloader = createClientReferencePreloader({
 	getReferences() {
 		return clientReferences;
@@ -175,7 +182,15 @@ 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 });
+				let reactLinkHeader = "";
+				const maxHeadersLength = options?.reactMaxHeadersLength ?? DEFAULT_REACT_MAX_HEADERS_LENGTH;
+				const captureHeaders = maxHeadersLength > 0;
 				const htmlStream = await renderToReadableStream(ssrRoot, {
+					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,
@@ -210,7 +225,8 @@ async function handleSsr(rscStream, navContext, fontData, options) {
 				return {
 					htmlStream: deferUntilStreamConsumed(htmlStream.pipeThrough(createTickBufferedTransform(rscEmbed, getInsertedHTML, getBeforeInteractiveHeadHTML, inlineCssManifest, inlineCssFontStyles, inlineCssFontStyleFallbackHTML, options?.scriptNonce)), cleanup),
 					metadataReady: Promise.resolve(),
-					capturedRscData: options?.capturedRscDataRef?.value ?? null
+					capturedRscData: options?.capturedRscDataRef?.value ?? null,
+					linkHeader: reactLinkHeader
 				};
 			} catch (error) {
 				cleanup();

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

@@ -89,6 +89,12 @@ function fixPreloadAs(html) {
 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;
+const CLOSE_TAG_RES = {
+	script: /<\/script\s*>/i,
+	style: /<\/style\s*>/i,
+	textarea: /<\/textarea\s*>/i,
+	title: /<\/title\s*>/i
+};
 function getHtmlAttribute(tag, name) {
 	const attrRe = /\s([^\s"'=<>`]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
 	let match;
@@ -141,7 +147,9 @@ function findTrailingOpenHtmlRewriteExcludedRegionStart(html) {
 		}
 		const tagName = match[1]?.toLowerCase();
 		if (!tagName) continue;
-		const close = new RegExp(`</${tagName}\\s*>`, "i").exec(html.slice(HTML_REWRITE_EXCLUDED_REGION_START_RE.lastIndex));
+		const closeTagRe = CLOSE_TAG_RES[tagName];
+		if (!closeTagRe) continue;
+		const close = closeTagRe.exec(html.slice(HTML_REWRITE_EXCLUDED_REGION_START_RE.lastIndex));
 		if (!close) return start;
 		HTML_REWRITE_EXCLUDED_REGION_START_RE.lastIndex += close.index + close[0].length;
 	}

package/dist/server/dev-lockfile.js

@@ -1,3 +1,4 @@
+import { normalizePathSeparators } from "../utils/path.js";
 import fs from "node:fs";
 import path from "node:path";
 //#region src/server/dev-lockfile.ts
@@ -98,7 +99,7 @@ function formatAlreadyRunningError(opts) {
 	if (!existing) return [
 		"Another vinext dev server appears to be running in this directory.",
 		"",
-		`Stale lock file: ${path.relative(cwd, lockfilePath)}`,
+		`Stale lock file: ${normalizePathSeparators(path.relative(cwd, lockfilePath))}`,
 		"Remove it manually if no server is running, then re-run `vinext dev`."
 	].join("\n");
 	const killCommand = process.platform === "win32" ? `taskkill /PID ${existing.pid} /F` : `kill ${existing.pid}`;

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

@@ -36,7 +36,7 @@ declare function parseCookieLocale(req: IncomingMessage, i18nConfig: NextI18nCon
  * 4. Render the component to HTML
  * 5. Wrap in _document shell and send response
  */
-declare function createSSRHandler(server: ViteDevServer, runner: ModuleImporter, routes: Route[], pagesDir: string, i18nConfig?: NextI18nConfig | null, fileMatcher?: ValidFileMatcher, basePath?: string, trailingSlash?: boolean, hasMiddleware?: boolean,
+declare function createSSRHandler(server: ViteDevServer, runner: ModuleImporter, routes: Route[], pagesDir: string, i18nConfig?: NextI18nConfig | null, fileMatcher?: ValidFileMatcher, basePath?: string, trailingSlash?: boolean, hasMiddleware?: boolean, hasRewrites?: boolean,
 /**
  * Allow-list of OpenTelemetry propagation keys to emit as `<meta>` tags
  * in the SSR head. Sourced from `experimental.clientTraceMetadata` in