vinext 1.1.0 → 1.2.1

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 { serializeStaticFileSignalForTransport } from "./static-file-signal.js";
+import { attachRequestCfMetadata } from "./request-pipeline.js";
+import { runWithExecutionContext } from "../shims/request-context.js";
+import { runInWorkStoreScope } from "../shims/internal/work-store-scope.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";
@@ -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

@@ -1,7 +1,7 @@
 import { buildRequestHeadersFromMiddlewareResponse } from "../utils/middleware-request-headers.js";
 import { addBasePathToPathname } from "../utils/base-path.js";
-import { NextRequest, RequestCookies, sealRequestCookies, sealRequestHeaders } from "../shims/server.js";
 import { cloneRequestWithHeaders, cloneRequestWithUrl } from "./request-pipeline.js";
+import { NextRequest, RequestCookies, sealRequestCookies, sealRequestHeaders } from "../shims/server.js";
 import { BUILT_IN_REQUEST_PROPERTIES } from "./app-route-request-built-ins.js";
 //#region src/server/app-route-handler-runtime.ts
 const BUILT_IN_REQUEST_PROPERTY_MAP = new Map(BUILT_IN_REQUEST_PROPERTIES.map((property) => [property.key, property]));
@@ -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

@@ -1,24 +1,26 @@
 import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_REVALIDATE_HOST_HEADER } from "../utils/protocol-headers.js";
-import { assetPrefixPathname, isNextStaticPath } 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 } from "./headers.js";
 import { badRequestResponse, notFoundResponse, notFoundStaticAssetResponse } from "./http-error-responses.js";
-import { cloneRequestWithHeaders, filterInternalHeaders, guardProtocolRelativeUrl } from "./request-pipeline.js";
+import { cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders, guardProtocolRelativeUrl } from "./request-pipeline.js";
+import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
+import { runWithExecutionContext } from "../shims/request-context.js";
+import "./server-globals.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;
@@ -64,7 +66,7 @@ async function handleRequest(request, env, platformCtx) {
 			const probeUrl = new URL(request.url);
 			if (probeUrl.searchParams.has("__vinext_cacheability_probe")) {
 				probeUrl.searchParams.delete(VINEXT_CACHEABILITY_PROBE_QUERY_PARAM);
-				request = new Request(probeUrl, request);
+				request = cloneRequestWithUrl(request, probeUrl.href);
 			}
 		}
 	}
