vinext 1.0.1 → 1.2.0

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

@@ -1,24 +1,28 @@
 import { VINEXT_PRERENDER_SECRET_HEADER, VINEXT_REVALIDATE_HOST_HEADER } from "../utils/protocol-headers.js";
+import { assetPrefixPathname } from "../utils/asset-prefix.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, notFoundResponse } from "./http-error-responses.js";
-import { isOpenRedirectShaped } from "./open-redirect.js";
-import { cloneRequestWithHeaders, filterInternalHeaders } from "./request-pipeline.js";
+import { badRequestResponse } from "./http-error-responses.js";
+import { cloneRequestWithHeaders, filterInternalHeaders, guardProtocolRelativeUrl } from "./request-pipeline.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 () => {
@@ -43,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;
@@ -70,13 +75,18 @@ 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);
-	if (isOpenRedirectShaped(url.pathname)) return notFoundResponse();
+	const servesImages = Boolean(assets) && getImageOptimizer() !== null;
+	const protocolRelativeGuard = guardProtocolRelativeUrl(url.pathname, url.search);
+	if (protocolRelativeGuard) return protocolRelativeGuard;
 	try {
 		decodeURIComponent(url.pathname);
 	} 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) {

package/dist/server/app-response-header-provenance.d.ts

@@ -3,6 +3,8 @@
 export declare function markFrameworkLinkHeaders(headers: Headers, linkHeader: string | string[] | null | undefined): void;
 /** Whether the response carries renderer-owned Link values that config may prepend to. */
 export declare function hasFrameworkLinkHeaders(headers: Headers): boolean;
+/** The renderer-owned part of the response's Link header, without middleware's. */
+export declare function getFrameworkLinkHeader(headers: Headers): string | null;
 /** Mark Link values returned by an Edge route handler after config and middleware. */
 export declare function markEdgeRouteHandlerLinkHeaders(headers: Headers, linkHeader: string | null | undefined): void;
 /** Whether config must precede a later framework or Edge-handler Link value. */

package/dist/server/app-response-header-provenance.js

@@ -1,17 +1,22 @@
 import { preserveFullyBufferedBodyMetadata } from "./fully-buffered-response.js";
 import "../shims/unified-request-context.js";
 //#region src/server/app-response-header-provenance.ts
-const frameworkLinkHeaders = /* @__PURE__ */ new WeakSet();
+const frameworkLinkHeaders = /* @__PURE__ */ new WeakMap();
 const edgeRouteHandlerLinkHeaders = /* @__PURE__ */ new WeakSet();
 const APP_RESPONSE_STAGE_LINK_PROVENANCE_HEADER = "x-vinext-app-stage-post-config-link";
 /** Mark response headers whose Link value was emitted by the App page renderer. */
 function markFrameworkLinkHeaders(headers, linkHeader) {
-	if (linkHeader && (typeof linkHeader === "string" || linkHeader.length > 0)) frameworkLinkHeaders.add(headers);
+	const value = Array.isArray(linkHeader) ? linkHeader.join(", ") : linkHeader;
+	if (value) frameworkLinkHeaders.set(headers, value);
 }
 /** Whether the response carries renderer-owned Link values that config may prepend to. */
 function hasFrameworkLinkHeaders(headers) {
 	return frameworkLinkHeaders.has(headers);
 }
+/** The renderer-owned part of the response's Link header, without middleware's. */
+function getFrameworkLinkHeader(headers) {
+	return frameworkLinkHeaders.get(headers) ?? null;
+}
 /** Mark Link values returned by an Edge route handler after config and middleware. */
 function markEdgeRouteHandlerLinkHeaders(headers, linkHeader) {
 	if (linkHeader) edgeRouteHandlerLinkHeaders.add(headers);
@@ -22,7 +27,8 @@ function hasPostConfigLinkHeaders(headers) {
 }
 /** Preserve Link provenance when a response wrapper reconstructs a Response. */
 function copyLinkHeaderProvenance(source, target) {
-	if (frameworkLinkHeaders.has(source)) frameworkLinkHeaders.add(target);
+	const frameworkLink = frameworkLinkHeaders.get(source);
+	if (frameworkLink !== void 0) frameworkLinkHeaders.set(target, frameworkLink);
 	if (edgeRouteHandlerLinkHeaders.has(source)) edgeRouteHandlerLinkHeaders.add(target);
 }
 /** Serialize otherwise process-local Link provenance across a response-stage transport. */
@@ -56,4 +62,4 @@ function consumeResponseStageLinkProvenance(response) {
 	};
 }
 //#endregion
-export { consumeResponseStageLinkProvenance, copyLinkHeaderProvenance, hasFrameworkLinkHeaders, hasPostConfigLinkHeaders, markEdgeRouteHandlerLinkHeaders, markFrameworkLinkHeaders, serializeResponseStageLinkProvenance };
+export { consumeResponseStageLinkProvenance, copyLinkHeaderProvenance, getFrameworkLinkHeader, hasFrameworkLinkHeaders, hasPostConfigLinkHeaders, markEdgeRouteHandlerLinkHeaders, markFrameworkLinkHeaders, serializeResponseStageLinkProvenance };

package/dist/server/app-response-stage-entry.js

@@ -1,8 +1,11 @@
 import { createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
 import { runWithExecutionContext } from "../shims/request-context.js";
+import { runInWorkStoreScope } from "../shims/internal/work-store-scope.js";
 import { serializeStaticFileSignalForTransport } from "./static-file-signal.js";
+import { attachRequestCfMetadata } from "./request-pipeline.js";
 import { validateCdnRequest } from "./cache-control.js";
 import { ensureFetchPatch } from "../shims/fetch-cache.js";
+import { serializeImageOptimizationSignalForTransport } from "./image-optimization.js";
 import { serializeResponseStageLinkProvenance } from "./app-response-header-provenance.js";
 import { attachFrameworkRequestError, attachFrameworkRequestRoute, captureFrameworkRequestRoute, clearFrameworkRequestError } from "./request-tracing.js";
 import { isAppWorkerResponseStageProps } from "./app-worker-stages.js";
@@ -26,10 +29,11 @@ async function invokeCacheFunction(invocation, env, platformCtx, dispatchRequest
 		executionContext,
 		rootParams: invocation.rootParams
 	});
-	await runWithRequestContext(context, () => invokeRegisteredCacheFunction(invocation, loadServerAction));
+	await runWithRequestContext(context, () => runInWorkStoreScope(() => invokeRegisteredCacheFunction(invocation, loadServerAction)));
 }
 async function handleResponseStage(request, env, platformCtx, props, dispatchRequestStage, options = { cache: "bypass" }) {
 	if (!isAppWorkerResponseStageProps(props)) return new Response("Invalid vinext App response stage", { status: 400 });
+	if (props.kind === "app-full-request" && props.headRequest) request = attachRequestCfMetadata(new Request(request, { method: "HEAD" }), request);
 	if (props.requestOrigin !== new URL(request.url).origin) return new Response("Invalid vinext App response stage", { status: 400 });
 	const currentBuildId = process.env.__VINEXT_BUILD_ID ?? null;
 	if (props.buildId !== currentBuildId) return new Response("Incompatible vinext App response stage", { status: 409 });
@@ -41,6 +45,10 @@ async function handleResponseStage(request, env, platformCtx, props, dispatchReq
 		...ctx,
 		isPrerenderPathDiscovery: true
 	};
+	else if (props.kind === "hybrid-pages" && options.regeneratesStoredEntry === true) ctx = {
+		...ctx,
+		isStoredEntryRegeneration: true
+	};
 	return withResponseStageCacheability({
 		buildId: process.env.__VINEXT_BUILD_ID,
 		cache: options.cache,
@@ -76,7 +84,7 @@ async function handleResponseStage(request, env, platformCtx, props, dispatchReq
 				failure = error;
 				result = new Response("Internal Server Error", { status: 500 });
 			}
-			const serialized = serializeStaticFileSignalForTransport(result, props.staticFileSignalToken);
+			const serialized = serializeImageOptimizationSignalForTransport(serializeStaticFileSignalForTransport(result, props.staticFileSignalToken), props.staticFileSignalToken);
 			return attachFrameworkRequestRoute(failed ? attachFrameworkRequestError(serialized, failure) : clearFrameworkRequestError(serialized), route);
 		}
 		const render = () => rscHandler.handleResponseStage(request, cacheabilityContext, props, options);

package/dist/server/app-route-handler-cache.d.ts

@@ -19,6 +19,7 @@ type ReadAppRouteHandlerCacheOptions = {
   handlerFn: AppRouteHandlerFunction;
   i18n?: NextI18nConfig | null;
   trailingSlash?: boolean;
+  skipTrailingSlashRedirect?: boolean;
   isAutoHead: boolean;
   appendResponseLink?: boolean;
   isrDebug?: AppRouteDebugLogger;

package/dist/server/app-route-handler-cache.js

@@ -49,6 +49,7 @@ async function readAppRouteHandlerCacheResponse(options) {
 								handlerFn: options.handlerFn,
 								i18n: options.i18n,
 								trailingSlash: options.trailingSlash,
+								skipTrailingSlashRedirect: options.skipTrailingSlashRedirect,
 								markDynamicUsage: options.markDynamicUsage,
 								params: options.params === null ? null : makeThenableParams(options.params),
 								request: new Request(options.requestUrl, { method: "GET" }),

package/dist/server/app-route-handler-dispatch.d.ts

@@ -31,6 +31,7 @@ type DispatchAppRouteHandlerOptions = {
   isrRouteKey: (pathname: string) => string;
   isrSet: RouteHandlerCacheSetter;
   trailingSlash?: boolean;
+  skipTrailingSlashRedirect?: boolean;
   middlewareContext: RouteHandlerMiddlewareContext;
   middlewareRequestHeaders?: Headers | null;
   /**

package/dist/server/app-route-handler-dispatch.js

@@ -1,6 +1,7 @@
 import { closeAfterResponse, createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
 import "../utils/protocol-headers.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
+import { runInWorkStoreScope } from "../shims/internal/work-store-scope.js";
 import { reportRequestError } from "./instrumentation.js";
 import { beginRouteCacheability, getRouteCacheabilityDynamicReason } from "../shims/cacheability-classification.js";
 import { applyCdnResponseBuildIdentityHeaders } from "./cache-control.js";
@@ -9,12 +10,12 @@ import { markDynamicUsage } from "../shims/internal/headers-state.js";
 import { consumeDynamicUsage, getActiveDraftModeState, getAndClearPendingCookies, getDraftModeCookieHeader, isDraftModeRequest, setHeadersAccessPhase } from "../shims/headers.js";
 import { _drainPendingRevalidations } from "../shims/cache-request-state.js";
 import { ensureFetchPatch, getCollectedFetchTags, setCurrentFetchCacheMode, setCurrentFetchRevalidate, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
+import { resolveAppRouteHandlerFetchCacheMode } from "./app-segment-config.js";
 import { setNavigationContext } from "../shims/navigation-context-state.js";
 import { makeThenableParams } from "../shims/thenable-params.js";
 import { traceResponseStart } from "./response-start-tracing.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
 import { applyRouteHandlerMiddlewareContext, finalizeRouteHandlerResponse } from "./app-route-handler-response.js";
-import { resolveAppRouteHandlerFetchCacheMode } from "./app-segment-config.js";
 import "../shims/navigation.js";
 import { isKnownDynamicAppRoute, isValidHTTPMethod } from "./app-route-handler-runtime.js";
 import { getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, hasNonStaticAppRouteHandlerMethods, resolveAppRouteHandlerMethod, shouldReadAppRouteHandlerCache } from "./app-route-handler-policy.js";
@@ -41,7 +42,7 @@ async function runInRouteHandlerRevalidationContext(options, renderFn) {
 		executionContext: getRequestExecutionContext(),
 		unstableCacheRevalidation: "foreground"
 	});
-	const revalidation = runWithRequestContext(requestContext, async () => {
+	const revalidation = runWithRequestContext(requestContext, () => runInWorkStoreScope(async () => {
 		ensureFetchPatch();
 		setCurrentFetchSoftTags(buildRouteHandlerPageCacheTags(options.cleanPathname, [], options.routeSegments));
 		setCurrentFetchCacheMode(options.fetchCacheMode);
@@ -52,7 +53,7 @@ async function runInRouteHandlerRevalidationContext(options, renderFn) {
 		} finally {
 			await _drainPendingRevalidations();
 		}
-	});
+	}));
 	try {
 		await revalidation;
 	} finally {
@@ -122,6 +123,7 @@ async function dispatchAppRouteHandlerImpl(options) {
 			handlerFn: resolvedHandlerFn,
 			i18n: options.i18n,
 			trailingSlash: options.trailingSlash,
+			skipTrailingSlashRedirect: options.skipTrailingSlashRedirect,
 			isAutoHead,
 			appendResponseLink,
 			isrDebug: options.isrDebug,
@@ -184,6 +186,7 @@ async function dispatchAppRouteHandlerImpl(options) {
 			handlerFn: resolvedHandlerFn,
 			i18n: options.i18n,
 			trailingSlash: options.trailingSlash,
+			skipTrailingSlashRedirect: options.skipTrailingSlashRedirect,
 			isAutoHead,
 			initialDraftModeCookie,
 			isDraftMode,

package/dist/server/app-route-handler-execution.d.ts

@@ -47,6 +47,7 @@ type RunAppRouteHandlerOptions = {
   i18n?: NextI18nConfig | null;
   isDraftMode?: boolean;
   trailingSlash?: boolean;
+  skipTrailingSlashRedirect?: boolean;
   markDynamicUsage: MarkAppRouteDynamicUsageFn;
   middlewareRequestHeaders?: Headers | null;
   /**

package/dist/server/app-route-handler-execution.js

@@ -112,6 +112,7 @@ async function runAppRouteHandler(options) {
 		basePath: options.basePath,
 		i18n: options.i18n,
 		trailingSlash: options.trailingSlash,
+		skipTrailingSlashRedirect: options.skipTrailingSlashRedirect,
 		middlewareHeaders: options.middlewareRequestHeaders,
 		onDynamicAccess() {
 			options.markDynamicUsage();

package/dist/server/app-route-handler-runtime.d.ts

@@ -17,13 +17,16 @@ export declare function buildRouteHandlerAllowHeader(exportedMethods: readonly s
 export declare function isKnownDynamicAppRoute(pattern: string): boolean;
 export declare function markKnownDynamicAppRoute(pattern: string): void;
 type RequestDynamicAccess = "request.headers" | "request.cookies" | "request.cf" | "request.ip" | "request.geo" | "request.url" | "request.body" | "request.blob" | "request.bytes" | "request.json" | "request.text" | "request.arrayBuffer" | "request.formData";
-type NextUrlDynamicAccess = "nextUrl.search" | "nextUrl.searchParams" | "nextUrl.url" | "nextUrl.href" | "nextUrl.toJSON" | "nextUrl.toString" | "nextUrl.origin";
+type NextUrlDynamicAccess = "nextUrl.search" | "nextUrl.searchParams" | "nextUrl.url" | "nextUrl.href" | "nextUrl.toJSON" | "nextUrl.toString" | "nextUrl.origin" | HostDerivedNextUrlDynamicAccess;
+type HostDerivedNextUrlDynamicAccess = "nextUrl.protocol" | "nextUrl.username" | "nextUrl.password" | "nextUrl.host" | "nextUrl.hostname" | "nextUrl.port" | DomainLocaleNextUrlDynamicAccess;
+type DomainLocaleNextUrlDynamicAccess = "nextUrl.locale" | "nextUrl.defaultLocale" | "nextUrl.domainLocale";
 type AppRouteDynamicRequestAccess = RequestDynamicAccess | NextUrlDynamicAccess;
 type AppRouteRequestMode = "auto" | "force-static" | "error";
 type TrackedAppRouteRequestOptions = {
   basePath?: string;
   i18n?: NextI18nConfig | null;
   trailingSlash?: boolean;
+  skipTrailingSlashRedirect?: boolean;
   middlewareHeaders?: Headers | null;
   onDynamicAccess?: (access: AppRouteDynamicRequestAccess) => void;
   requestMode?: AppRouteRequestMode;

package/dist/server/app-route-handler-runtime.js

@@ -64,11 +64,12 @@ function getRequestProperty(target, prop, receiver, builtInProperties) {
 	return bindMethodIfNeeded(Reflect.get(target, prop, bindingTarget), bindingTarget);
 }
 function buildNextConfig(options) {
-	if (!options.basePath && !options.i18n && !options.trailingSlash) return null;
+	if (!options.basePath && !options.i18n && !options.trailingSlash && !options.skipTrailingSlashRedirect) return null;
 	return {
 		basePath: options.basePath,
 		i18n: options.i18n ?? void 0,
-		trailingSlash: options.trailingSlash
+		trailingSlash: options.trailingSlash,
+		skipTrailingSlashRedirect: options.skipTrailingSlashRedirect
 	};
 }
 function createForceStaticNextRequest(input, nextConfig) {
@@ -128,21 +129,41 @@ function createTrackedAppRouteRequest(request, options = {}) {
 		didAccessDynamicRequest = true;
 		options.onDynamicAccess?.(access);
 	};
+	const isNextDynamicNextUrlProperty = (prop) => {
+		switch (prop) {
+			case "search":
+			case "searchParams":
+			case "url":
+			case "href":
+			case "toJSON":
+			case "toString":
+			case "origin": return true;
+			default: return false;
+		}
+	};
+	const hasI18nDomains = (options.i18n?.domains?.length ?? 0) > 0;
+	const isHostDerivedNextUrlProperty = (prop) => {
+		switch (prop) {
+			case "protocol":
+			case "username":
+			case "password":
+			case "host":
+			case "hostname":
+			case "port": return true;
+			case "locale":
+			case "defaultLocale":
+			case "domainLocale": return hasI18nDomains;
+			default: return false;
+		}
+	};
 	const wrapNextUrl = (nextUrl) => {
 		return new Proxy(nextUrl, { get(target, prop) {
-			switch (prop) {
-				case "search":
-				case "searchParams":
-				case "url":
-				case "href":
-				case "toJSON":
-				case "toString":
-				case "origin":
-					markDynamicAccess(`nextUrl.${String(prop)}`);
-					return bindMethodIfNeeded(Reflect.get(target, prop, target), target);
-				case "clone": return () => wrapNextUrl(target.clone());
-				default: return bindMethodIfNeeded(Reflect.get(target, prop, target), target);
+			if (isNextDynamicNextUrlProperty(prop) || isHostDerivedNextUrlProperty(prop)) {
+				markDynamicAccess(`nextUrl.${String(prop)}`);
+				return bindMethodIfNeeded(Reflect.get(target, prop, target), target);
 			}
+			if (prop === "clone") return () => wrapNextUrl(target.clone());
+			return bindMethodIfNeeded(Reflect.get(target, prop, target), target);
 		} });
 	};
 	const wrapForceStaticNextUrl = (nextUrl) => {
@@ -165,18 +186,18 @@ function createTrackedAppRouteRequest(request, options = {}) {
 		throw new Error(options.staticGenerationErrorMessage?.(expression) ?? `Route handler with \`dynamic = "error"\` used ${expression}.`);
 	};
 	const wrapRequireStaticNextUrl = (nextUrl) => {
+		let staticNextUrl = null;
 		return new Proxy(nextUrl, { get(target, prop) {
-			switch (prop) {
-				case "search":
-				case "searchParams":
-				case "url":
-				case "href":
-				case "toJSON":
-				case "toString":
-				case "origin": return throwStaticGenerationError(`nextUrl.${String(prop)}`);
-				case "clone": return () => wrapRequireStaticNextUrl(target.clone());
-				default: return bindMethodIfNeeded(Reflect.get(target, prop, target), target);
+			if (isNextDynamicNextUrlProperty(prop)) return throwStaticGenerationError(`nextUrl.${String(prop)}`);
+			if (isHostDerivedNextUrlProperty(prop)) {
+				if (staticNextUrl === null) {
+					staticNextUrl = target.clone();
+					staticNextUrl.href = cleanStaticUrl(target.href);
+				}
+				return Reflect.get(staticNextUrl, prop, staticNextUrl);
 			}
+			if (prop === "clone") return () => wrapRequireStaticNextUrl(target.clone());
+			return bindMethodIfNeeded(Reflect.get(target, prop, target), target);
 		} });
 	};
 	const wrapRequest = (rawInput) => {

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

@@ -5,21 +5,22 @@ import "./server-globals.js";
 import "./app-rsc-vary.js";
 import { VINEXT_CACHEABILITY_PROBE_QUERY_PARAM } from "./headers.js";
 import { badRequestResponse, notFoundResponse, notFoundStaticAssetResponse } from "./http-error-responses.js";
-import { isOpenRedirectShaped } from "./open-redirect.js";
-import { cloneRequestWithHeaders, filterInternalHeaders } from "./request-pipeline.js";
+import { cloneRequestWithHeaders, filterInternalHeaders, guardProtocolRelativeUrl } from "./request-pipeline.js";
 import { getCdnCacheAdapter } from "../shims/cdn-cache.js";
 import { applyCdnResponseIdentityHeaders, validateCdnRequest } from "./cache-control.js";
-import { getImageOptimizer, handleConfiguredImageOptimization, isImageOptimizationPath } from "./image-optimization.js";
+import { getImageOptimizer, readImageOptimizationSignal } from "./image-optimization.js";
 import { traceFrameworkRequest } from "./request-tracing.js";
 import { createStaticAssetRequest, resolveStaticAssetSignal } from "./worker-utils.js";
 import { readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } 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 { registerConfiguredImageOptimizer } from "virtual:vinext-image-adapters";
 import { registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
-import rscHandler, { __assetPrefix, __basePath, __cacheabilityManifest, __ensureHybridPagesApplication, __ensureInstrumentation, __imageAllowedWidths, __imageConfig, __prerenderSecret } from "virtual:vinext-rsc-entry";
+import rscHandler, { __assetPrefix, __basePath, __cacheabilityManifest, __clientBuildFiles, __ensureHybridPagesApplication, __ensureInstrumentation, __imageAllowedWidths, __imageConfig, __prerenderSecret } from "virtual:vinext-rsc-entry";
 //#region src/server/app-router-entry.ts
 const __workerBasePath = typeof __basePath === "string" ? __basePath : "";
+const __workerClientBuildFiles = new Set(Array.isArray(__clientBuildFiles) ? __clientBuildFiles : []);
 const __workerAssetPathPrefix = assetPrefixPathname(typeof __assetPrefix === "string" ? __assetPrefix : "");
 function isPotentialCompletedAdmissionRequest(request) {
 	if (request.method !== "GET" && request.method !== "HEAD") return false;
@@ -82,13 +83,18 @@ async function handleRequest(request, env, platformCtx) {
 	const cdnValidationResponse = await validateCdnRequest(request);
 	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);
-	if (isOpenRedirectShaped(url.pathname)) return notFoundResponse();
+	const servesImages = Boolean(assets) && getImageOptimizer() !== null;
+	const protocolRelativeGuard = guardProtocolRelativeUrl(url.pathname, url.search);
+	if (protocolRelativeGuard) return protocolRelativeGuard;
 	try {
 		decodeURIComponent(url.pathname);
 	} catch {
 		return badRequestResponse();
 	}
+	if (assets && (request.method === "GET" || request.method === "HEAD")) {
+		const clientBuildFile = resolveClientBuildFile(url.pathname, __workerBasePath, __workerClientBuildFiles);
+		if (clientBuildFile) return await assets.fetch(createStaticAssetRequest(clientBuildFile, request));
+	}
 	const missingBuildAsset = isNextStaticPath(url.pathname, __workerBasePath, __workerAssetPathPrefix);
 	{
 		const trustedPrerenderRouteParams = ctx.hostRuntime === "node" ? readTrustedPrerenderRouteParams(request) : null;
@@ -103,8 +109,21 @@ async function handleRequest(request, env, platformCtx) {
 	const result = await (ctx ? runWithExecutionContext(ctx, handleFn) : handleFn());
 	if (result instanceof Response) {
 		let response = result;
-		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: __workerBasePath,
+				assetPathPrefix: __workerAssetPathPrefix,
+				clientBuildFiles: __workerClientBuildFiles,
+				fetchPublicFile: async (sourceRequest) => {
+					const sourceResult = await runWithExecutionContext(requestCtx, () => rscHandler(sourceRequest, requestCtx));
+					return sourceResult instanceof Response ? fetchSignalledPublicFile(sourceResult, sourceRequest, assets) : null;
+				}
+			});
+		} else if (assets) {
+			const assetResponse = await resolveStaticAssetSignal(response, { fetchAsset: (path, requestHeaders) => Promise.resolve(assets.fetch(createStaticAssetRequest(path, request, requestHeaders))) });
 			if (assetResponse) response = assetResponse;
 		}
 		return finalizeCacheabilityResponse ? finalizeCacheabilityResponse(response, ctx) : response;

package/dist/server/app-rsc-cache-busting.js

@@ -1,7 +1,7 @@
 import { NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_INTERCEPTION_ID_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_STATE_FINGERPRINT_HEADER, VINEXT_RSC_VARY_HEADER } from "./app-rsc-vary.js";
 import { NEXTJS_DEPLOYMENT_ID_HEADER, VINEXT_CLIENT_REUSE_MANIFEST_HEADER } from "./headers.js";
-import { fnv1a64 } from "../utils/hash.js";
 import { APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, parseAppRscRenderMode } from "./app-rsc-render-mode.js";
+import { fnv1a64 } from "../utils/hash.js";
 import { applyDeploymentIdHeader, getDeploymentId } from "../utils/deployment-id.js";
 import { createAppRscStateFingerprint } from "./app-rsc-state-fingerprint.js";
 //#region src/server/app-rsc-cache-busting.ts

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

@@ -1,6 +1,7 @@
 import { isNavigationSignalError } from "../utils/navigation-signal.js";
 import { resolveAppPageSpecialError } from "./app-page-execution.js";
 import { isAppRenderAbortError } from "./app-render-abort-error.js";
+import { getProperError } from "./proper-error.js";
 //#region src/server/app-rsc-errors.ts
 const ORIGINAL_SERVER_ERROR = Symbol.for("vinext.originalServerError");
 function hasDigest(error) {
@@ -23,11 +24,14 @@ function getDigestForWellKnownError(error) {
 	const digest = String(error.digest);
 	if (isNavigationSignalError(error) || digest === BAILOUT_TO_CSR_DIGEST || digest === DYNAMIC_SERVER_USAGE_DIGEST) return digest;
 }
-function getThrownValueMessage(error) {
-	return error instanceof Error ? error.message : String(error);
-}
-function getThrownValueStack(error) {
-	return error instanceof Error ? error.stack || "" : "";
+/**
+* Next.js hashes a thrown string as is, and other values once they are an
+* Error (packages/next/src/server/app-render/create-error-handler.tsx).
+*/
+function getThrownValueDigest(error) {
+	if (typeof error === "string") return errorDigest(error);
+	const properError = getProperError(error);
+	return errorDigest(properError.message + (properError.stack || ""));
 }
 /**
 * djb2 hash matching Next.js's string-hash package for RSC error digests.
@@ -41,7 +45,7 @@ function sanitizeErrorForClient(error, nodeEnv = process.env.NODE_ENV) {
 	if (resolveAppPageSpecialError(error)) return error;
 	if (nodeEnv !== "production") return error;
 	const sanitized = /* @__PURE__ */ new Error("An error occurred in the Server Components render. The specific message is omitted in production builds to avoid leaking sensitive details. A digest property is included on this error instance which may provide additional details about the nature of the error.");
-	sanitized.digest = hasDigest(error) ? String(error.digest) : errorDigest(getThrownValueMessage(error) + getThrownValueStack(error));
+	sanitized.digest = hasDigest(error) ? String(error.digest) : getThrownValueDigest(error);
 	Object.defineProperty(sanitized, ORIGINAL_SERVER_ERROR, {
 		configurable: false,
 		enumerable: false,
@@ -55,6 +59,7 @@ function createRscOnErrorHandler(options) {
 	return (error) => {
 		const nodeEnv = options.nodeEnv ?? process.env.NODE_ENV;
 		const reportableError = error && typeof error === "object" && ORIGINAL_SERVER_ERROR in error ? Reflect.get(error, ORIGINAL_SERVER_ERROR) : error;
+		if (typeof reportableError === "string") return hasDigest(error) ? String(error.digest) : errorDigest(reportableError);
 		if (isAppRenderAbortError(error) || isAppRenderAbortError(reportableError)) return;
 		const wellKnownDigest = getDigestForWellKnownError(error) ?? getDigestForWellKnownError(reportableError);
 		if (wellKnownDigest !== void 0) return wellKnownDigest;
@@ -62,22 +67,21 @@ function createRscOnErrorHandler(options) {
 			console.error("[vinext] RSC serialization error: a non-plain object was passed from a Server Component to a Client Component.\n\nCommon causes:\n  * Passing a module namespace (import * as X) directly as a prop.\n    Unlike Next.js (webpack), Vite produces real ESM module namespace objects\n    which are not serializable. Fix: pass individual values instead,\n    e.g. <Comp value={module.value} />\n  * Passing a class instance (new Foo()) as a prop.\n    Fix: convert to a plain object, e.g. { id: foo.id, name: foo.name }\n  * Passing a Date, Map, or Set. Use .toISOString(), [...map.entries()], etc.\n  * Passing Object.create(null). Use { ...obj } to restore a prototype.\n\nOriginal error:", error.message);
 			return;
 		}
-		if (options.requestInfo && options.errorContext && error) options.reportRequestError(reportableError, options.requestInfo, options.errorContext);
+		const thrownHasDigest = hasDigest(error);
+		const properError = getProperError(reportableError);
+		const digest = thrownHasDigest ? String(error.digest) : errorDigest(properError.message + (properError.stack || ""));
+		if (!hasDigest(properError) && (properError !== reportableError || options.attachDigest !== false)) try {
+			Object.assign(properError, { digest });
+		} catch {}
+		if (options.requestInfo && options.errorContext) options.reportRequestError(properError, options.requestInfo, options.errorContext);
 		if (process.env.VINEXT_PRERENDER === "1" && error) {
 			if (!loggedPrerenderErrors?.has(reportableError)) {
 				(loggedPrerenderErrors ??= /* @__PURE__ */ new Set()).add(reportableError);
 				const route = options.requestInfo?.path ?? options.errorContext?.routePath ?? "<unknown>";
 				console.error(`[vinext] Error prerendering route ${JSON.stringify(route)}:`, reportableError);
 			}
-		} else if (nodeEnv !== "production" && error && !hasDigest(error)) console.error("[vinext] Server render error:", reportableError);
-		if (hasDigest(error)) return String(error.digest);
-		if (error) {
-			const digest = errorDigest(getThrownValueMessage(error) + getThrownValueStack(error));
-			if (options.attachDigest !== false && error instanceof Error) try {
-				Object.assign(error, { digest });
-			} catch {}
-			return digest;
-		}
+		} else if (nodeEnv !== "production" && !thrownHasDigest) console.error("[vinext] Server render error:", properError);
+		return digest;
 	};
 }
 //#endregion

package/dist/server/app-rsc-handler.d.ts

@@ -85,6 +85,8 @@ type DispatchMatchedPageOptions<TRoute> = {
   scriptNonce?: string;
   searchParams: URLSearchParams;
   renderMode: AppRscRenderMode;
+  /** Render the document whole before its first byte (a regeneration or warm-up). */
+  renderWholeDocument?: boolean;
 };
 type DispatchMatchedRouteHandlerOptions<TRoute> = {
   /**
@@ -202,6 +204,11 @@ export type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
     fallback: NextRewrite[];
   };
   draftModeSecret: string;
+  /**
+   * Dev-only key the hybrid Pages handler seals x-vinext-mw-ctx with. Null
+   * outside `vite dev`, so a forwarded middleware context is never honored.
+   */
+  devForwardedMiddlewareContextKey?: string | null;
   dispatchMatchedPage: (options: DispatchMatchedPageOptions<TRoute>) => Promise<Response>;
   dispatchMatchedRouteHandler: (options: DispatchMatchedRouteHandlerOptions<TRoute>) => Promise<Response>;
   /**
@@ -235,6 +242,8 @@ export type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
   matchInterceptRoute?: (pathname: string, sourcePathname: string, interceptionId?: string | null) => AppRscRouteMatch<TRoute> | null;
   matchRoute: (pathname: string) => AppRscRouteMatch<TRoute> | null;
   matchRequestRoute?: (pathname: string) => AppRscRouteMatch<TRoute> | null;
+  /** `matchRequestRoute` without its decoded static page substitution. */
+  matchRawRequestRoute?: (pathname: string) => AppRscRouteMatch<TRoute> | null;
   runMiddleware?: (options: RunAppMiddlewareOptions) => Promise<ApplyAppMiddlewareResult>;
   publicFiles: ReadonlySet<string>;
   prefetchInlining?: PrefetchInliningConfig;
@@ -242,6 +251,8 @@ export type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
   renderPagesFallback?: (options: RenderPagesFallbackOptions) => Promise<Response | null>;
   rootParamNamesByPattern?: RootParamNamesMap;
   setNavigationContext: (context: NavigationContextValue) => void;
+  /** next.config `skipTrailingSlashRedirect`: serve both slash forms without a 308. */
+  skipTrailingSlashRedirect?: boolean;
   staticParamsMap: StaticParamsMap;
   trailingSlash: boolean;
   validateDevRequestOrigin?: (request: Request) => Response | null;