vinext 1.1.0 → 1.2.1

package/dist/server/app-browser-state.js

@@ -1,7 +1,7 @@
-import { normalizePathnameForRouteMatch } from "../routing/utils.js";
 import { stripBasePath } from "../utils/base-path.js";
 import { VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_MOUNTED_SLOTS_HEADER } from "./app-rsc-vary.js";
 import { NEXT_ACTION_HEADER, RSC_ACTION_HEADER } from "./headers.js";
+import { normalizePathnameForRouteMatch } from "../routing/utils.js";
 import { normalizePath } from "./normalize-path.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import { getMountedSlotIds, getMountedSlotIdsHeader } from "./app-elements.js";

package/dist/server/app-browser-supplemental-refresh.js

@@ -1,5 +1,5 @@
-import { normalizePathnameForRouteMatch } from "../routing/utils.js";
 import { addBasePathToPathname, removeTrailingSlash, stripBasePath } from "../utils/base-path.js";
+import { normalizePathnameForRouteMatch } from "../routing/utils.js";
 import { normalizePath } from "./normalize-path.js";
 import { APP_INTERCEPTION_CONTEXT_KEY, APP_INTERCEPTION_KEY, APP_SLOT_BINDINGS_KEY, AppElementsWire, normalizeAppElementsSlotBindings } from "./app-elements-wire.js";
 import "./app-elements.js";

package/dist/server/app-middleware.d.ts