@@ -81,7 +83,7 @@ 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);
+	const servesImages = Boolean(assets) && getImageOptimizer() !== null;
 	const protocolRelativeGuard = guardProtocolRelativeUrl(url.pathname, url.search);
 	if (protocolRelativeGuard) return protocolRelativeGuard;
 	try {
@@ -89,6 +91,10 @@ async function handleRequest(request, env, platformCtx) {
 	} 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.d.ts

@@ -89,6 +89,22 @@ export declare function canonicalizePrewarmableRscRequestHeaders(headers: Header
  * router state is transport context and must not fragment the shared response.
  */
 export declare function canonicalizeLoadingShellRscRequestHeaders(headers: Headers): boolean;
+/**
+ * Callers pass a path (usually a parsed URL's pathname + search) or an
+ * absolute URL. A pathname can begin with "//", and resolving that as a
+ * relative reference would read its first segment as a host, so a path is
+ * appended to the base instead of resolved against it.
+ */
+export declare function parseRscRequestPath(href: string): URL;
+/**
+ * Serialize the path-absolute reference callers fetch against the app origin.
+ * A pathname that begins with "//" would serialize as a protocol-relative URL
+ * and send the request to another host, so it keeps a "/." prefix, as the
+ * WHATWG URL serializer does. URL resolution drops the dot segment, so the
+ * request still targets the same pathname on the app origin, as Next.js's
+ * full-URL fetch does.
+ */
+export declare function formatRscRequestPath(url: URL): string;
 export declare function createRscRequestUrl(href: string, headers: Headers): Promise<string>;
 /** Build the definitive full-route RSC URL shared by prefetch and navigation. */
 export declare function createCanonicalRscRequestUrl(href: string): string;

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
@@ -218,33 +218,50 @@ function canonicalizeLoadingShellRscRequestHeaders(headers) {
 	headers.delete(VINEXT_CLIENT_REUSE_MANIFEST_HEADER);
 	return true;
 }
-function toRscRequestPath(href) {
+const RSC_REQUEST_URL_BASE = "http://vinext.local";
+/**
+* Callers pass a path (usually a parsed URL's pathname + search) or an
+* absolute URL. A pathname can begin with "//", and resolving that as a
+* relative reference would read its first segment as a host, so a path is
+* appended to the base instead of resolved against it.
+*/
+function parseRscRequestPath(href) {
 	const hashIndex = href.indexOf("#");
-	return hashIndex === -1 ? href : href.slice(0, hashIndex);
+	const beforeHash = hashIndex === -1 ? href : href.slice(0, hashIndex);
+	if (beforeHash.startsWith("/") || beforeHash.startsWith("\\")) return new URL(`${RSC_REQUEST_URL_BASE}${beforeHash}`);
+	return new URL(beforeHash, RSC_REQUEST_URL_BASE);
+}
+/**
+* Serialize the path-absolute reference callers fetch against the app origin.
+* A pathname that begins with "//" would serialize as a protocol-relative URL
+* and send the request to another host, so it keeps a "/." prefix, as the
+* WHATWG URL serializer does. URL resolution drops the dot segment, so the
+* request still targets the same pathname on the app origin, as Next.js's
+* full-URL fetch does.
+*/
+function formatRscRequestPath(url) {
+	return `${url.pathname.startsWith("//") ? `/.${url.pathname}` : url.pathname}${url.search}`;
 }
 async function createRscRequestUrl(href, headers) {
-	const url = new URL(toRscRequestPath(href), "http://vinext.local");
+	const url = parseRscRequestPath(href);
 	if (typeof window !== "undefined" && process.env.NODE_ENV === "production" && process.env.__NEXT_CONFIG_OUTPUT === "export") {
 		const basePath = process.env.__NEXT_ROUTER_BASEPATH ?? "";
 		const isBasePathRoot = basePath !== "" && url.pathname === basePath;
 		if (url.pathname.endsWith("/")) url.pathname += "index.txt";
 		else url.pathname += isBasePathRoot ? "/index.txt" : ".txt";
-		return `${url.pathname}${url.search}`;
+		return formatRscRequestPath(url);
 	}
 	setRscCacheBustingSearchParam(url, await computeRscCacheBustingSearchParam(headers));
-	return `${url.pathname}${url.search}`;
+	return formatRscRequestPath(url);
 }
 /** Build the definitive full-route RSC URL shared by prefetch and navigation. */
 function createCanonicalRscRequestUrl(href) {
-	const url = new URL(toRscRequestPath(href), "http://vinext.local");
+	const url = parseRscRequestPath(href);
 	setRscCacheBustingSearchParam(url, "");
-	return `${url.pathname}${url.search}`;
+	return formatRscRequestPath(url);
 }
 function createServerActionRequestUrl(href) {
-	const hashIndex = href.indexOf("#");
-	const beforeHash = hashIndex === -1 ? href : href.slice(0, hashIndex);
-	const url = new URL(beforeHash, "http://vinext.local");
-	return `${url.pathname}${url.search}`;
+	return formatRscRequestPath(parseRscRequestPath(href));
 }
 async function createRscRedirectLocation(location, request) {
 	const requestUrl = new URL(request.url);
@@ -309,4 +326,4 @@ async function resolveInvalidRscCacheBustingRequest(options) {
 	});
 }
 //#endregion
-export { VINEXT_RSC_BUILD_ID_HEADER, VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, canonicalizeLoadingShellRscRequestHeaders, canonicalizePrewarmableRscRequestHeaders, computeRscCacheBustingSearchParam, createCanonicalLoadingShellRscRequestHeaders, createCanonicalRscRequestHeaders, createCanonicalRscRequestUrl, createRscRedirectLocation, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, getVinextRscCompatibilityId, hasRscCacheBustingSearchParam, isRscCompatibilityIdCompatible, keepOnlyValidatedRscCacheBustingSearchParam, resolveHardNavigationTargetFromRscResponse, resolveInvalidRscCacheBustingRequest, resolveRscCompatibilityNavigationDecision, setRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, stripRscSuffix };
+export { VINEXT_RSC_BUILD_ID_HEADER, VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, canonicalizeLoadingShellRscRequestHeaders, canonicalizePrewarmableRscRequestHeaders, computeRscCacheBustingSearchParam, createCanonicalLoadingShellRscRequestHeaders, createCanonicalRscRequestHeaders, createCanonicalRscRequestUrl, createRscRedirectLocation, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, formatRscRequestPath, getVinextRscCompatibilityId, hasRscCacheBustingSearchParam, isRscCompatibilityIdCompatible, keepOnlyValidatedRscCacheBustingSearchParam, parseRscRequestPath, resolveHardNavigationTargetFromRscResponse, resolveInvalidRscCacheBustingRequest, resolveRscCompatibilityNavigationDecision, setRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, stripRscSuffix };

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

@@ -204,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>;
   /**
@@ -246,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;