@qzsy/vinext 0.1.7

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

@@ -0,0 +1,39 @@
+import { NextI18nConfig } from "../config/next-config.js";
+import { NextRequest } from "../shims/server.js";
+
+//#region src/server/app-route-handler-runtime.d.ts
+declare const ROUTE_HANDLER_HTTP_METHODS: readonly ["GET", "HEAD", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"];
+type RouteHandlerHttpMethod = (typeof ROUTE_HANDLER_HTTP_METHODS)[number];
+type RouteHandlerModule = Partial<Record<RouteHandlerHttpMethod | "default", unknown>>;
+/**
+ * Checks whether a string is a recognized HTTP method for App Router route
+ * handlers. Invalid methods must be rejected with 400 before any auto-OPTIONS
+ * or 405 logic runs.
+ *
+ * @see https://github.com/vercel/next.js/blob/canary/packages/next/src/server/web/http.ts
+ */
+declare function isValidHTTPMethod(maybeMethod: string): maybeMethod is RouteHandlerHttpMethod;
+declare function collectRouteHandlerMethods(handler: RouteHandlerModule): RouteHandlerHttpMethod[];
+declare function buildRouteHandlerAllowHeader(exportedMethods: readonly string[]): string;
+declare function isKnownDynamicAppRoute(pattern: string): boolean;
+declare function markKnownDynamicAppRoute(pattern: string): void;
+type RequestDynamicAccess = "request.headers" | "request.cookies" | "request.ip" | "request.geo" | "request.url" | "request.body" | "request.blob" | "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 AppRouteDynamicRequestAccess = RequestDynamicAccess | NextUrlDynamicAccess;
+type AppRouteRequestMode = "auto" | "force-static" | "error";
+type TrackedAppRouteRequestOptions = {
+  basePath?: string;
+  i18n?: NextI18nConfig | null;
+  trailingSlash?: boolean;
+  middlewareHeaders?: Headers | null;
+  onDynamicAccess?: (access: AppRouteDynamicRequestAccess) => void;
+  requestMode?: AppRouteRequestMode;
+  staticGenerationErrorMessage?: (expression?: string) => string;
+};
+type TrackedAppRouteRequest = {
+  request: NextRequest;
+  didAccessDynamicRequest(): boolean;
+};
+declare function createTrackedAppRouteRequest(request: Request, options?: TrackedAppRouteRequestOptions): TrackedAppRouteRequest;
+//#endregion
+export { RouteHandlerHttpMethod, RouteHandlerModule, buildRouteHandlerAllowHeader, collectRouteHandlerMethods, createTrackedAppRouteRequest, isKnownDynamicAppRoute, isValidHTTPMethod, markKnownDynamicAppRoute };

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

@@ -0,0 +1,250 @@
+import { addBasePathToPathname } from "../utils/base-path.js";
+import { buildRequestHeadersFromMiddlewareResponse } from "./middleware-request-headers.js";
+import { NextRequest, RequestCookies, sealRequestCookies, sealRequestHeaders } from "../shims/server.js";
+//#region src/server/app-route-handler-runtime.ts
+const ROUTE_HANDLER_HTTP_METHODS = [
+	"GET",
+	"HEAD",
+	"POST",
+	"PUT",
+	"DELETE",
+	"PATCH",
+	"OPTIONS"
+];
+/**
+* Checks whether a string is a recognized HTTP method for App Router route
+* handlers. Invalid methods must be rejected with 400 before any auto-OPTIONS
+* or 405 logic runs.
+*
+* @see https://github.com/vercel/next.js/blob/canary/packages/next/src/server/web/http.ts
+*/
+function isValidHTTPMethod(maybeMethod) {
+	return ROUTE_HANDLER_HTTP_METHODS.includes(maybeMethod);
+}
+function collectRouteHandlerMethods(handler) {
+	const methods = ROUTE_HANDLER_HTTP_METHODS.filter((method) => typeof handler[method] === "function");
+	if (methods.includes("GET") && !methods.includes("HEAD")) methods.push("HEAD");
+	return methods;
+}
+function buildRouteHandlerAllowHeader(exportedMethods) {
+	const allow = new Set(exportedMethods);
+	allow.add("OPTIONS");
+	return Array.from(allow).sort().join(", ");
+}
+const _KNOWN_DYNAMIC_APP_ROUTE_HANDLERS_KEY = Symbol.for("vinext.appRouteHandlerRuntime.knownDynamicHandlers");
+const _g = globalThis;
+const knownDynamicAppRouteHandlers = _g[_KNOWN_DYNAMIC_APP_ROUTE_HANDLERS_KEY] ??= /* @__PURE__ */ new Set();
+function isKnownDynamicAppRoute(pattern) {
+	return knownDynamicAppRouteHandlers.has(pattern);
+}
+function markKnownDynamicAppRoute(pattern) {
+	knownDynamicAppRouteHandlers.add(pattern);
+}
+function bindMethodIfNeeded(value, target) {
+	return typeof value === "function" ? value.bind(target) : value;
+}
+function buildNextConfig(options) {
+	if (!options.basePath && !options.i18n && !options.trailingSlash) return null;
+	return {
+		basePath: options.basePath,
+		i18n: options.i18n ?? void 0,
+		trailingSlash: options.trailingSlash
+	};
+}
+function rebuildRequestWithHeaders(input, headers) {
+	const method = input.method;
+	const hasBody = method !== "GET" && method !== "HEAD";
+	const init = {
+		method,
+		headers,
+		cache: input.cache,
+		credentials: input.credentials,
+		integrity: input.integrity,
+		keepalive: input.keepalive,
+		mode: input.mode,
+		redirect: input.redirect,
+		referrer: input.referrer,
+		referrerPolicy: input.referrerPolicy,
+		signal: input.signal
+	};
+	if (hasBody && input.body) {
+		init.body = input.body;
+		init.duplex = "half";
+	}
+	return new Request(input.url, init);
+}
+function cleanStaticUrl(url) {
+	const cleanUrl = new URL(url);
+	cleanUrl.protocol = "http:";
+	cleanUrl.host = "localhost:3000";
+	cleanUrl.username = "";
+	cleanUrl.password = "";
+	cleanUrl.search = "";
+	cleanUrl.hash = "";
+	return cleanUrl.href;
+}
+function readEmptyBodyAsArrayBuffer() {
+	return new Response(null).arrayBuffer();
+}
+function readEmptyBodyAsBlob() {
+	return new Response(null).blob();
+}
+function readEmptyBodyAsFormData() {
+	return new Response(null).formData();
+}
+function readEmptyBodyAsJson() {
+	return new Response(null).json();
+}
+function readEmptyBodyAsText() {
+	return new Response(null).text();
+}
+function createTrackedAppRouteRequest(request, options = {}) {
+	let didAccessDynamicRequest = false;
+	const requestMode = options.requestMode ?? "auto";
+	const nextConfig = buildNextConfig(options);
+	const markDynamicAccess = (access) => {
+		didAccessDynamicRequest = true;
+		options.onDynamicAccess?.(access);
+	};
+	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);
+			}
+		} });
+	};
+	const wrapForceStaticNextUrl = (nextUrl) => {
+		const emptySearchParams = new URLSearchParams();
+		const staticHref = cleanStaticUrl(nextUrl.href);
+		return new Proxy(nextUrl, { get(target, prop) {
+			switch (prop) {
+				case "search": return "";
+				case "searchParams": return emptySearchParams;
+				case "href": return staticHref;
+				case "url": return;
+				case "toJSON":
+				case "toString": return () => staticHref;
+				case "clone": return () => wrapForceStaticNextUrl(target.clone());
+				default: return bindMethodIfNeeded(Reflect.get(target, prop, target), target);
+			}
+		} });
+	};
+	const throwStaticGenerationError = (expression) => {
+		throw new Error(options.staticGenerationErrorMessage?.(expression) ?? `Route handler with \`dynamic = "error"\` used ${expression}.`);
+	};
+	const wrapRequireStaticNextUrl = (nextUrl) => {
+		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);
+			}
+		} });
+	};
+	const wrapRequest = (rawInput) => {
+		let input = rawInput;
+		if (options.basePath) {
+			const inputUrl = new URL(rawInput.url);
+			const prefixedPathname = addBasePathToPathname(inputUrl.pathname, options.basePath);
+			if (prefixedPathname !== inputUrl.pathname) {
+				inputUrl.pathname = prefixedPathname;
+				const bodySource = rawInput.body && !rawInput.bodyUsed ? rawInput.clone() : rawInput;
+				input = new Request(inputUrl, bodySource);
+			}
+		}
+		const requestHeaders = options.middlewareHeaders ? buildRequestHeadersFromMiddlewareResponse(input.headers, options.middlewareHeaders) : null;
+		const requestWithOverrides = requestHeaders ? rebuildRequestWithHeaders(input, requestHeaders) : input;
+		const nextRequest = requestWithOverrides instanceof NextRequest ? requestWithOverrides : new NextRequest(requestWithOverrides, { nextConfig: nextConfig ?? void 0 });
+		let proxiedNextUrl = null;
+		let forceStaticNextUrl = null;
+		let requireStaticNextUrl = null;
+		let forceStaticHeaders = null;
+		let forceStaticCookies = null;
+		return new Proxy(nextRequest, { get(target, prop) {
+			if (requestMode === "force-static") switch (prop) {
+				case "nextUrl":
+					forceStaticNextUrl ??= wrapForceStaticNextUrl(target.nextUrl);
+					return forceStaticNextUrl;
+				case "headers":
+					forceStaticHeaders ??= sealRequestHeaders(new Headers());
+					return forceStaticHeaders;
+				case "cookies":
+					forceStaticCookies ??= sealRequestCookies(new RequestCookies(new Headers()));
+					return forceStaticCookies;
+				case "url": return cleanStaticUrl(target.nextUrl.href);
+				case "ip":
+				case "geo": return;
+				case "body": return null;
+				case "arrayBuffer": return readEmptyBodyAsArrayBuffer;
+				case "blob": return readEmptyBodyAsBlob;
+				case "formData": return readEmptyBodyAsFormData;
+				case "json": return readEmptyBodyAsJson;
+				case "text": return readEmptyBodyAsText;
+				case "clone": return () => wrapRequest(target.clone());
+				default: return bindMethodIfNeeded(Reflect.get(target, prop, target), target);
+			}
+			if (requestMode === "error") switch (prop) {
+				case "nextUrl":
+					requireStaticNextUrl ??= wrapRequireStaticNextUrl(target.nextUrl);
+					return requireStaticNextUrl;
+				case "headers":
+				case "cookies":
+				case "url":
+				case "ip":
+				case "geo":
+				case "body":
+				case "blob":
+				case "json":
+				case "text":
+				case "arrayBuffer":
+				case "formData": return throwStaticGenerationError(`request.${String(prop)}`);
+				case "clone": return () => wrapRequest(target.clone());
+				default: return bindMethodIfNeeded(Reflect.get(target, prop, target), target);
+			}
+			switch (prop) {
+				case "nextUrl":
+					proxiedNextUrl ??= wrapNextUrl(target.nextUrl);
+					return proxiedNextUrl;
+				case "headers":
+				case "cookies":
+				case "ip":
+				case "geo":
+				case "url":
+				case "body":
+				case "blob":
+				case "json":
+				case "text":
+				case "arrayBuffer":
+				case "formData":
+					markDynamicAccess(`request.${String(prop)}`);
+					return bindMethodIfNeeded(Reflect.get(target, prop, target), target);
+				case "clone": return () => wrapRequest(target.clone());
+				default: return bindMethodIfNeeded(Reflect.get(target, prop, target), target);
+			}
+		} });
+	};
+	return {
+		request: wrapRequest(request),
+		didAccessDynamicRequest() {
+			return didAccessDynamicRequest;
+		}
+	};
+}
+//#endregion
+export { buildRouteHandlerAllowHeader, collectRouteHandlerMethods, createTrackedAppRouteRequest, isKnownDynamicAppRoute, isValidHTTPMethod, markKnownDynamicAppRoute };