@@ -34,6 +34,8 @@ export type ApplyAppMiddlewareOptions = {
    * `trailingSlash`.
    */
   trailingSlash?: boolean;
+  /** next.config `skipTrailingSlashRedirect`, forwarded to `executeMiddleware`. */
+  skipTrailingSlashRedirect?: boolean;
 };
 export type ApplyAppMiddlewareResult = {
   kind: "continue";
@@ -43,6 +45,8 @@ export type ApplyAppMiddlewareResult = {
   /** True when this pathname can match middleware for some request context. */
   pathnameEligible?: boolean;
   rewritten: boolean;
+  /** False when a same-origin rewrite target was outside the basePath. */
+  rewriteHadBasePath?: boolean;
   search: string | null;
 } | {
   kind: "response";
@@ -53,6 +57,13 @@ export type ApplyAppMiddlewareResult = {
   response: Response;
 };
 export declare function isExternalMiddlewareRewrite(rewriteUrl: string, request: Request): boolean;
+/**
+ * The request an external rewrite forwards after middleware ran: the complete
+ * middleware request-header override, so deleted credentials stay deleted.
+ * Flight headers come from the original request, matching Next.js, which
+ * treats them as non-overridable.
+ */
+export declare function requestWithMiddlewareContextHeaders(request: Request, context: AppMiddlewareContext): Request;
 export declare function proxyExternalMiddlewareRewrite(request: Request, rewriteUrl: string, context: AppMiddlewareContext): Promise<Response>;
 export declare function applyAppMiddleware(options: ApplyAppMiddlewareOptions): Promise<ApplyAppMiddlewareResult>;
 //#endregion

package/dist/server/app-middleware.js

@@ -75,8 +75,17 @@ function restoreFlightHeaders(request, source) {
 	}
 	return changed ? cloneRequestWithHeaders(request, headers) : request;
 }
+/**
+* The request an external rewrite forwards after middleware ran: the complete
+* middleware request-header override, so deleted credentials stay deleted.
+* Flight headers come from the original request, matching Next.js, which
+* treats them as non-overridable.
+*/
+function requestWithMiddlewareContextHeaders(request, context) {
+	return restoreFlightHeaders(requestWithMiddlewareRequestHeaders(request, context.requestHeaders ?? context.headers), request);
+}
 async function proxyExternalMiddlewareRewrite(request, rewriteUrl, context) {
-	const proxyRequest = restoreFlightHeaders(requestWithMiddlewareRequestHeaders(request, context.requestHeaders ?? context.headers), request);
+	const proxyRequest = requestWithMiddlewareContextHeaders(request, context);
 	setHeadersContext(null);
 	setNavigationContext(null);
 	const { proxyExternalRequest } = await import("../config/config-matchers.js");
@@ -129,6 +138,7 @@ function applyForwardedMiddlewareContext(request, context) {
 		if (typeof data.s === "number") context.status = data.s;
 		if (typeof data.r === "string" && data.r.length > 0) return {
 			applied: true,
+			rewriteHadBasePath: typeof data.b === "boolean" ? data.b : void 0,
 			rewriteUrl: data.r
 		};
 		return { applied: true };
@@ -143,6 +153,7 @@ async function applyAppMiddleware(options) {
 	let pathnameEligible = forwarded.applied;
 	let cleanPathname = options.cleanPathname;
 	let rewritten = false;
+	let rewriteHadBasePath;
 	let search = null;
 	if (forwarded.rewriteUrl) try {
 		if (isExternalMiddlewareRewrite(forwarded.rewriteUrl, options.request)) {
@@ -168,6 +179,7 @@ async function applyAppMiddleware(options) {
 		const rewriteParsed = new URL(forwarded.rewriteUrl, options.request.url);
 		cleanPathname = rewriteParsed.pathname;
 		rewritten = true;
+		rewriteHadBasePath = forwarded.rewriteHadBasePath;
 		search = rewriteParsed.search;
 	} catch (e) {
 		console.error("[vinext] Failed to apply forwarded middleware rewrite:", e);
@@ -194,6 +206,7 @@ async function applyAppMiddleware(options) {
 				},
 				requestBodyAlreadyIsolated: true,
 				request: middlewareRequest,
+				skipTrailingSlashRedirect: options.skipTrailingSlashRedirect,
 				trailingSlash: options.trailingSlash
 			});
 		} finally {
@@ -243,6 +256,7 @@ async function applyAppMiddleware(options) {
 			const rewriteParsed = new URL(result.rewriteUrl, middlewareRequest.url);
 			cleanPathname = rewriteParsed.pathname;
 			rewritten = true;
+			rewriteHadBasePath = result.rewriteHadBasePath;
 			search = rewriteParsed.search;
 		}
 	}
@@ -258,8 +272,9 @@ async function applyAppMiddleware(options) {
 		matched,
 		pathnameEligible,
 		rewritten,
+		rewriteHadBasePath,
 		search
 	};
 }
 //#endregion
-export { FLIGHT_HEADERS, applyAppMiddleware, isExternalMiddlewareRewrite, proxyExternalMiddlewareRewrite };
+export { FLIGHT_HEADERS, applyAppMiddleware, isExternalMiddlewareRewrite, proxyExternalMiddlewareRewrite, requestWithMiddlewareContextHeaders };

package/dist/server/app-optimistic-routing.js

@@ -1,6 +1,6 @@
 import { isUnknownRecord } from "../utils/record.js";
-import { buildParams, decodeMatchedParams, splitPathnameForRouteMatch } from "../routing/utils.js";
 import { stripBasePath } from "../utils/base-path.js";
+import { buildParams, decodeMatchedParams, splitPathnameForRouteMatch } from "../routing/utils.js";
 import { extractRawRoutePatternParams, matchRoutePattern } from "../routing/route-pattern.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";

package/dist/server/app-page-cache.d.ts

@@ -93,7 +93,7 @@ type ReadAppPageFallbackShellCacheResponseOptions = {
   isEdgeRuntime?: boolean;
   isrDebug?: AppPageDebugLogger;
   isrGet: AppPageCacheGetter;
-  isrHtmlKey: (pathname: string) => string;
+  isrFallbackShellHtmlKey: (pathname: string) => string;
   middlewareHeaders?: Headers | null;
   middlewareStatus?: number | null;
   revalidateSeconds: number;

package/dist/server/app-page-cache.js

@@ -375,7 +375,7 @@ see more here https://nextjs.org/docs/messages/app-static-to-dynamic-error`);
 	return null;
 }
 async function readAppPageFallbackShellCacheResponse(options) {
-	const isrKey = options.isrHtmlKey(options.fallbackPathname);
+	const isrKey = options.isrFallbackShellHtmlKey(options.fallbackPathname);
 	try {
 		const cached = await options.isrGet(isrKey);
 		const cachedValue = getCachedAppPageValue(cached);

package/dist/server/app-page-dispatch.d.ts

@@ -13,7 +13,8 @@ import { AppPageSsrHandler } from "./app-page-stream.js";
 import { AppRenderErrorContextOverrides } from "./app-rsc-error-handler.js";
 import { AppPageCacheSetter, ISRCacheEntry } from "./isr-cache.js";
 import { PprFallbackShellState } from "../shims/ppr-fallback-shell.js";
-import { FetchCacheMode } from "../shims/fetch-cache.js";
+import { FetchCacheMode } from "../shims/fetch-cache-state.js";
+import "../shims/fetch-cache.js";
 import { AppPagePprFallbackCacheShell } from "./app-ppr-fallback-shell.js";
 import { WarmPprFallbackShellCachesOptions } from "./app-ppr-fallback-shell-render.js";
 import { ValidateAppPageDynamicParamsOptions } from "./app-page-request.js";
@@ -197,6 +198,7 @@ export type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
   isRscRequest: boolean;
   isrDebug?: AppPageDebugLogger;
   isrGet: AppPageCacheGetter;
+  isrFallbackShellHtmlKey: (pathname: string) => string;
   isrHtmlKey: (pathname: string) => string;
   isrRscKey: (pathname: string, mountedSlotsHeader?: string | null, renderMode?: AppRscRenderMode, interceptionContext?: string | null, interceptionId?: string | null) => string;
   isrSet: AppPageCacheSetter;

package/dist/server/app-page-dispatch.js

@@ -1,8 +1,9 @@
 import { closeAfterResponse, createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
 import "../utils/protocol-headers.js";
-import { getRequestExecutionContext } from "../shims/request-context.js";
 import { VINEXT_INTERCEPTION_ID_HEADER, VINEXT_RSC_VARY_HEADER } from "./app-rsc-vary.js";
 import "./headers.js";
+import { getRequestExecutionContext } from "../shims/request-context.js";
+import { runInWorkStoreScope } from "../shims/internal/work-store-scope.js";
 import { beginRouteCacheability, isRouteCacheabilityIdentityProbe, isRouteCacheabilityProbe, markRouteCacheabilityPatternDynamic, readRouteCacheabilityState } from "../shims/cacheability-classification.js";
 import { APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL } from "./app-rsc-render-mode.js";
 import { consumeDynamicUsage, consumeInvalidDynamicUsageError, getAndClearPendingCookies, getDraftModeCookieHeader, getHeadersContext, isDraftModeRequest, peekDynamicUsage, peekRenderRequestApiUsage, runWithIsolatedDynamicUsage, setHeadersContext } from "../shims/headers.js";
@@ -150,7 +151,7 @@ async function runAppPageRevalidationContext(options, renderFn) {
 		executionContext: getRequestExecutionContext(),
 		unstableCacheRevalidation: "foreground"
 	});
-	const revalidation = runWithRequestContext(requestContext, async () => {
+	const revalidation = runWithRequestContext(requestContext, () => runInWorkStoreScope(async () => {
 		ensureFetchPatch();
 		setRefreshStaleFetchesInForeground(process.env.VINEXT_PRERENDER === "1");
 		setCurrentFetchSoftTags(buildAppPageTags(options.cleanPathname, [], options.routeSegments));
@@ -160,7 +161,7 @@ async function runAppPageRevalidationContext(options, renderFn) {
 			params: options.params
 		});
 		return await runWithFetchDedupe(renderFn);
-	});
+	}));
 	try {
 		return await revalidation;
 	} finally {
@@ -313,7 +314,7 @@ async function dispatchAppPageInner(options) {
 	});
 	const isNeverStoredPath = options.pprRuntime === void 0 && hasNoManifestAdmissionState(route.pattern);
 	const shouldReadCache = !isRouteCacheabilityProbe() && isCacheEligibleRender && !isNeverStoredPath;
-	const isCacheCandidate = isCacheEligibleRender && isStaticEligible && options.pprRuntime === void 0 && !isNeverStoredPath;
+	const isCacheCandidate = isCacheEligibleRender && isStaticEligible && options.pprFallbackShell === void 0 && !isNeverStoredPath;
 	if (shouldReadCache && isStaticEligible) {
 		traceOperation = resolveAppPageTraceOperation({
 			hasRequestSearchParams,

package/dist/server/app-page-ppr-runtime.js

@@ -34,7 +34,7 @@ async function probePprFallbackShellCache(options, fallbackShells, currentRevali
 			isEdgeRuntime: options.isEdgeRuntime,
 			isrDebug: options.isrDebug,
 			isrGet: options.isrGet,
-			isrHtmlKey: options.isrHtmlKey,
+			isrFallbackShellHtmlKey: options.isrFallbackShellHtmlKey,
 			middlewareHeaders: options.middlewareContext.headers,
 			middlewareStatus: options.middlewareContext.status,
 			revalidateSeconds: currentRevalidateSeconds ?? 0,

package/dist/server/app-page-render-observation.js

@@ -1,5 +1,5 @@
-import { fnv1a64 } from "../utils/hash.js";
 import { normalizeMountedSlotsHeader } from "./app-mounted-slots-header.js";
+import { fnv1a64 } from "../utils/hash.js";
 import { consumeDynamicUsage, consumeInvalidDynamicUsageError, consumeRenderRequestApiUsage } from "../shims/headers.js";
 import { _consumeRequestScopedCacheLife } from "../shims/cache-request-state.js";
 import { consumeDynamicFetchObservations } from "../shims/fetch-cache.js";

package/dist/server/app-page-render.js

@@ -1,8 +1,8 @@
 import { preserveFullyBufferedBodyMetadata } from "./fully-buffered-response.js";
 import { bindRequestContext } from "../shims/unified-request-context.js";
-import { getRequestExecutionContext } from "../shims/request-context.js";
 import { VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_RSC_COMPLETION_METADATA_HEADER } from "./headers.js";
 import { internalServerErrorResponse } from "./http-error-responses.js";
+import { getRequestExecutionContext } from "../shims/request-context.js";
 import { isRouteCacheabilityEvaluation, recordRouteCacheabilityClientTraceMetadataMarker } from "../shims/cacheability-classification.js";
 import { NEVER_CACHE_CONTROL, NO_STORE_CACHE_CONTROL, applyCdnResponseHeaders, isCdnResponsePolicyHeader } from "./cache-control.js";
 import { resolveClientStaleTimeSeconds } from "../utils/cache-control-metadata.js";

package/dist/server/app-page-request.js

@@ -183,24 +183,62 @@ async function generateIndependentStaticParams(sources, primaryParams, requestPa
 		validated
 	};
 }
-async function generateChainedStaticParams(sources) {
-	let generatedParams = [];
+function isStaticParamsRowConsistentWithRequest(row, requestParams) {
+	const sharedKeys = Object.keys(row).filter((key) => requestParams[key] !== void 0);
+	return areStaticParamsAllowed(requestParams, [row], false, sharedKeys);
+}
+function rewritesParentParams(parentParams, item) {
+	return Object.keys(item).some((key) => Object.hasOwn(parentParams, key) && JSON.stringify(item[key]) !== JSON.stringify(parentParams[key]));
+}
+async function generateChainedStaticParams(sources, requestParams, results = /* @__PURE__ */ new Map()) {
+	let generatedRows = [];
+	let skippedParents = false;
+	let needsEveryCombination = false;
 	for (const source of sources) {
-		const hasParentParams = generatedParams.length > 0;
-		const parents = hasParentParams ? generatedParams : [{}];
-		const nextParams = [];
-		for (const parentParams of parents) {
-			const result = await runWithFetchDedupe(() => source.generateStaticParams({ params: parentParams }));
-			if (Array.isArray(result) && result.length > 0) {
-				for (const item of result) if (item !== null && typeof item === "object" && !Array.isArray(item)) nextParams.push({
-					...parentParams,
-					...item
+		let sourceResults = results.get(source);
+		if (!sourceResults) {
+			sourceResults = /* @__PURE__ */ new Map();
+			results.set(source, sourceResults);
+		}
+		const hasParentParams = generatedRows.length > 0;
+		let parents = hasParentParams ? generatedRows : [{
+			params: {},
+			lineage: ""
+		}];
+		const nextRows = [];
+		if (requestParams) {
+			const consistent = parents.filter((row) => isStaticParamsRowConsistentWithRequest(row.params, requestParams));
+			parents = consistent.length > 0 ? consistent : parents.slice(0, 1);
+		}
+		if (hasParentParams && parents.length < generatedRows.length) skippedParents = true;
+		for (const parent of parents) {
+			let result = sourceResults.get(parent.lineage);
+			if (!sourceResults.has(parent.lineage)) {
+				result = await runWithFetchDedupe(() => source.generateStaticParams({ params: parent.params }));
+				sourceResults.set(parent.lineage, result);
+			}
+			if (Array.isArray(result) && result.length > 0) result.forEach((item, index) => {
+				if (item === null || typeof item !== "object" || Array.isArray(item)) return;
+				const row = item;
+				if (skippedParents && rewritesParentParams(parent.params, row)) needsEveryCombination = true;
+				nextRows.push({
+					params: {
+						...parent.params,
+						...row
+					},
+					lineage: `${parent.lineage}/${index}`
 				});
-			} else if (hasParentParams) nextParams.push(parentParams);
+			});
+			else if (hasParentParams) nextRows.push({
+				params: parent.params,
+				lineage: `${parent.lineage}/-`
+			});
 		}
-		generatedParams = nextParams;
+		if (skippedParents && nextRows.length === 0) needsEveryCombination = true;
+		generatedRows = nextRows;
 	}
-	return generatedParams;
+	if (needsEveryCombination) return generateChainedStaticParams(sources, null, results);
+	return generatedRows.map((row) => row.params);
 }
 function normalizeGenerateStaticParams(generateStaticParams) {
 	return (Array.isArray(generateStaticParams) ? generateStaticParams : [generateStaticParams]).flatMap((source) => {
@@ -218,7 +256,7 @@ async function validateAppPageDynamicParams(options) {
 	if (generateStaticParamsSources.length === 0) return notFoundResponse();
 	const chainedSources = generateStaticParamsSources.filter((source) => source.chained);
 	let chainedStaticParams = null;
-	if (chainedSources.length > 0) chainedStaticParams = await generateChainedStaticParams(chainedSources);
+	if (chainedSources.length > 0) chainedStaticParams = await generateChainedStaticParams(chainedSources, generateStaticParamsSources.some((source) => !source.chained) ? null : options.params);
 	const independentChains = /* @__PURE__ */ new Map();
 	for (const source of generateStaticParamsSources.filter((source) => !source.chained)) {
 		const chain = independentChains.get(source.independentChain ?? source) ?? [];

package/dist/server/app-page-route-wiring.js

@@ -1,5 +1,5 @@
-import { fnv1a64 } from "../utils/hash.js";
 import { APP_RSC_RENDER_MODE_PREFETCH_EMPTY, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL } from "./app-rsc-render-mode.js";
+import { fnv1a64 } from "../utils/hash.js";
 import { createInlineScriptTag, escapeHtmlAttr } from "./html.js";
 import { createAppRenderDependency, registerAppElementRenderDependencies, renderAfterAppDependencies, renderAppComponentWithDependencyBarrier } from "./app-render-dependency.js";
 import { APP_LAYOUT_IDS_KEY, APP_ROOT_LAYOUT_KEY, APP_STATIC_SIBLINGS_KEY, AppElementsWire, normalizeAppElementsSlotBindings } from "./app-elements-wire.js";
@@ -289,7 +289,7 @@ function createAppPageRouteBodyMetadata(metadata, pathname, metadataPlacement, t
 		streamedIconKey
 	});
 	const metadataKey = streamedIconKey ? createStreamedIconKey(pathname, renderedMetadataHtml) : "";
-	const parserInsertedMetadataHtml = (streamedIconKey ? renderedMetadataHtml.replaceAll(`<link data-vinext-streamed-icon="${STREAMED_ICON_KEY_PLACEHOLDER}:`, `<link data-vinext-streamed-icon="${escapeHtmlAttr(metadataKey)}:`) : renderedMetadataHtml) + createInlineScriptTag(REINSERT_STREAMED_ICONS_SCRIPT, scriptNonce);
+	const parserInsertedMetadataHtml = (streamedIconKey ? renderedMetadataHtml.replaceAll(`<link data-vinext-streamed-icon="${STREAMED_ICON_KEY_PLACEHOLDER}:`, () => `<link data-vinext-streamed-icon="${escapeHtmlAttr(metadataKey)}:`) : renderedMetadataHtml) + createInlineScriptTag(REINSERT_STREAMED_ICONS_SCRIPT, scriptNonce);
 	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("div", {
 		hidden: true,
 		suppressHydrationWarning: true,

package/dist/server/app-pages-bridge.d.ts

@@ -24,7 +24,6 @@ type AppRouteMatch = {
 type RenderPagesFallbackDependencies = {
   loadPagesEntry: () => Promise<PagesEntry> | PagesEntry;
   buildRequestHeaders: (requestHeaders: Headers, middlewareRequestHeaders: Headers) => Headers | null;
-  decodePathParams: (pathname: string) => string;
   applyRouteHandlerMiddlewareContext: (response: Response, middlewareContext: AppMiddlewareContext) => Response;
   /**
    * Returns the `__prerender_bypass` Set-Cookie header emitted by a
@@ -51,6 +50,7 @@ type RenderPagesFallbackOptions = {
   initialResponseHeaders?: Headers;
   matchKind?: "dynamic" | "static";
   middlewareContext: AppMiddlewareContext;
+  /** Raw (still percent-encoded) Pages route URL; defaults to `url.pathname`. */
   pathname?: string;
   pagesDataRequest?: Request | null;
   request: Request;

package/dist/server/app-pages-bridge.js

@@ -1,5 +1,5 @@
-import { getRequestExecutionContext } from "../shims/request-context.js";
 import { cloneRequestWithHeaders, cloneRequestWithUrl } from "./request-pipeline.js";
+import { getRequestExecutionContext } from "../shims/request-context.js";
 import { beginRouteCacheability } from "../shims/cacheability-classification.js";
 import { mergeHeaders } from "./worker-utils.js";
 import { pagesRouteHasPriorityOverAppRoute } from "./hybrid-route-priority.js";
@@ -19,7 +19,7 @@ function applyPagesMiddlewareContext(response, middlewareContext) {
 */
 async function renderPagesFallback(options, dependencies) {
 	const { allowRscDocumentFallback = false, appRouteMatch = null, isDataRequest = false, isRscRequest, initialResponseHeaders, matchKind, middlewareContext, pathname = options.url.pathname, pagesDataRequest = null, request, url } = options;
-	const { loadPagesEntry, buildRequestHeaders, decodePathParams, applyRouteHandlerMiddlewareContext, getDraftModeCookieHeader } = dependencies;
+	const { loadPagesEntry, buildRequestHeaders, applyRouteHandlerMiddlewareContext, getDraftModeCookieHeader } = dependencies;
 	if (isRscRequest && !allowRscDocumentFallback) return null;
 	const pagesEntry = await loadPagesEntry();
 	const pagesRequestHeaders = middlewareContext.requestHeaders ? buildRequestHeaders(request.headers, middlewareContext.requestHeaders) : null;
@@ -27,8 +27,7 @@ async function renderPagesFallback(options, dependencies) {
 	if (pagesRequestHeaders) pagesRequest = cloneRequestWithHeaders(request, pagesRequestHeaders);
 	const queryIndex = pathname.indexOf("?");
 	const pagesPathname = queryIndex === -1 ? pathname : pathname.slice(0, queryIndex);
-	const pagesSearch = queryIndex === -1 ? url.search || "" : pathname.slice(queryIndex);
-	const pagesUrl = decodePathParams(pagesPathname) + pagesSearch;
+	const pagesUrl = pagesPathname + (queryIndex === -1 ? url.search || "" : pathname.slice(queryIndex));
 	if (pagesPathname.startsWith("/api/") || pagesPathname === "/api") {
 		if (typeof pagesEntry.handleApiRoute !== "function") return null;
 		const hasApiMatcher = typeof pagesEntry.matchApiRoute === "function";

package/dist/server/app-prerender-endpoints.js

@@ -1,5 +1,6 @@
 import "./headers.js";
 import { notFoundResponse } from "./http-error-responses.js";
+import { runInWorkStoreScope, runOutsideWorkStoreScope } from "../shims/internal/work-store-scope.js";
 import { callAppPrerenderStaticParams } from "./app-prerender-static-params.js";
 //#region src/server/app-prerender-endpoints.ts
 const JSON_HEADERS = {
@@ -39,13 +40,13 @@ async function handleStaticParamsEndpoint(request, options) {
 	if (typeof generateStaticParams !== "function") return jsonNullResponse();
 	try {
 		const params = parseParentParams(url.searchParams.get("parentParams"));
-		const result = await callAppPrerenderStaticParams({
+		const result = await runInWorkStoreScope(() => callAppPrerenderStaticParams({
 			fn: generateStaticParams,
 			params,
 			pattern,
 			rejectEmptyResults: url.searchParams.get("rejectEmptyResults") === "1",
 			rootParamNamesByPattern: options.rootParamNamesByPattern ?? {}
-		});
+		}));
 		if (result === null) return jsonNullResponse();
 		return jsonResponse(result);
 	} catch (error) {
@@ -63,10 +64,12 @@ async function handlePagesStaticPathsEndpoint(request, options) {
 	try {
 		const getStaticPaths = findPageRoute(await options.loadPagesRoutes?.(), pattern)?.module?.getStaticPaths;
 		if (typeof getStaticPaths !== "function") return jsonNullResponse();
-		return jsonResponse(await getStaticPaths({
-			locales: parseLocales(url.searchParams.get("locales")),
-			defaultLocale: url.searchParams.get("defaultLocale") ?? ""
-		}));
+		const locales = parseLocales(url.searchParams.get("locales"));
+		const defaultLocale = url.searchParams.get("defaultLocale") ?? "";
+		return jsonResponse(await runOutsideWorkStoreScope(() => getStaticPaths({
+			locales,
+			defaultLocale
+		})));
 	} catch (error) {
 		return jsonResponse({ error: String(error) }, 500);
 	}

package/dist/server/app-render-abort-error.d.ts

@@ -1,3 +1,22 @@
 //#region src/server/app-render-abort-error.d.ts
 export declare function isAppRenderAbortError(error: unknown): boolean;
+export type RenderStreamCancellation = {
+  /** Records the reason the render's output stream ended early with. */
+  record: (reason: unknown) => void;
+  /** Whether React is reporting that recorded cancellation as an error. */
+  isReason: (error: unknown) => boolean;
+};
+/**
+ * Tracks the cancellation of a React render's output stream.
+ *
+ * React aborts the render with the cancel reason and passes it to `onError`
+ * as though the render had failed. Next.js cancels with its own
+ * `ResponseAborted`, which `isAppRenderAbortError` skips, but the reason is
+ * whatever the consumer chose: Workers runtimes cancel a disconnected
+ * response's body with their own (workerd's is `Error("Network connection
+ * lost.")`) and a tee picks its own reason for its source (Node passes both
+ * branches' reasons). So recognize the cancellation itself rather than the
+ * reason's shape.
+ */
+export declare function createRenderStreamCancellation(): RenderStreamCancellation;
 //#endregion

package/dist/server/app-render-abort-error.js

@@ -4,5 +4,35 @@ function isAppRenderAbortError(error) {
 	const name = Reflect.get(error, "name");
 	return name === "AbortError" || name === "ResponseAborted";
 }
+/**
+* Tracks the cancellation of a React render's output stream.
+*
+* React aborts the render with the cancel reason and passes it to `onError`
+* as though the render had failed. Next.js cancels with its own
+* `ResponseAborted`, which `isAppRenderAbortError` skips, but the reason is
+* whatever the consumer chose: Workers runtimes cancel a disconnected
+* response's body with their own (workerd's is `Error("Network connection
+* lost.")`) and a tee picks its own reason for its source (Node passes both
+* branches' reasons). So recognize the cancellation itself rather than the
+* reason's shape.
+*/
+function createRenderStreamCancellation() {
+	let cancelled = false;
+	let cancelReason;
+	return {
+		record: (reason) => {
+			if (cancelled) return;
+			cancelled = true;
+			cancelReason = reason;
+		},
+		isReason: (error) => {
+			if (!cancelled) return false;
+			if (Object.is(error, cancelReason)) return true;
+			if (!(error instanceof Error)) return false;
+			if (cancelReason === void 0) return error.message === "The render was aborted by the server without a reason.";
+			return typeof cancelReason === "object" && cancelReason !== null && error.message === "The render was aborted by the server with a promise.";
+		}
+	};
+}
 //#endregion
-export { isAppRenderAbortError };
+export { createRenderStreamCancellation, isAppRenderAbortError };

package/dist/server/app-request-stage-dispatch.js

@@ -1,8 +1,10 @@
 import "../utils/protocol-headers.js";
 import "./headers.js";
 import { restoreStaticFileSignalFromTransport } from "./static-file-signal.js";
+import { attachRequestCfMetadata } from "./request-pipeline.js";
 import { isDraftModeRequest } from "../shims/headers.js";
 import { getScriptNonceFromHeaderSources } from "./csp.js";
+import { restoreImageOptimizationSignalFromTransport } from "./image-optimization.js";
 import { isRouteTreePrefetchRequest } from "./app-route-tree-prefetch.js";
 import "./app-worker-stages.js";
 //#region src/server/app-request-stage-dispatch.ts
@@ -29,7 +31,8 @@ async function dispatchAppRequestStage(request, ctx, dispatchResponseStage, opti
 	if (!dispatchResponseStage) throw new Error("App request stage requires a response-stage dispatcher");
 	if (appRequestUsesFullResponseGraph(request, options)) {
 		const staticFileSignalToken = crypto.randomUUID();
-		const response = await dispatchResponseStage(request, {
+		const headRequest = request.method === "HEAD";
+		const response = await dispatchResponseStage(headRequest ? attachRequestCfMetadata(new Request(request, { method: "GET" }), request) : request, {
 			kind: "app-full-request",
 			buildId: options.buildId,
 			cacheability: {
@@ -38,6 +41,7 @@ async function dispatchAppRequestStage(request, ctx, dispatchResponseStage, opti
 				resolvedRoutePathname: new URL(request.url).pathname
 			},
 			draftModeCookie: null,
+			headRequest,
 			middlewareCookieOverlay: null,
 			prerenderDiscovery: options.prerenderDiscovery,
 			protocolVersion: 11,
@@ -46,7 +50,7 @@ async function dispatchAppRequestStage(request, ctx, dispatchResponseStage, opti
 			staticFileSignalToken,
 			trustedPrerenderState: options.trustedPrerenderState ?? null
 		}, { cache: "bypass" });
-		return restoreStaticFileSignalFromTransport(response, staticFileSignalToken);
+		return await restoreImageOptimizationSignalFromTransport(await restoreStaticFileSignalFromTransport(response, staticFileSignalToken), staticFileSignalToken);
 	}
 	return options.handleRequest(request, ctx, false, dispatchResponseStage, options.probeMode);
 }

package/dist/server/app-request-stage-independent-entry.js

@@ -1,23 +1,28 @@
 import { VINEXT_PRERENDER_SECRET_HEADER, VINEXT_REVALIDATE_HOST_HEADER } from "../utils/protocol-headers.js";
-import { runWithExecutionContext } from "../shims/request-context.js";
-import "./server-globals.js";
 import "./app-rsc-vary.js";
 import { VINEXT_CACHEABILITY_PROBE_QUERY_PARAM, VINEXT_EXPECTED_WORKER_VERSION_HEADER } from "./headers.js";
 import { badRequestResponse } from "./http-error-responses.js";
-import { cloneRequestWithHeaders, filterInternalHeaders, guardProtocolRelativeUrl } from "./request-pipeline.js";
+import { cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders, guardProtocolRelativeUrl } from "./request-pipeline.js";
+import { assetPrefixPathname } from "../utils/asset-prefix.js";
+import { runWithExecutionContext } from "../shims/request-context.js";
+import "./server-globals.js";
 import { getExplicitCdnCacheAdapter } from "../shims/cdn-cache-state.js";
 import { applyCdnResponseIdentityHeaders, validateCdnRequest } from "./cache-control.js";
 import { registerLazyDataCacheHandler } from "../shims/cache-handler.js";
-import { getImageOptimizer, handleConfiguredImageOptimization, isImageOptimizationPath } from "./image-optimization.js";
+import { getImageOptimizer, readImageOptimizationSignal } from "./image-optimization.js";
 import { consumeFrameworkRequestRoute, traceFrameworkRequest } from "./request-tracing.js";
 import { createStaticAssetRequest, resolveStaticAssetSignal } from "./worker-utils.js";
 import { readTrustedPrerenderStateFromHeaders } from "./prerender-route-params.js";
+import { resolveClientBuildFile } from "./client-build-files.js";
 import { createWorkerRevalidationContext } from "./worker-revalidation-context.js";
 import { createWorkerPrerenderDiscoveryContext, createWorkerPrerenderReadinessResponse } from "./worker-prerender-discovery.js";
-import requestRscHandler, { __ensureHybridPagesApplication, __ensureInstrumentation, __imageAllowedWidths, __imageConfig, __prerenderSecret } from "virtual:vinext-app-request-entry";
+import requestRscHandler, { __assetPrefix, __basePath, __clientBuildFiles, __ensureHybridPagesApplication, __ensureInstrumentation, __imageAllowedWidths, __imageConfig, __prerenderSecret } from "virtual:vinext-app-request-entry";
 import * as configuredCdnCacheAdapters from "virtual:vinext-cdn-cache-adapter";
 import { registerConfiguredImageOptimizer } from "virtual:vinext-image-adapters";
 //#region src/server/app-request-stage-independent-entry.ts
+const clientBuildFiles = new Set(__clientBuildFiles);
+const assetPathPrefix = assetPrefixPathname(__assetPrefix);
+const rejectResponseStage = () => Promise.resolve(new Response(null, { status: 404 }));
 function handleRequestStage(request, env, ctx, dispatchResponseStage) {
 	const originalRequest = request;
 	const handleStage = async () => {
@@ -42,6 +47,7 @@ async function handleRequest(request, env, platformCtx, dispatchResponseStage, a
 		(await import("virtual:vinext-cache-adapters")).registerConfiguredCacheAdapters(env);
 	});
 	registerConfiguredImageOptimizer(env);
+	const requestCtx = ctx;
 	ctx = createWorkerPrerenderDiscoveryContext(ctx, request, __prerenderSecret);
 	const readinessResponse = createWorkerPrerenderReadinessResponse(ctx, request);
 	let didValidateCdnRequest = false;
@@ -61,7 +67,7 @@ async function handleRequest(request, env, platformCtx, dispatchResponseStage, a
 			probeRoute = readWorkerCacheabilityProbeRoute(request);
 			const probeUrl = new URL(request.url);
 			probeUrl.searchParams.delete(VINEXT_CACHEABILITY_PROBE_QUERY_PARAM);
-			request = new Request(probeUrl, request);
+			request = cloneRequestWithUrl(request, probeUrl.href);
 		}
 	}
 	if (!didValidateCdnRequest) {
@@ -69,7 +75,7 @@ async function handleRequest(request, env, platformCtx, dispatchResponseStage, a
 		if (cdnValidationResponse) return cdnValidationResponse;
 	}
 	const url = new URL(request.url);
-	if (isImageOptimizationPath(url.pathname) && assets && getImageOptimizer()) return handleConfiguredImageOptimization(request, (assetPath) => Promise.resolve(assets.fetch(new Request(new URL(assetPath, request.url)))), __imageAllowedWidths, __imageConfig);
+	const servesImages = Boolean(assets) && getImageOptimizer() !== null;
 	const protocolRelativeGuard = guardProtocolRelativeUrl(url.pathname, url.search);
 	if (protocolRelativeGuard) return protocolRelativeGuard;
 	try {
@@ -77,6 +83,10 @@ async function handleRequest(request, env, platformCtx, dispatchResponseStage, a
 	} catch {
 		return badRequestResponse();
 	}
+	if (assets && (request.method === "GET" || request.method === "HEAD")) {
+		const clientBuildFile = resolveClientBuildFile(url.pathname, __basePath, clientBuildFiles);
+		if (clientBuildFile) return await assets.fetch(createStaticAssetRequest(clientBuildFile, request));
+	}
 	const trustedPrerenderState = readTrustedPrerenderStateFromHeaders(request.headers, __prerenderSecret);
 	const filteredHeaders = ctx.isInternalPagesRevalidation ? new Headers(request.headers) : filterInternalHeaders(request.headers);
 	filteredHeaders.delete(VINEXT_PRERENDER_SECRET_HEADER);
@@ -94,8 +104,18 @@ async function handleRequest(request, env, platformCtx, dispatchResponseStage, a
 	};
 	const handle = () => requestRscHandler(request, ctx, trackedDispatchResponseStage, probeMode, ctx.isPrerenderPathDiscovery === true, trustedPrerenderState);
 	let response = await runWithExecutionContext(ctx, handle);
-	if (assets) {
-		const assetResponse = await resolveStaticAssetSignal(response, { fetchAsset: (path) => Promise.resolve(assets.fetch(createStaticAssetRequest(path, request))) });
+	const imageSignal = servesImages ? readImageOptimizationSignal(response) : null;
+	if (imageSignal && assets) {
+		const { fetchSignalledPublicFile, serveWorkerImageOptimization } = await import("./worker-image-optimization.js");
+		response = await serveWorkerImageOptimization(request, imageSignal, __imageAllowedWidths, __imageConfig, {
+			assets,
+			basePath: __basePath,
+			assetPathPrefix,
+			clientBuildFiles,
+			fetchPublicFile: async (sourceRequest) => fetchSignalledPublicFile(await runWithExecutionContext(requestCtx, () => requestRscHandler(sourceRequest, requestCtx, rejectResponseStage, null, false, null)), sourceRequest, assets)
+		});
+	} else if (assets) {
+		const assetResponse = await resolveStaticAssetSignal(response, { fetchAsset: (path, requestHeaders) => Promise.resolve(assets.fetch(createStaticAssetRequest(path, request, requestHeaders))) });
 		if (assetResponse) response = assetResponse;
 	}
 	if (probeMode && probeRoute && !responseStageDispatched) {