vinext 1.1.0 → 1.2.0

package/dist/plugins/worker-use-server.d.ts

@@ -0,0 +1,25 @@
+import { Plugin } from "vite";
+//#region src/plugins/worker-use-server.d.ts
+type RscPluginModule = typeof import("@vitejs/plugin-rsc");
+/**
+ * Replace `"use server"` modules in browser Web Worker bundles with Server
+ * Function reference proxies.
+ *
+ * Vite bundles every worker in a fresh plugin container built from
+ * `worker.plugins`, so @vitejs/plugin-rsc's `rsc:use-server` transform never
+ * sees worker modules in production builds and the module bodies would be
+ * emitted verbatim. Next.js compiles workers as part of the browser graph,
+ * where `"use server"` exports become `createServerReference(...)` proxies.
+ * This mirrors the client-environment branch of `rsc:use-server` with the
+ * same reference keys, without claiming references.
+ *
+ * The worker realm has no router to dispatch Server Function calls. Next.js's
+ * `callServer` dispatches inside `startTransition`, so the dispatch error is
+ * reported globally and the call's promise never settles; the worker
+ * references reproduce that instead of reaching the server.
+ */
+export declare function createWorkerUseServerPlugins(options: {
+  rscPluginModule: Promise<RscPluginModule>;
+  rscPluginPath: string;
+}): Promise<Plugin[]>;
+//#endregion

package/dist/plugins/worker-use-server.js

