vinext 1.2.0 → 1.3.0

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

@@ -1,8 +1,8 @@
 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 { 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";
@@ -19,7 +19,7 @@ import { registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
 /** Cacheable App response stage. This is the only multi-stage App entry that imports user routes. */
 /** Invoke one transformed public cache function without rendering its owning route. */
 async function invokeCacheFunction(invocation, env, platformCtx, dispatchRequestStage) {
-	await __ensureInstrumentation();
+	await __ensureInstrumentation(platformCtx);
 	const [{ loadServerAction }, { invokeCacheFunction: invokeRegisteredCacheFunction }] = await Promise.all([import("@vitejs/plugin-rsc/core/rsc"), import("../shims/cache-callable-runtime.js")]);
 	registerConfiguredCacheAdapters(env);
 	ensureFetchPatch();
@@ -37,8 +37,8 @@ async function handleResponseStage(request, env, platformCtx, props, dispatchReq
 	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 });
-	await __ensureInstrumentation();
-	if (props.kind === "app-full-request" && props.prerenderDiscovery) await __ensureHybridPagesApplication();
+	await __ensureInstrumentation(platformCtx);
+	if (props.kind === "app-full-request" && props.prerenderDiscovery) await __ensureHybridPagesApplication(platformCtx);
 	registerConfiguredImageOptimizer(env);
 	let ctx = createWorkerRevalidationContext(platformCtx, (internalRequest) => dispatchRequestStage(internalRequest), "node");
 	if (props.kind === "app-full-request" && props.prerenderDiscovery) ctx = {

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

@@ -1,4 +1,4 @@
-import { closeAfterResponse, createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
+import { closeAfterResponse, createRequestContext, getRequestContext, 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";
@@ -40,6 +40,7 @@ async function runInRouteHandlerRevalidationContext(options, renderFn) {
 	const requestContext = createRequestContext({
 		headersContext,
 		executionContext: getRequestExecutionContext(),
+		phase: "route-handler",
 		unstableCacheRevalidation: "foreground"
 	});
 	const revalidation = runWithRequestContext(requestContext, () => runInWorkStoreScope(async () => {
@@ -203,6 +204,7 @@ async function dispatchAppRouteHandlerImpl(options) {
 				return reportRequestError(error, request, context);
 			},
 			request: options.request,
+			requestSignal: getRequestContext().requestSignal ?? void 0,
 			expireSeconds: options.expireSeconds,
 			revalidateSeconds,
 			revalidateReason,

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

@@ -56,6 +56,8 @@ type RunAppRouteHandlerOptions = {
    */
   params: AppRouteParams | null;
   request: Request;
+  /** Host signal for the client connection; only the foreground request has one. */
+  requestSignal?: AbortSignal;
   routePattern?: string;
   setHeadersAccessPhase?: (phase: HeadersAccessPhase) => HeadersAccessPhase;
 };

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

@@ -118,6 +118,7 @@ async function runAppRouteHandler(options) {
 			options.markDynamicUsage();
 		},
 		requestMode: options.dynamicConfig === "force-static" || options.dynamicConfig === "error" ? options.dynamicConfig : "auto",
+		signal: options.requestSignal,
 		staticGenerationErrorMessage(expression) {
 			return getAppRouteStaticGenerationErrorMessage(options.routePattern, expression);
 		}
@@ -210,10 +211,16 @@ async function executeAppRouteHandlerImpl(options) {
 			revalidateSeconds: options.revalidateSeconds,
 			requiresCompletedResponseAdmission: isRouteCacheabilityEvaluation()
 		})) {
-			const completed = await completeAppRouteHandlerResponse(response);
+			const completed = await completeAppRouteHandlerResponse(response).catch(async (error) => {
+				await _drainPendingRevalidations().catch(() => {});
+				throw error;
+			});
 			response = completed.response;
 			cleanupDeferredToBody = !completed.completed;
-			if (completed.completed) markRouteCacheabilityResponseBodyComplete();
+			if (completed.completed) {
+				markRouteCacheabilityResponseBodyComplete();
+				await _drainPendingRevalidations();
+			}
 			const dynamicUsedDuringCompletion = options.consumeDynamicUsage();
 			dynamicUsedInHandler = handlerResult.didAccessDynamicRequest() || dynamicUsedDuringCompletion || dynamicUsedInHandler;
 		}

package/dist/server/app-route-handler-middleware-context.d.ts

@@ -1,8 +1,9 @@
+import { MiddlewareResponseMergeOptions } from "./middleware-response-headers.js";
 //#region src/server/app-route-handler-middleware-context.d.ts
 export type RouteHandlerMiddlewareContext = {
   headers: Headers | null;
   status: number | null;
 };
 /** Apply request-stage middleware response metadata to a route-handler response. */
-export declare function applyRouteHandlerMiddlewareContext(response: Response, middlewareContext: RouteHandlerMiddlewareContext): Response;
+export declare function applyRouteHandlerMiddlewareContext(response: Response, middlewareContext: RouteHandlerMiddlewareContext, options?: MiddlewareResponseMergeOptions): Response;
 //#endregion

package/dist/server/app-route-handler-middleware-context.js

@@ -1,10 +1,10 @@
-import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
+import { mergeMiddlewareResponseHeadersOntoResponse } from "./middleware-response-headers.js";
 //#region src/server/app-route-handler-middleware-context.ts
 /** Apply request-stage middleware response metadata to a route-handler response. */
-function applyRouteHandlerMiddlewareContext(response, middlewareContext) {
+function applyRouteHandlerMiddlewareContext(response, middlewareContext, options = {}) {
 	if (!middlewareContext.headers && middlewareContext.status == null) return response;
 	const responseHeaders = new Headers(response.headers);
-	mergeMiddlewareResponseHeaders(responseHeaders, middlewareContext.headers);
+	mergeMiddlewareResponseHeadersOntoResponse(responseHeaders, middlewareContext.headers, options);
 	return new Response(response.body, {
 		status: middlewareContext.status ?? response.status,
 		statusText: response.statusText,

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

@@ -1,3 +1,4 @@
+import { MiddlewareResponseMergeOptions } from "./middleware-response-headers.js";
 import { CacheControlMetadata, CachedRouteValue } from "../shims/cache-handler.js";
 //#region src/server/app-route-handler-response.d.ts
 export type RouteHandlerMiddlewareContext = {
@@ -16,7 +17,7 @@ type FinalizeRouteHandlerResponseOptions = {
   draftCookie?: string | null;
   isHead: boolean;
 };
-export declare function applyRouteHandlerMiddlewareContext(response: Response, middlewareContext: RouteHandlerMiddlewareContext, options?: {
+export declare function applyRouteHandlerMiddlewareContext(response: Response, middlewareContext: RouteHandlerMiddlewareContext, options?: MiddlewareResponseMergeOptions & {
   appendResponseLink?: boolean;
 }): Response;
 export declare function assertSupportedAppRouteHandlerResponse(response: Response): void;

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

@@ -5,7 +5,7 @@ import { markRouteCacheabilityExplicitResponsePolicy, recordRouteCacheability }
 import { applyCdnResponseHeaders } from "./cache-control.js";
 import { buildAppRouteMissIsrCacheControl, decideIsr } from "./isr-decision.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
-import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
+import { mergeMiddlewareResponseHeadersOntoResponse } from "./middleware-response-headers.js";
 import { markEdgeRouteHandlerLinkHeaders } from "./app-response-header-provenance.js";
 import { getSetCookieName } from "./cookie-utils.js";
 //#region src/server/app-route-handler-response.ts
@@ -22,7 +22,7 @@ function applyRouteHandlerMiddlewareContext(response, middlewareContext, options
 		return response;
 	}
 	const responseHeaders = new Headers(response.headers);
-	mergeMiddlewareResponseHeaders(responseHeaders, middlewareContext.headers);
+	mergeMiddlewareResponseHeadersOntoResponse(responseHeaders, middlewareContext.headers, options);
 	if (responseLink && middlewareContext.headers?.get("link")) responseHeaders.append("link", responseLink);
 	const result = new Response(response.body, {
 		status: middlewareContext.status ?? response.status,

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

@@ -30,6 +30,8 @@ type TrackedAppRouteRequestOptions = {
   middlewareHeaders?: Headers | null;
   onDynamicAccess?: (access: AppRouteDynamicRequestAccess) => void;
   requestMode?: AppRouteRequestMode;
+  /** Host signal for the client connection (UnifiedRequestContext.requestSignal). */
+  signal?: AbortSignal;
   staticGenerationErrorMessage?: (expression?: string) => string;
 };
 type TrackedAppRouteRequest = {

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]));
@@ -72,7 +72,20 @@ function buildNextConfig(options) {
 		skipTrailingSlashRedirect: options.skipTrailingSlashRedirect
 	};
 }
-function createForceStaticNextRequest(input, nextConfig) {
+/**
+* Undici's Request follows its input's signal through a WeakRef, and so does
+* every clone between the host signal and the handler's request. A handler
+* that only listens on `request.signal` (e.g. to stop a stream) would miss the
+* abort once GC collects any of them, so the request follows the host signal
+* directly and stays reachable for as long as that signal is.
+*/
+const requestsByHostSignal = /* @__PURE__ */ new WeakMap();
+function retainWhileSignalLives(signal, request) {
+	const requests = requestsByHostSignal.get(signal);
+	if (requests) requests.push(request);
+	else requestsByHostSignal.set(signal, [request]);
+}
+function createForceStaticNextRequest(input, nextConfig, signal) {
 	const read = (key) => {
 		const descriptor = BUILT_IN_REQUEST_PROPERTY_MAP.get(key)?.descriptor;
 		if (descriptor?.get) return descriptor.get.call(input);
@@ -89,7 +102,7 @@ function createForceStaticNextRequest(input, nextConfig) {
 		redirect: read("redirect"),
 		referrer: read("referrer"),
 		referrerPolicy: read("referrerPolicy"),
-		signal: read("signal"),
+		signal: signal ?? read("signal"),
 		nextConfig: nextConfig ?? void 0
 	});
 }
@@ -215,7 +228,11 @@ function createTrackedAppRouteRequest(request, options = {}) {
 		const sourceCfDescriptor = Reflect.getOwnPropertyDescriptor(requestWithOverrides, "cf");
 		const sourceCfAccessor = sourceCfDescriptor?.get;
 		const sourceCfMetadata = sourceCfAccessor ? void 0 : Reflect.get(requestWithOverrides, "cf", requestWithOverrides);
-		const nextRequest = requestMode === "force-static" ? createForceStaticNextRequest(requestWithOverrides, nextConfig) : requestWithOverrides instanceof NextRequest && sourceCfDescriptor?.configurable !== false ? requestWithOverrides : new NextRequest(requestWithOverrides, { nextConfig: nextConfig ?? void 0 });
+		const nextRequest = requestMode === "force-static" ? createForceStaticNextRequest(requestWithOverrides, nextConfig, options.signal) : requestWithOverrides instanceof NextRequest && sourceCfDescriptor?.configurable !== false && !options.signal ? requestWithOverrides : new NextRequest(requestWithOverrides, {
+			nextConfig: nextConfig ?? void 0,
+			signal: options.signal
+		});
+		if (options.signal) retainWhileSignalLives(options.signal, nextRequest);
 		const rawCfMetadata = sourceCfAccessor ? void 0 : sourceCfMetadata === void 0 ? Reflect.get(nextRequest, "cf", nextRequest) : sourceCfMetadata;
 		const hasCfMetadata = sourceCfAccessor !== void 0 || rawCfMetadata !== void 0;
 		const originalCfDescriptor = sourceCfDescriptor ?? Reflect.getOwnPropertyDescriptor(nextRequest, "cf");

package/dist/server/app-route-module-loader.js

@@ -1,4 +1,5 @@
 import { runOutsideRequestScopes } from "../shims/internal/als-registry.js";
+import { shareIsolatePromise } from "./isolate-shared-promise.js";
 //#region src/server/app-route-module-loader.ts
 /**
 * Lazy route-module hydration for the App Router RSC entry.
@@ -63,7 +64,7 @@ async function hydrateInterceptModule(intercept, loader, field, loadingField) {
 	const cached = loadState?.[field];
 	if (cached != null) intercept[field] = cached;
 	if (!loader || intercept[field] != null) return;
-	const loading = loadState?.[loadingField] ?? runOutsideRequestScopes(loader).then((module) => {
+	const loading = loadState?.[loadingField] ?? shareIsolatePromise(runOutsideRequestScopes(loader).then((module) => {
 		intercept[field] = module;
 		if (loadState) {
 			loadState[field] = module;
@@ -73,7 +74,7 @@ async function hydrateInterceptModule(intercept, loader, field, loadingField) {
 	}).catch((error) => {
 		if (loadState) loadState[loadingField] = null;
 		throw error;
-	});
+	}));
 	if (loadState) loadState[loadingField] = loading;
 	intercept[field] = await loading;
 }
@@ -92,13 +93,13 @@ function loadAppInterceptLayouts(intercept) {
 	pushArrayLoads(loads, intercept.interceptLayouts, intercept.__loadInterceptLayouts);
 	pushArrayLoads(loads, intercept.interceptLoadings, intercept.__loadInterceptLoadings);
 	if (loads.length === 0) return Promise.resolve(intercept.interceptLayouts ?? []);
-	const loading = Promise.all(loads).then(() => {
+	const loading = shareIsolatePromise(Promise.all(loads).then(() => {
 		if (loadState) loadState.interceptLayoutsLoading = null;
 		return intercept.interceptLayouts ?? [];
 	}).catch((error) => {
 		if (loadState) loadState.interceptLayoutsLoading = null;
 		throw error;
-	});
+	}));
 	if (loadState) loadState.interceptLayoutsLoading = loading;
 	return loading;
 }
@@ -143,14 +144,14 @@ function ensureAppRouteModulesLoaded(route) {
 		route.__loaded = true;
 		return route;
 	}
-	const loading = Promise.all(loads).then(() => {
+	const loading = shareIsolatePromise(Promise.all(loads).then(() => {
 		route.__loaded = true;
 		route.__loading = null;
 		return route;
 	}).catch((error) => {
 		route.__loading = null;
 		throw error;
-	});
+	}));
 	route.__loading = loading;
 	return loading;
 }

package/dist/server/app-route-tree.d.ts

@@ -0,0 +1,20 @@
+import { AppElements } from "./app-elements-wire.js";
+import "./app-elements.js";
+import { ReactNode } from "react";
+//#region src/server/app-route-tree.d.ts
+/**
+ * Builds the App Router route tree after a sibling that the browser uses to
+ * write navigation history. Insertion effects run in tree order, so that
+ * sibling's effect runs before React mutates the route tree's DOM, like
+ * Next.js' HistoryUpdater.
+ *
+ * The server and the browser must render this same shape: a second child
+ * changes the useId values of everything below it, so SSR passes null in the
+ * sibling's place to keep hydrated ids matching.
+ */
+export declare function createAppRouteTree(options: {
+  elements: AppElements;
+  historyCommit: ReactNode;
+  routeId: string;
+}): ReactNode;
+//#endregion

package/dist/server/app-route-tree.js

@@ -0,0 +1,18 @@
+import { ElementsContext, Slot } from "../shims/slot.js";
+import { Fragment, createElement } from "react";
+//#region src/server/app-route-tree.ts
+/**
+* Builds the App Router route tree after a sibling that the browser uses to
+* write navigation history. Insertion effects run in tree order, so that
+* sibling's effect runs before React mutates the route tree's DOM, like
+* Next.js' HistoryUpdater.
+*
+* The server and the browser must render this same shape: a second child
+* changes the useId values of everything below it, so SSR passes null in the
+* sibling's place to keep hydrated ids matching.
+*/
+function createAppRouteTree(options) {
+	return createElement(Fragment, null, options.historyCommit, createElement(ElementsContext.Provider, { value: options.elements }, createElement(Slot, { id: options.routeId })));
+}
+//#endregion
+export { createAppRouteTree };

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

@@ -1,11 +1,11 @@
 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, readImageOptimizationSignal } from "./image-optimization.js";
@@ -31,7 +31,7 @@ var app_router_entry_default = {
 	__ensureInstrumentation,
 	async fetch(request, env, ctx) {
 		const handleFetch = async () => {
-			await __ensureInstrumentation();
+			await __ensureInstrumentation(ctx);
 			const url = new URL(request.url);
 			return traceFrameworkRequest({
 				callback: async () => applyCdnResponseIdentityHeaders(await handleRequest(request, env, ctx), request),
@@ -53,7 +53,7 @@ async function handleRequest(request, env, platformCtx) {
 	let ctx = createWorkerPrerenderDiscoveryContext(requestCtx, request, __prerenderSecret);
 	const readinessResponse = createWorkerPrerenderReadinessResponse(ctx, request);
 	if (readinessResponse) {
-		if (readinessResponse.status === 204) await __ensureHybridPagesApplication();
+		if (readinessResponse.status === 204) await __ensureHybridPagesApplication(ctx);
 		return await validateCdnRequest(request) ?? readinessResponse;
 	}
 	let finalizeCacheabilityResponse;
@@ -66,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);
 			}
 		}
 	}

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

@@ -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-combined-handler.js

@@ -1,8 +1,15 @@
+import { getRequestExecutionContext, runWithExecutionContext } from "../shims/request-context.js";
+import { createWorkerRevalidationContext } from "./worker-revalidation-context.js";
 import { createAppRscRequestHandler } from "./app-rsc-handler.js";
 //#region src/server/app-rsc-combined-handler.ts
 /** Combined request/response handler used by default single-stage App entries. */
 function createAppRscHandler(options) {
-	const appRscHandler = createAppRscRequestHandler(options);
+	const appRscRequestHandler = createAppRscRequestHandler(options);
+	const appRscHandler = (request, ctx, ...rest) => {
+		if (ctx != null || getRequestExecutionContext()) return appRscRequestHandler(request, ctx, ...rest);
+		const executionContext = createWorkerRevalidationContext(void 0, (internalRequest, internalCtx) => runWithExecutionContext(internalCtx, () => appRscRequestHandler(internalRequest, internalCtx)), "node");
+		return runWithExecutionContext(executionContext, () => appRscRequestHandler(request, ctx, ...rest));
+	};
 	return Object.assign(appRscHandler, { handleResponseStage(request, ctx, props, stageOptions) {
 		return import("./app-rsc-response-stage.js").then(({ renderAppWorkerResponseStage }) => renderAppWorkerResponseStage(options, request, ctx, props, stageOptions));
 	} });

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

@@ -37,6 +37,13 @@ export declare function getDigestForWellKnownError(error: unknown): string | und
  * djb2 hash matching Next.js's string-hash package for RSC error digests.
  */
 export declare function errorDigest(input: string): string;
+/**
+ * The message React 19.3's production Flight client gives a Server Components
+ * error in the browser (minified error #441). Sanitized errors that vinext
+ * serializes itself, such as the error passed to app/global-error, use the
+ * same text so they read the same as errors React reconstructs.
+ */
+export declare const PRODUCTION_SERVER_COMPONENTS_ERROR_MESSAGE = "Minified React error #441; visit https://react.dev/errors/441 for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";
 export declare function sanitizeErrorForClient(error: unknown, nodeEnv?: "development" | "production" | "test"): unknown;
 export declare function createRscOnErrorHandler(options: CreateRscOnErrorHandlerOptions): (error: unknown) => string | undefined;
 //#endregion

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

@@ -41,10 +41,17 @@ function errorDigest(input) {
 	for (let i = input.length - 1; i >= 0; i--) hash = hash * 33 ^ input.charCodeAt(i);
 	return (hash >>> 0).toString();
 }
+/**
+* The message React 19.3's production Flight client gives a Server Components
+* error in the browser (minified error #441). Sanitized errors that vinext
+* serializes itself, such as the error passed to app/global-error, use the
+* same text so they read the same as errors React reconstructs.
+*/
+const PRODUCTION_SERVER_COMPONENTS_ERROR_MESSAGE = "Minified React error #441; visit https://react.dev/errors/441 for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";
 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.");
+	const sanitized = /* @__PURE__ */ new Error(PRODUCTION_SERVER_COMPONENTS_ERROR_MESSAGE);
 	sanitized.digest = hasDigest(error) ? String(error.digest) : getThrownValueDigest(error);
 	Object.defineProperty(sanitized, ORIGINAL_SERVER_ERROR, {
 		configurable: false,
@@ -85,4 +92,4 @@ function createRscOnErrorHandler(options) {
 	};
 }
 //#endregion
-export { createRscOnErrorHandler, errorDigest, getDigestForWellKnownError, hasDigest, sanitizeErrorForClient };
+export { PRODUCTION_SERVER_COMPONENTS_ERROR_MESSAGE, createRscOnErrorHandler, errorDigest, getDigestForWellKnownError, hasDigest, sanitizeErrorForClient };

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

@@ -1,6 +1,7 @@
 import { VinextCacheabilityProbeMode } from "./multi-stage.js";
 import { NextHeader, NextI18nConfig, NextRedirect, NextRewrite } from "../config/next-config.js";
 import { ImageConfig } from "./image-optimization.js";
+import { ExecutionContextLike } from "../shims/request-context.js";
 import { AppMiddlewareContext, ApplyAppMiddlewareResult } from "./app-middleware.js";
 import { ClientReuseManifestParseResult } from "./client-reuse-manifest.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
@@ -217,7 +218,7 @@ export type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
    * dedup'd. Provided by the generated RSC entry; absent in older entries.
    */
   ensureRouteLoaded?: (route: TRoute) => unknown;
-  ensureInstrumentation?: () => Promise<void>;
+  ensureInstrumentation?: (ctx: ExecutionContextLike | null) => Promise<void>;
   /**
    * Register cache adapters configured via the vinext() `cache` option. Wired
    * from the generated RSC entry (which can import `virtual:vinext-cache-adapters`)
@@ -251,6 +252,8 @@ export type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
   renderPagesFallback?: (options: RenderPagesFallbackOptions) => Promise<Response | null>;
   rootParamNamesByPattern?: RootParamNamesMap;
   setNavigationContext: (context: NavigationContextValue) => void;
+  /** next.config `skipProxyUrlNormalize`. */
+  skipProxyUrlNormalize?: boolean;
   /** next.config `skipTrailingSlashRedirect`: serve both slash forms without a 308. */
   skipTrailingSlashRedirect?: boolean;
   staticParamsMap: StaticParamsMap;