package/dist/server/app-route-module-loader.d.ts

@@ -0,0 +1,91 @@
+//#region src/server/app-route-module-loader.d.ts
+/**
+ * Lazy route-module hydration for the App Router RSC entry.
+ *
+ * The generated route table (see `entries/app-rsc-manifest.ts`) emits page and
+ * route-handler modules as lazy `() => import()` thunks instead of eager
+ * `import * as mod_N` namespaces. This keeps those modules out of the RSC
+ * entry's top-level evaluation, so an app with many routes — or routes with
+ * expensive module-level initialization — does not pay to evaluate every route
+ * module at Worker startup. Only the module(s) for the matched route are
+ * evaluated, on demand.
+ *
+ * `ensureAppRouteModulesLoaded` resolves a route's lazy thunks and populates
+ * the synchronous module fields that the rest of the request pipeline reads
+ * directly (`page`, `routeHandler`, layouts, templates, boundaries, and
+ * parallel-slot modules). It is:
+ *
+ *  - idempotent: once a route is loaded it returns immediately;
+ *  - dedup'd: concurrent calls for the same route share one in-flight promise,
+ *    so a burst of requests to the same route triggers a single import.
+ *
+ * Callers must `await` it before any synchronous read of route modules
+ * (segment config, fetch-cache mode, runtime resolution, dispatch branch,
+ * element building, etc.).
+ */
+type LazyModuleThunk = () => Promise<unknown>;
+type LazyModuleLoaderArray = readonly (LazyModuleThunk | null | undefined)[];
+type LazyLoadableIntercept = {
+  interceptLayouts?: readonly unknown[] | null;
+  __loadInterceptLayouts?: LazyModuleLoaderArray | null;
+  __loadState?: {
+    interceptLayoutsLoading: Promise<readonly unknown[]> | null;
+  };
+};
+type LazyLoadableSlot = {
+  page?: unknown;
+  default?: unknown;
+  layout?: unknown;
+  loading?: unknown;
+  error?: unknown;
+  __loadPage?: LazyModuleThunk | null;
+  __loadDefault?: LazyModuleThunk | null;
+  __loadLayout?: LazyModuleThunk | null;
+  __loadLoading?: LazyModuleThunk | null;
+  __loadError?: LazyModuleThunk | null; /** Hydrated only after an intercept matches, not with the slot's base modules. */
+  intercepts?: LazyLoadableIntercept[];
+};
+type LazyLoadableRoute = {
+  page?: unknown;
+  routeHandler?: unknown;
+  layouts?: unknown[];
+  templates?: unknown[];
+  errors?: unknown[];
+  errorPaths?: unknown[];
+  notFounds?: unknown[];
+  forbiddens?: unknown[];
+  unauthorizeds?: unknown[];
+  loading?: unknown;
+  error?: unknown;
+  notFound?: unknown;
+  forbidden?: unknown;
+  unauthorized?: unknown;
+  slots?: Record<string, LazyLoadableSlot>;
+  siblingIntercepts?: LazyLoadableIntercept[]; /** Lazy loader for the page module; `null`/absent when the page is eager. */
+  __loadPage?: LazyModuleThunk | null; /** Lazy loader for the route-handler module; `null`/absent when none. */
+  __loadRouteHandler?: LazyModuleThunk | null;
+  __loadLayouts?: LazyModuleLoaderArray | null;
+  __loadTemplates?: LazyModuleLoaderArray | null;
+  __loadErrors?: LazyModuleLoaderArray | null;
+  __loadErrorPaths?: LazyModuleLoaderArray | null;
+  __loadNotFounds?: LazyModuleLoaderArray | null;
+  __loadForbiddens?: LazyModuleLoaderArray | null;
+  __loadUnauthorizeds?: LazyModuleLoaderArray | null;
+  __loadLoading?: LazyModuleThunk | null;
+  __loadError?: LazyModuleThunk | null;
+  __loadNotFound?: LazyModuleThunk | null;
+  __loadForbidden?: LazyModuleThunk | null;
+  __loadUnauthorized?: LazyModuleThunk | null; /** Set once the route's lazy module fields have been resolved. */
+  __loaded?: boolean; /** In-flight hydration promise, used to dedup concurrent loads. */
+  __loading?: Promise<unknown> | null;
+};
+declare function loadAppInterceptLayouts(intercept: LazyLoadableIntercept): Promise<readonly unknown[]>;
+/**
+ * Resolve a route's lazy modules and assign them onto the route's synchronous
+ * module fields. Returns the same route reference (synchronously when already
+ * loaded, otherwise after the in-flight import resolves). Safe to call on
+ * `null`/`undefined` routes and on eager routes that have no lazy thunks.
+ */
+declare function ensureAppRouteModulesLoaded<TRoute extends LazyLoadableRoute>(route: TRoute | null | undefined): TRoute | Promise<TRoute>;
+//#endregion
+export { LazyLoadableRoute, ensureAppRouteModulesLoaded, loadAppInterceptLayouts };

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