@@ -0,0 +1,129 @@
+import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { escapeRegExp } from "../utils/regex.js";
+import { magicStringTransformResult } from "./transform-result.js";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import { pathToFileURL } from "node:url";
+import { parseAstAsync, transformWithOxc } from "vite";
+//#region src/plugins/worker-use-server.ts
+const WORKER_REFERENCE_RUNTIME_ID = "\0vinext:worker-server-reference";
+const WORKER_REFERENCE_RUNTIME_ID_RE = /^\0vinext:worker-server-reference$/;
+function workerReferenceRuntime(browserRuntime) {
+	return `import { createServerReference } from ${JSON.stringify(browserRuntime)};
+
+function callServer() {
+  return new Promise(() => {
+    reportError(new Error("Server Functions cannot be called from a browser Web Worker."));
+  });
+}
+
+export function createWorkerServerReference(id, name) {
+  return createServerReference(id, callServer, undefined, undefined, name);
+}
+`;
+}
+/** A module-local binding that cannot collide with any name in `code`. */
+function uniqueBinding(code, base) {
+	let binding = base;
+	while (code.includes(binding)) binding += "_";
+	return binding;
+}
+function isPlainFilePath(id) {
+	return !/[\0?#]/.test(id) && fs.existsSync(id);
+}
+function withPositionedError(ctx, run) {
+	return Promise.resolve().then(run).catch((error) => {
+		if (error instanceof Error && "pos" in error && typeof error.pos === "number") ctx.error(error.message, error.pos);
+		throw error;
+	});
+}
+/**
+* Replace `"use server"` modules in browser Web Worker bundles with Server
+* Function reference proxies.
+*
+* Vite bundles every worker in a fresh plugin container built from
+* `worker.plugins`, so @vitejs/plugin-rsc's `rsc:use-server` transform never
+* sees worker modules in production builds and the module bodies would be
+* emitted verbatim. Next.js compiles workers as part of the browser graph,
+* where `"use server"` exports become `createServerReference(...)` proxies.
+* This mirrors the client-environment branch of `rsc:use-server` with the
+* same reference keys, without claiming references.
+*
+* The worker realm has no router to dispatch Server Function calls. Next.js's
+* `callServer` dispatches inside `startTransition`, so the dispatch error is
+* reported globally and the call's promise never settles; the worker
+* references reproduce that instead of reaching the server.
+*/
+async function createWorkerUseServerPlugins(options) {
+	const rscRequire = createRequire(options.rscPluginPath);
+	const importRscModule = (specifier) => import(pathToFileURL(rscRequire.resolve(specifier)).href);
+	const browserRuntime = pathToFileURL(rscRequire.resolve("@vitejs/plugin-rsc/react/browser")).href;
+	const [transforms, rscCore] = await Promise.all([importRscModule("@vitejs/plugin-rsc/transforms"), importRscModule("@vitejs/plugin-rsc/core/plugin")]);
+	let manager;
+	const useServerPlugin = {
+		name: "vinext:worker-use-server",
+		async configResolved(config) {
+			// @vitejs/plugin-rsc's plugin API (and its reference manager) lives.
+			const mainConfig = config.mainConfig;
+			manager = (await options.rscPluginModule).getPluginApi(mainConfig ?? config)?.manager;
+		},
+		resolveId: {
+			filter: { id: WORKER_REFERENCE_RUNTIME_ID_RE },
+			handler: (source) => source
+		},
+		load: {
+			filter: { id: WORKER_REFERENCE_RUNTIME_ID_RE },
+			handler: () => workerReferenceRuntime(browserRuntime)
+		},
+		transform: {
+			filter: { code: "use server" },
+			async handler(code, id) {
+				let ast = await parseAstAsync(code);
+				if (!transforms.hasDirective(ast.body, "use server")) return null;
+				if (!manager) throw new Error("vinext: cannot compile a \"use server\" module in a Web Worker without @vitejs/plugin-rsc.");
+				const expanded = await withPositionedError(this, () => transforms.transformExpandExportAll({
+					code,
+					ast,
+					importer: id,
+					resolve: async (source, importer) => (await this.resolve(source, importer))?.id,
+					load: async (target) => {
+						if (!isPlainFilePath(target)) throw new Error(`vinext: a "use server" module imported by a Web Worker cannot \`export *\` from ${JSON.stringify(target)}; re-export its names explicitly.`);
+						this.addWatchFile(target);
+						const source = await fs.promises.readFile(target, "utf-8");
+						return parseAstAsync((await transformWithOxc(source, target, { sourcemap: false })).code);
+					}
+				}));
+				if (expanded) {
+					code = expanded.code;
+					ast = await parseAstAsync(code);
+				}
+				const { referenceKey } = manager.serverReferences.resolve(id, "rsc");
+				const runtime = uniqueBinding(code, "$$vinextWorkerReference");
+				const result = await withPositionedError(this, () => transforms.transformDirectiveProxyExport(ast, {
+					code,
+					directive: "use server",
+					rejectNonAsyncFunction: true,
+					runtime: (name) => `${runtime}(${JSON.stringify(`${referenceKey}#${name}`)}, ${JSON.stringify(name)})`
+				}));
+				if (!result?.output.hasChanged()) return null;
+				result.output.prepend(`import { createWorkerServerReference as ${runtime} } from ${JSON.stringify(WORKER_REFERENCE_RUNTIME_ID)};\n`);
+				return magicStringTransformResult(result.output);
+			}
+		}
+	};
+	const patchHook = rscCore.default().find((plugin) => plugin.name === "rsc:patch-react-server-dom-webpack")?.transform;
+	if (!patchHook || typeof patchHook !== "object") throw new Error("vinext: @vitejs/plugin-rsc no longer exposes its Flight client patch plugin.");
+	const flightClientDir = path.dirname(rscRequire.resolve("@vitejs/plugin-rsc/vendor/react-server-dom/client.browser"));
+	return [{
+		name: "vinext:worker-patch-react-server-dom",
+		transform: {
+			filter: {
+				id: new RegExp(`^${escapeRegExp(`${toSlash(flightClientDir)}/`)}`),
+				code: "__webpack_require__"
+			},
+			handler: patchHook.handler
+		}
+	}, useServerPlugin];
+}
+//#endregion
+export { createWorkerUseServerPlugins };

package/dist/server/api-handler.d.ts

@@ -13,5 +13,6 @@ export declare function handleApiRoute(runner: ModuleImporter, req: IncomingMess
   trustedRevalidateOrigin?: string;
   allowedRevalidateHeaderKeys?: readonly string[];
   trailingSlash?: boolean;
+  skipTrailingSlashRedirect?: boolean;
 }): Promise<boolean>;
 //#endregion

package/dist/server/api-handler.js