@@ -0,0 +1,83 @@
+//#region src/server/app-route-module-loader.ts
+function pushFieldLoad(loads, target, field, loader) {
+	if (!loader || target[field] != null) return;
+	loads.push(loader().then((module) => {
+		target[field] = module;
+	}));
+}
+function pushArrayLoads(loads, target, loaders) {
+	if (!target || !loaders) return;
+	const slots = target;
+	for (const [index, loader] of loaders.entries()) {
+		if (index >= slots.length || !loader || slots[index] != null) continue;
+		loads.push(loader().then((module) => {
+			slots[index] = module;
+		}));
+	}
+}
+function loadAppInterceptLayouts(intercept) {
+	const loadState = intercept.__loadState;
+	if (loadState?.interceptLayoutsLoading) return loadState.interceptLayoutsLoading;
+	const loads = [];
+	pushArrayLoads(loads, intercept.interceptLayouts, intercept.__loadInterceptLayouts);
+	if (loads.length === 0) return Promise.resolve(intercept.interceptLayouts ?? []);
+	const loading = 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;
+}
+/**
+* Resolve a route's lazy modules and assign them onto the route's synchronous
+* module fields. Returns the same route reference (synchronously when already
+* loaded, otherwise after the in-flight import resolves). Safe to call on
+* `null`/`undefined` routes and on eager routes that have no lazy thunks.
+*/
+function ensureAppRouteModulesLoaded(route) {
+	if (!route || route.__loaded) return route;
+	if (route.__loading) return route.__loading;
+	const loadPage = route.__loadPage;
+	const loadRouteHandler = route.__loadRouteHandler;
+	const loads = [];
+	pushFieldLoad(loads, route, "page", loadPage);
+	pushFieldLoad(loads, route, "routeHandler", loadRouteHandler);
+	pushFieldLoad(loads, route, "loading", route.__loadLoading);
+	pushFieldLoad(loads, route, "error", route.__loadError);
+	pushFieldLoad(loads, route, "notFound", route.__loadNotFound);
+	pushFieldLoad(loads, route, "forbidden", route.__loadForbidden);
+	pushFieldLoad(loads, route, "unauthorized", route.__loadUnauthorized);
+	pushArrayLoads(loads, route.layouts, route.__loadLayouts);
+	pushArrayLoads(loads, route.templates, route.__loadTemplates);
+	pushArrayLoads(loads, route.errors, route.__loadErrors);
+	pushArrayLoads(loads, route.errorPaths, route.__loadErrorPaths);
+	pushArrayLoads(loads, route.notFounds, route.__loadNotFounds);
+	pushArrayLoads(loads, route.forbiddens, route.__loadForbiddens);
+	pushArrayLoads(loads, route.unauthorizeds, route.__loadUnauthorizeds);
+	for (const slot of Object.values(route.slots ?? {})) {
+		pushFieldLoad(loads, slot, "page", slot.__loadPage);
+		pushFieldLoad(loads, slot, "default", slot.__loadDefault);
+		pushFieldLoad(loads, slot, "layout", slot.__loadLayout);
+		pushFieldLoad(loads, slot, "loading", slot.__loadLoading);
+		pushFieldLoad(loads, slot, "error", slot.__loadError);
+	}
+	if (loads.length === 0) {
+		route.__loaded = true;
+		return route;
+	}
+	const loading = Promise.all(loads).then(() => {
+		route.__loaded = true;
+		route.__loading = null;
+		return route;
+	}).catch((error) => {
+		route.__loading = null;
+		throw error;
+	});
+	route.__loading = loading;
+	return loading;
+}
+//#endregion
+export { ensureAppRouteModulesLoaded, loadAppInterceptLayouts };