@@ -237,7 +237,8 @@ async function handleApiRoute(runner, req, res, url, apiRoutes, nextConfig) {
 			const nextRequest = new NextRequest(createEdgeApiRequest(req, res, url, params, nextConfig), nextConfig ? { nextConfig: {
 				basePath: nextConfig.basePath,
 				i18n: nextConfig.i18n ?? void 0,
-				trailingSlash: nextConfig.trailingSlash
+				trailingSlash: nextConfig.trailingSlash,
+				skipTrailingSlashRedirect: nextConfig.skipTrailingSlashRedirect
 			} } : void 0);
 			const handlerResponse = await tracePagesApiHandler(route.pattern, () => apiModule.default(nextRequest));
 			if (!(handlerResponse instanceof Response)) throw new Error("Edge API route did not return a Response");

package/dist/server/app-browser-action-result.d.ts

@@ -25,7 +25,7 @@ export declare function isServerActionResult<TRoot>(value: unknown): value is Ap
 export declare function shouldClearClientNavigationCachesForServerActionResult<TRoot>(result: AppBrowserServerActionResult<TRoot> | TRoot, revalidation?: ServerActionRevalidationKind): boolean;
 export declare function parseServerActionRevalidationHeader(headers: Pick<Headers, "get">): ServerActionRevalidationKind;
 export declare function resolveServerActionOperationLane(revalidation: ServerActionRevalidationKind): Extract<OperationLane, "refresh" | "server-action">;
-export declare function normalizeServerActionThrownValue(data: unknown, responseStatus: number): unknown;
+export declare function normalizeServerActionThrownValue(data: unknown, responseStatus: number): Promise<unknown>;
 export declare function shouldSyncServerActionHttpFallbackHead<TRoot>(result: AppBrowserServerActionResult<TRoot> | TRoot): boolean;
 export declare function readInvalidServerActionResponseError(response: Pick<Response, "headers" | "status" | "text">, hasRedirectLocation: boolean): Promise<Error | null>;
 export type ServerActionResultResponseFactsInput = {

package/dist/server/app-browser-action-result.js

@@ -41,8 +41,15 @@ function createServerActionHttpFallbackError(status) {
 	const error = /* @__PURE__ */ new Error(status === 404 ? "NEXT_NOT_FOUND" : `NEXT_HTTP_ERROR_FALLBACK;${status}`);
 	return Object.assign(error, { digest });
 }
-function normalizeServerActionThrownValue(data, responseStatus) {
-	return createServerActionHttpFallbackError(responseStatus) ?? data;
+async function normalizeServerActionThrownValue(data, responseStatus) {
+	const fallbackError = createServerActionHttpFallbackError(responseStatus);
+	if (fallbackError) return fallbackError;
+	try {
+		await data;
+	} catch (error) {
+		return error;
+	}
+	return data;
 }
 function shouldSyncServerActionHttpFallbackHead(result) {
 	if (!isServerActionResult(result) || result.root !== void 0) return false;

package/dist/server/app-browser-navigation-controller.js

@@ -583,7 +583,7 @@ function createAppBrowserNavigationController(deps = {}) {
 			} else notifyDiscardedServerActionRevalidation(lifecycleOptions);
 		} else if (decision.disposition === "no-commit") notifyDiscardedServerActionRevalidation(lifecycleOptions);
 		if (returnValue) {
-			if (!returnValue.ok) throw returnValue.data;
+			if (!returnValue.ok) throw await returnValue.data;
 			return returnValue.data;
 		}
 	}

package/dist/server/app-browser-server-action-client.js

@@ -123,7 +123,7 @@ async function invokeClientServerAction(id, args, actionInitiation, deps) {
 			return deps.commitSameUrlNavigatePayload(Promise.resolve(AppElementsWire.decode(result.root)), actionInitiation, returnValue, revalidation, renderedPathAndSearch);
 		}
 		if (result.returnValue) {
-			if (!result.returnValue.ok) throw normalizeServerActionThrownValue(result.returnValue.data, fetchResponse.status);
+			if (!result.returnValue.ok) throw await normalizeServerActionThrownValue(result.returnValue.data, fetchResponse.status);
 			return result.returnValue.data;
 		}
 		return;

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-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

@@ -3,6 +3,7 @@ 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 { 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-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

@@ -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,4 +1,5 @@
 import "./headers.js";
+import { runInWorkStoreScope, runOutsideWorkStoreScope } from "../shims/internal/work-store-scope.js";
 import { notFoundResponse } from "./http-error-responses.js";
 import { callAppPrerenderStaticParams } from "./app-prerender-static-params.js";
 //#region src/server/app-prerender-endpoints.ts
@@ -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-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);
 }