package/dist/server/app-router-entry.d.ts

@@ -0,0 +1,13 @@
+import { ExecutionContextLike } from "../shims/request-context.js";
+
+//#region src/server/app-router-entry.d.ts
+type WorkerAssetEnv = {
+  ASSETS?: {
+    fetch(request: Request): Promise<Response> | Response;
+  };
+};
+declare const _default: {
+  fetch(request: Request, env?: WorkerAssetEnv, ctx?: ExecutionContextLike): Promise<Response>;
+};
+//#endregion
+export { _default as default };

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

@@ -0,0 +1,49 @@
+import "./server-globals.js";
+import { runWithExecutionContext } from "../shims/request-context.js";
+import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER } 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 { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
+import { resolveStaticAssetSignal } from "./worker-utils.js";
+import { readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
+import rscHandler, { __assetPrefix, __basePath } from "virtual:vinext-rsc-entry";
+import { registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
+//#region src/server/app-router-entry.ts
+const __workerBasePath = typeof __basePath === "string" ? __basePath : "";
+const __workerAssetPathPrefix = assetPrefixPathname(typeof __assetPrefix === "string" ? __assetPrefix : "");
+var app_router_entry_default = { async fetch(request, env, ctx) {
+	return handleRequest(request, env, ctx);
+} };
+async function handleRequest(request, env, ctx) {
+	registerConfiguredCacheAdapters(env);
+	const url = new URL(request.url);
+	if (isOpenRedirectShaped(url.pathname)) return notFoundResponse();
+	try {
+		decodeURIComponent(url.pathname);
+	} catch {
+		return badRequestResponse();
+	}
+	if (isNextStaticPath(url.pathname, __workerBasePath, __workerAssetPathPrefix)) return notFoundStaticAssetResponse();
+	{
+		const prerenderRouteParamsPayload = readTrustedPrerenderRouteParams(request);
+		const filteredHeaders = filterInternalHeaders(request.headers);
+		const prerenderRouteParamsHeader = serializePrerenderRouteParamsHeader(prerenderRouteParamsPayload);
+		if (prerenderRouteParamsHeader !== null) filteredHeaders.set(VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, prerenderRouteParamsHeader);
+		request = cloneRequestWithHeaders(request, filteredHeaders);
+	}
+	const handleFn = () => rscHandler(request, ctx);
+	const result = await (ctx ? runWithExecutionContext(ctx, handleFn) : handleFn());
+	if (result instanceof Response) {
+		if (env?.ASSETS) {
+			const assetFetcher = env.ASSETS;
+			const assetResponse = await resolveStaticAssetSignal(result, { fetchAsset: (path) => Promise.resolve(assetFetcher.fetch(new Request(new URL(path, request.url)))) });
+			if (assetResponse) return assetResponse;
+		}
+		return result;
+	}
+	if (result === null || result === void 0) return notFoundResponse();
+	return new Response(String(result), { status: 200 });
+}
+//#endregion
+export { app_router_entry_default as default };

package/dist/server/app-rsc-cache-busting.d.ts

@@ -0,0 +1,64 @@
+import { VINEXT_RSC_RENDER_MODE_HEADER } from "./headers.js";
+import { AppRscRenderMode } from "./app-rsc-render-mode.js";
+
+//#region src/server/app-rsc-cache-busting.d.ts
+/**
+ * RSC cache-busting hashes cover the headers that make an RSC payload vary.
+ * Client-side variant headers must survive transit through CDNs and reverse
+ * proxies; stripping them changes the server hash and turns stale URLs into
+ * repeated canonicalization redirects.
+ */
+declare const VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM = "_rsc";
+declare const VINEXT_RSC_COMPATIBILITY_ID_HEADER = "X-Vinext-RSC-Compatibility-Id";
+declare const VINEXT_RSC_CONTENT_TYPE = "text/x-component";
+declare const VINEXT_RSC_VARY_HEADER: string;
+type CreateRscRequestHeadersOptions = {
+  clientReuseManifestHeader?: string | null;
+  interceptionContext?: string | null;
+  mountedSlotsHeader?: string | null;
+  renderMode?: AppRscRenderMode;
+};
+type ResolveInvalidRscCacheBustingRequestOptions = {
+  isRscRequest: boolean;
+  request: Request;
+};
+declare function getVinextRscCompatibilityId(): string | null;
+declare function applyRscCompatibilityIdHeader(headers: Headers, compatibilityId?: string | null | undefined): void;
+declare function isRscCompatibilityIdCompatible(responseCompatibilityId: string | null | undefined, clientCompatibilityId?: string | null | undefined): boolean;
+type RscCompatibilityNavigationDecision = {
+  kind: "compatible";
+} | {
+  hardNavigationTarget: string;
+  kind: "hard-navigate";
+};
+declare function resolveHardNavigationTargetFromRscResponse(responseUrl: string | null | undefined, currentHref: string, origin: string): string;
+declare function resolveRscCompatibilityNavigationDecision(options: {
+  clientCompatibilityId?: string | null;
+  currentHref: string;
+  origin: string;
+  responseCompatibilityId: string | null | undefined;
+  responseUrl?: string | null;
+}): RscCompatibilityNavigationDecision;
+/**
+ * Detect the internal RSC cache-busting search param using the same
+ * encoding-aware matching as `stripRscCacheBustingSearchParam`
+ * (`isRscCacheBustingSearchPair`). The two share a single matcher so a guard
+ * built on this helper and the stripper can never disagree on which pairs
+ * count as `_rsc`, including encoded-key edge cases like `%5Frsc`.
+ */
+declare function hasRscCacheBustingSearchParam(url: URL): boolean;
+declare function computeRscCacheBustingSearchParam(headers: Headers): Promise<string>;
+declare function setRscCacheBustingSearchParam(url: URL, hash: string): void;
+declare function stripRscCacheBustingSearchParam(url: URL): void;
+/**
+ * Remove a trailing `.rsc` suffix from a pathname. Returns the pathname
+ * unchanged when the suffix is absent.
+ */
+declare function stripRscSuffix(pathname: string): string;
+declare function createRscRequestHeaders(options?: CreateRscRequestHeadersOptions): Headers;
+declare function createRscRequestUrl(href: string, headers: Headers): Promise<string>;
+declare function createServerActionRequestUrl(href: string): string;
+declare function createRscRedirectLocation(location: string, request: Request): Promise<string>;
+declare function resolveInvalidRscCacheBustingRequest(options: ResolveInvalidRscCacheBustingRequestOptions): Promise<Response | null>;
+//#endregion
+export { 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, computeRscCacheBustingSearchParam, createRscRedirectLocation, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, getVinextRscCompatibilityId, hasRscCacheBustingSearchParam, isRscCompatibilityIdCompatible, resolveHardNavigationTargetFromRscResponse, resolveInvalidRscCacheBustingRequest, resolveRscCompatibilityNavigationDecision, setRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, stripRscSuffix };