vinext 0.0.54 → 0.1.0

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

@@ -1,7 +1,7 @@
 import "./headers.js";
 import { processMiddlewareHeaders } from "./request-pipeline.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
-import { NEVER_CACHE_CONTROL, STATIC_CACHE_CONTROL, buildCachedRevalidateCacheControl } from "./cache-control.js";
+import { NEVER_CACHE_CONTROL, STATIC_CACHE_CONTROL, applyCdnResponseHeaders, buildCachedRevalidateCacheControl } from "./cache-control.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { getSetCookieName } from "./cookie-utils.js";
 //#region src/server/app-route-handler-response.ts
@@ -37,14 +37,17 @@ function buildRouteHandlerCachedResponse(cachedValue, options) {
 	setCacheStateHeaders(headers, options.cacheState);
 	const revalidateSeconds = options.cacheControl?.revalidate ?? options.revalidateSeconds;
 	const expireSeconds = options.cacheControl === void 0 ? void 0 : options.cacheControl.expire ?? options.expireSeconds;
-	headers.set("Cache-Control", buildRouteHandlerCacheControl(options.cacheState, revalidateSeconds, expireSeconds));
+	applyCdnResponseHeaders(headers, { cacheControl: buildRouteHandlerCacheControl(options.cacheState, revalidateSeconds, expireSeconds) });
 	return new Response(options.isHead ? null : cachedValue.body, {
 		status: cachedValue.status,
 		headers
 	});
 }
-function applyRouteHandlerRevalidateHeader(response, revalidateSeconds, expireSeconds) {
-	response.headers.set("cache-control", buildRouteHandlerCacheControl("HIT", revalidateSeconds, expireSeconds));
+function applyRouteHandlerRevalidateHeader(response, revalidateSeconds, expireSeconds, tags) {
+	applyCdnResponseHeaders(response.headers, {
+		cacheControl: buildRouteHandlerCacheControl("HIT", revalidateSeconds, expireSeconds),
+		tags
+	});
 }
 function markRouteHandlerCacheMiss(response) {
 	setCacheStateHeaders(response.headers, "MISS");
@@ -83,7 +86,7 @@ function hasCookieAttribute(cookie, attributeName) {
 */
 function normalizeReturnedCookie(cookie) {
 	if (hasCookieAttribute(cookie, "Path")) return cookie;
-	return `${cookie}; Path=/`;
+	return `${cookie.replace(/;\s*$/, "")}; Path=/`;
 }
 function applyMutableCookieFallbacks(headers, pendingCookies) {
 	if (pendingCookies.length === 0) return;
@@ -139,5 +142,3 @@ function finalizeRouteHandlerResponse(response, options) {
 }
 //#endregion
 export { applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, buildRouteHandlerCachedResponse, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss };
-
-//# sourceMappingURL=app-route-handler-response.js.map

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

@@ -35,5 +35,4 @@ type TrackedAppRouteRequest = {
 };
 declare function createTrackedAppRouteRequest(request: Request, options?: TrackedAppRouteRequestOptions): TrackedAppRouteRequest;
 //#endregion
-export { RouteHandlerHttpMethod, RouteHandlerModule, buildRouteHandlerAllowHeader, collectRouteHandlerMethods, createTrackedAppRouteRequest, isKnownDynamicAppRoute, isValidHTTPMethod, markKnownDynamicAppRoute };
-//# sourceMappingURL=app-route-handler-runtime.d.ts.map
+export { RouteHandlerHttpMethod, RouteHandlerModule, buildRouteHandlerAllowHeader, collectRouteHandlerMethods, createTrackedAppRouteRequest, isKnownDynamicAppRoute, isValidHTTPMethod, markKnownDynamicAppRoute };

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

@@ -236,5 +236,3 @@ function createTrackedAppRouteRequest(request, options = {}) {
 }
 //#endregion
 export { buildRouteHandlerAllowHeader, collectRouteHandlerMethods, createTrackedAppRouteRequest, isKnownDynamicAppRoute, isValidHTTPMethod, markKnownDynamicAppRoute };
-
-//# sourceMappingURL=app-route-handler-runtime.js.map

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

@@ -0,0 +1,43 @@
+//#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 `page` / `routeHandler` fields that the rest of the request
+ * pipeline reads directly. 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.page` or
+ * `route.routeHandler` (segment config, fetch-cache mode, runtime resolution,
+ * dispatch branch, element building, etc.).
+ */
+type LazyModuleThunk = () => Promise<unknown>;
+type LazyLoadableRoute = {
+  page?: unknown;
+  routeHandler?: unknown; /** 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; /** Set once the lazy modules have been resolved onto `page`/`routeHandler`. */
+  __loaded?: boolean; /** In-flight hydration promise, used to dedup concurrent loads. */
+  __loading?: Promise<unknown> | null;
+};
+/**
+ * Resolve a route's lazy page/route-handler modules and assign them onto the
+ * route's synchronous `page` / `routeHandler` 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 };

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

@@ -0,0 +1,32 @@
+//#region src/server/app-route-module-loader.ts
+/**
+* Resolve a route's lazy page/route-handler modules and assign them onto the
+* route's synchronous `page` / `routeHandler` 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;
+	if (!loadPage && !loadRouteHandler) {
+		route.__loaded = true;
+		return route;
+	}
+	const loading = Promise.all([loadPage ? loadPage() : void 0, loadRouteHandler ? loadRouteHandler() : void 0]).then(([pageModule, routeHandlerModule]) => {
+		if (loadPage) route.page = pageModule;
+		if (loadRouteHandler) route.routeHandler = routeHandlerModule;
+		route.__loaded = true;
+		route.__loading = null;
+		return route;
+	}).catch((error) => {
+		route.__loading = null;
+		throw error;
+	});
+	route.__loading = loading;
+	return loading;
+}
+//#endregion
+export { ensureAppRouteModulesLoaded };

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

@@ -10,5 +10,4 @@ declare const _default: {
   fetch(request: Request, env?: WorkerAssetEnv, ctx?: ExecutionContextLike): Promise<Response>;
 };
 //#endregion
-export { _default as default };
-//# sourceMappingURL=app-router-entry.d.ts.map
+export { _default as default };

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

@@ -5,6 +5,7 @@ import { cloneRequestWithHeaders, filterInternalHeaders, isOpenRedirectShaped }
 import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
 import { resolveStaticAssetSignal } from "./worker-utils.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 : "");
@@ -12,6 +13,7 @@ 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 {
@@ -39,5 +41,3 @@ async function handleRequest(request, env, ctx) {
 }
 //#endregion
 export { app_router_entry_default as default };
-
-//# sourceMappingURL=app-router-entry.js.map

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

@@ -3,7 +3,7 @@ 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 a `.rsc` payload vary.
+ * 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.
@@ -13,6 +13,7 @@ declare const VINEXT_RSC_COMPATIBILITY_ID_HEADER = "X-Vinext-RSC-Compatibility-I
 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;
@@ -38,6 +39,14 @@ declare function resolveRscCompatibilityNavigationDecision(options: {
   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;
@@ -48,8 +57,8 @@ declare function stripRscCacheBustingSearchParam(url: URL): void;
 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, getVinextRscCompatibilityId, isRscCompatibilityIdCompatible, resolveHardNavigationTargetFromRscResponse, resolveInvalidRscCacheBustingRequest, resolveRscCompatibilityNavigationDecision, setRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, stripRscSuffix };
-//# sourceMappingURL=app-rsc-cache-busting.d.ts.map
+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 };

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

@@ -1,9 +1,9 @@
-import { NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_RSC_RENDER_MODE_HEADER } from "./headers.js";
+import { NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_RSC_RENDER_MODE_HEADER } from "./headers.js";
 import { fnv1a64 } from "../utils/hash.js";
 import { parseAppRscRenderMode } from "./app-rsc-render-mode.js";
 //#region src/server/app-rsc-cache-busting.ts
 /**
-* RSC cache-busting hashes cover the headers that make a `.rsc` payload vary.
+* 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.
@@ -112,6 +112,16 @@ function isRscCacheBustingSearchPair(pair) {
 		return rawKey === VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM;
 	}
 }
+/**
+* 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`.
+*/
+function hasRscCacheBustingSearchParam(url) {
+	return (url.search.startsWith("?") ? url.search.slice(1) : url.search).split("&").some((pair) => pair.length > 0 && isRscCacheBustingSearchPair(pair));
+}
 async function computeRscCacheBustingSearchParam(headers) {
 	const input = createCacheBustingInput(headers);
 	if (input === null) return "";
@@ -140,23 +150,26 @@ function createRscRequestHeaders(options = {}) {
 	});
 	if (options.interceptionContext !== void 0 && options.interceptionContext !== null) headers.set(VINEXT_INTERCEPTION_CONTEXT_HEADER, options.interceptionContext);
 	if (options.mountedSlotsHeader !== void 0 && options.mountedSlotsHeader !== null) headers.set(VINEXT_MOUNTED_SLOTS_HEADER, options.mountedSlotsHeader);
+	if (options.clientReuseManifestHeader !== void 0 && options.clientReuseManifestHeader !== null) headers.set(VINEXT_CLIENT_REUSE_MANIFEST_HEADER, options.clientReuseManifestHeader);
 	const renderMode = options.renderMode ?? "navigation";
 	if (renderMode !== "navigation") headers.set(VINEXT_RSC_RENDER_MODE_HEADER, renderMode);
 	return headers;
 }
 function toRscRequestPath(href) {
 	const hashIndex = href.indexOf("#");
-	const beforeHash = hashIndex === -1 ? href : href.slice(0, hashIndex);
-	const queryIndex = beforeHash.indexOf("?");
-	const pathname = queryIndex === -1 ? beforeHash : beforeHash.slice(0, queryIndex);
-	const query = queryIndex === -1 ? "" : beforeHash.slice(queryIndex);
-	return `${pathname.length > 1 && pathname.endsWith("/") ? pathname.slice(0, -1) : pathname}.rsc${query}`;
+	return hashIndex === -1 ? href : href.slice(0, hashIndex);
 }
 async function createRscRequestUrl(href, headers) {
 	const url = new URL(toRscRequestPath(href), "http://vinext.local");
 	setRscCacheBustingSearchParam(url, await computeRscCacheBustingSearchParam(headers));
 	return `${url.pathname}${url.search}`;
 }
+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}`;
+}
 async function createRscRedirectLocation(location, request) {
 	const requestUrl = new URL(request.url);
 	const destinationUrl = new URL(location, requestUrl);
@@ -188,6 +201,4 @@ async function resolveInvalidRscCacheBustingRequest(options) {
 	});
 }
 //#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, getVinextRscCompatibilityId, isRscCompatibilityIdCompatible, resolveHardNavigationTargetFromRscResponse, resolveInvalidRscCacheBustingRequest, resolveRscCompatibilityNavigationDecision, setRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, stripRscSuffix };
-
-//# sourceMappingURL=app-rsc-cache-busting.js.map
+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 };

package/dist/server/app-rsc-embedded-chunks.d.ts

@@ -5,5 +5,4 @@ declare function bytesToBase64(bytes: Uint8Array): string;
 declare function decodeRscEmbeddedChunk(chunk: RscEmbeddedChunk): Uint8Array;
 declare function concatUint8Arrays(chunks: readonly Uint8Array[]): Uint8Array<ArrayBuffer>;
 //#endregion
-export { RSC_EMBEDDED_BINARY_CHUNK, RscEmbeddedChunk, bytesToBase64, concatUint8Arrays, decodeRscEmbeddedChunk };
-//# sourceMappingURL=app-rsc-embedded-chunks.d.ts.map
+export { RSC_EMBEDDED_BINARY_CHUNK, RscEmbeddedChunk, bytesToBase64, concatUint8Arrays, decodeRscEmbeddedChunk };

package/dist/server/app-rsc-embedded-chunks.js

@@ -30,5 +30,3 @@ function concatUint8Arrays(chunks) {
 }
 //#endregion
 export { RSC_EMBEDDED_BINARY_CHUNK, bytesToBase64, concatUint8Arrays, decodeRscEmbeddedChunk };
-
-//# sourceMappingURL=app-rsc-embedded-chunks.js.map

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

@@ -17,5 +17,4 @@ type ReportRequestError = (error: Error, requestInfo: {
  */
 declare function createAppRscOnErrorHandler(reportRequestError: ReportRequestError, request: Request, pathname: string, routePath: string): (error: unknown) => string | undefined;
 //#endregion
-export { createAppRscOnErrorHandler };
-//# sourceMappingURL=app-rsc-error-handler.d.ts.map
+export { createAppRscOnErrorHandler };

package/dist/server/app-rsc-error-handler.js

@@ -26,5 +26,3 @@ function createAppRscOnErrorHandler(reportRequestError, request, pathname, route
 }
 //#endregion
 export { createAppRscOnErrorHandler };
-
-//# sourceMappingURL=app-rsc-error-handler.js.map

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

@@ -26,5 +26,4 @@ declare function errorDigest(input: string): string;
 declare function sanitizeErrorForClient(error: unknown, nodeEnv?: string | undefined): unknown;
 declare function createRscOnErrorHandler(options: CreateRscOnErrorHandlerOptions): (error: unknown) => string | undefined;
 //#endregion
-export { createRscOnErrorHandler, errorDigest, hasDigest, sanitizeErrorForClient };
-//# sourceMappingURL=app-rsc-errors.d.ts.map
+export { createRscOnErrorHandler, errorDigest, hasDigest, sanitizeErrorForClient };

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

@@ -38,5 +38,3 @@ function createRscOnErrorHandler(options) {
 }
 //#endregion
 export { createRscOnErrorHandler, errorDigest, hasDigest, sanitizeErrorForClient };
-
-//# sourceMappingURL=app-rsc-errors.js.map

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

@@ -1,4 +1,5 @@
 import { NextHeader, NextI18nConfig, NextRedirect, NextRewrite } from "../config/next-config.js";
+import { ClientReuseManifestParseResult } from "./client-reuse-manifest.js";
 import { RootParams } from "../shims/root-params.js";
 import { MiddlewareModule } from "./middleware-runtime.js";
 import { AppMiddlewareContext } from "./app-middleware.js";
@@ -27,6 +28,7 @@ type AppRscRouteMatch<TRoute> = {
   route: TRoute;
 };
 type DispatchMatchedPageOptions<TRoute> = {
+  clientReuseManifest: ClientReuseManifestParseResult;
   cleanPathname: string;
   formState: ReactFormState | null;
   actionError?: unknown;
@@ -130,7 +132,20 @@ type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
   draftModeSecret: string;
   dispatchMatchedPage: (options: DispatchMatchedPageOptions<TRoute>) => Promise<Response>;
   dispatchMatchedRouteHandler: (options: DispatchMatchedRouteHandlerOptions<TRoute>) => Promise<Response>;
+  /**
+   * Hydrate a matched route's lazily-loaded page/route-handler modules before
+   * any synchronous read of `route.page` / `route.routeHandler`. Idempotent and
+   * dedup'd. Provided by the generated RSC entry; absent in older entries.
+   */
+  ensureRouteLoaded?: (route: TRoute) => unknown;
   ensureInstrumentation?: () => Promise<void>;
+  /**
+   * Register cache adapters configured via the vinext() `cache` option. Wired
+   * from the generated RSC entry (which can import `virtual:vinext-cache-adapters`)
+   * so config-driven cache handlers apply to App Router on EVERY runtime — the
+   * Node server and dev included, not just the Cloudflare worker entry.
+   */
+  registerCacheAdapters: (env?: Record<string, unknown>) => void;
   handleProgressiveActionRequest: (options: HandleProgressiveActionRequestOptions) => Promise<Response | ProgressiveActionFormStateResult | null>;
   handleServerActionRequest: (options: HandleServerActionRequestOptions) => Promise<Response | null>;
   i18nConfig: NextI18nConfig | null;
@@ -151,5 +166,4 @@ type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
 };
 declare function createAppRscHandler<TRoute extends AppRscHandlerRoute>(options: CreateAppRscHandlerOptions<TRoute>): (request: Request, ctx: unknown) => Promise<Response>;
 //#endregion
-export { createAppRscHandler };
-//# sourceMappingURL=app-rsc-handler.d.ts.map
+export { createAppRscHandler };

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

@@ -4,27 +4,37 @@ import { getRequestExecutionContext } from "../shims/request-context.js";
 import { ACTION_REVALIDATED_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER } from "./headers.js";
 import { isExternalUrl, matchRedirect, matchRewrite, proxyExternalRequest, requestContextFromRequest, sanitizeDestination } from "../config/config-matchers.js";
 import { notFoundResponse } from "./http-error-responses.js";
-import { applyConfigHeadersToResponse, cloneRequestWithHeaders, filterInternalHeaders, normalizeTrailingSlash, resolvePublicFileRoute, validateImageUrl } from "./request-pipeline.js";
+import { applyConfigHeadersToResponse, cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders, normalizeTrailingSlash, resolvePublicFileRoute, validateImageUrl } from "./request-pipeline.js";
 import { headersContextFromRequest } from "../shims/headers.js";
 import { ensureFetchPatch, setCurrentFetchSoftTags } from "../shims/fetch-cache.js";
-import { createRscRedirectLocation, resolveInvalidRscCacheBustingRequest, stripRscCacheBustingSearchParam, stripRscSuffix } from "./app-rsc-cache-busting.js";
+import { createRscRedirectLocation, hasRscCacheBustingSearchParam, resolveInvalidRscCacheBustingRequest, stripRscCacheBustingSearchParam, stripRscSuffix } from "./app-rsc-cache-busting.js";
 import { getScriptNonceFromHeaderSources } from "./csp.js";
 import { normalizeDefaultLocalePathname } from "./pages-i18n.js";
 import { isImageOptimizationPath } from "./image-optimization.js";
-import { prerenderRouteParamsPayloadMatchesRoute, readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
-import { flattenErrorCauses } from "../utils/error-cause.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import "./app-page-response.js";
+import { prerenderRouteParamsPayloadMatchesRoute, readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
+import { pickRootParams, setRootParams } from "../shims/root-params.js";
+import { flattenErrorCauses } from "../utils/error-cause.js";
 import { applyAppMiddleware } from "./app-middleware.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
 import { buildPostMwRequestContext } from "./app-post-middleware-context.js";
-import { pickRootParams, setRootParams } from "../shims/root-params.js";
 import { handleAppPrerenderEndpoint } from "./app-prerender-endpoints.js";
 import { finalizeAppRscResponse } from "./app-rsc-response-finalizer.js";
 import { normalizeRscRequest } from "./app-rsc-request-normalization.js";
 import { handleMetadataRouteRequest } from "./metadata-route-response.js";
 import { runWithPrerenderWorkUnit } from "./prerender-work-unit-setup.js";
 //#region src/server/app-rsc-handler.ts
+function applyMiddlewareContextToResponse(response, middlewareContext) {
+	if (!middlewareContext.headers && middlewareContext.status == null) return response;
+	const headers = new Headers(response.headers);
+	mergeMiddlewareResponseHeaders(headers, middlewareContext.headers);
+	return new Response(response.body, {
+		status: middlewareContext.status ?? response.status,
+		statusText: response.statusText,
+		headers
+	});
+}
 function hasProperty(value, key) {
 	return key in value;
 }
@@ -66,6 +76,12 @@ function applyConfigHeadersToMiddlewareRedirect(response, options) {
 	}
 	return response;
 }
+function requestWithoutRscCacheBustingSearchParam(request) {
+	const url = new URL(request.url);
+	if (!hasRscCacheBustingSearchParam(url)) return request;
+	stripRscCacheBustingSearchParam(url);
+	return cloneRequestWithUrl(request.body ? request.clone() : request, url.toString());
+}
 async function handleAppRscRequest(options, request, preMiddlewareRequestContext, isDataRequest) {
 	const handlerStart = process.env.NODE_ENV !== "production" ? performance.now() : 0;
 	if (process.env.NODE_ENV !== "production") {
@@ -74,7 +90,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	}
 	const normalized = normalizeRscRequest(request, options.basePath);
 	if (normalized instanceof Response) return normalized;
-	const { url, isRscRequest, interceptionContextHeader, mountedSlotsHeader, renderMode } = normalized;
+	const { url, isRscRequest, interceptionContextHeader, mountedSlotsHeader, renderMode, clientReuseManifest } = normalized;
 	let { pathname, cleanPathname } = normalized;
 	const canonicalPathname = cleanPathname;
 	const basePathState = {
@@ -108,6 +124,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		request
 	});
 	if (rscCacheBustingRedirect) return rscCacheBustingRedirect;
+	const userlandRequest = isRscRequest ? requestWithoutRscCacheBustingSearchParam(request) : request;
 	const middlewareContext = {
 		headers: null,
 		requestHeaders: null,
@@ -122,7 +139,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			isDataRequest,
 			isProxy: options.isMiddlewareProxy,
 			module: options.middlewareModule,
-			request,
+			request: userlandRequest,
 			trailingSlash: options.trailingSlash
 		});
 		if (middlewareResult.kind === "response") return applyConfigHeadersToMiddlewareRedirect(middlewareResult.response, {
@@ -135,11 +152,11 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		if (middlewareResult.search !== null) url.search = middlewareResult.search;
 	}
 	const scriptNonce = getScriptNonceFromHeaderSources(request.headers, middlewareContext.headers);
-	const postMiddlewareRequestContext = buildPostMwRequestContext(request);
+	const postMiddlewareRequestContext = buildPostMwRequestContext(userlandRequest);
 	const beforeFilesRewrite = await applyRewrite({
 		basePathState,
 		clearRequestContext: options.clearRequestContext,
-		request,
+		request: userlandRequest,
 		requestContext: postMiddlewareRequestContext,
 		rewrites: options.configRewrites.beforeFiles
 	}, matchPathname(cleanPathname));
@@ -155,7 +172,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		cleanPathname,
 		makeThenableParams: options.makeThenableParams
 	});
-	if (metadataRouteResponse) return metadataRouteResponse;
+	if (metadataRouteResponse) return applyMiddlewareContextToResponse(metadataRouteResponse, middlewareContext);
 	const publicFileResponse = resolvePublicFileRoute({
 		cleanPathname,
 		middlewareContext,
@@ -207,7 +224,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		const afterFilesRewrite = await applyRewrite({
 			basePathState,
 			clearRequestContext: options.clearRequestContext,
-			request,
+			request: userlandRequest,
 			requestContext: postMiddlewareRequestContext,
 			rewrites: options.configRewrites.afterFiles
 		}, matchPathname(cleanPathname));
@@ -221,7 +238,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		const fallbackRewrite = await applyRewrite({
 			basePathState,
 			clearRequestContext: options.clearRequestContext,
-			request,
+			request: userlandRequest,
 			requestContext: postMiddlewareRequestContext,
 			rewrites: options.configRewrites.fallback
 		}, matchPathname(cleanPathname));
@@ -260,6 +277,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		return notFoundResponse({ headers });
 	}
 	const { route, params } = match;
+	if (options.ensureRouteLoaded) await options.ensureRouteLoaded(route);
 	const prerenderRouteParamsPayload = readTrustedPrerenderRouteParams(request);
 	const prerenderRouteParams = prerenderRouteParamsPayloadMatchesRoute(prerenderRouteParamsPayload, route.pattern, params) ? prerenderRouteParamsPayload.params : null;
 	const renderParams = prerenderRouteParams ?? params;
@@ -282,6 +300,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		});
 	}
 	const pageResponse = await options.dispatchMatchedPage({
+		clientReuseManifest,
 		cleanPathname,
 		formState,
 		actionError,
@@ -338,6 +357,7 @@ function applyProgressiveActionSideEffects(response, sideEffects) {
 }
 function createAppRscHandler(options) {
 	return async function appRscHandler(rawRequest, ctx) {
+		options.registerCacheAdapters();
 		await options.ensureInstrumentation?.();
 		const mwCtx = rawRequest.headers.get(VINEXT_MW_CTX_HEADER);
 		const isDataRequest = rawRequest.headers.get("x-nextjs-data") === "1";
@@ -373,5 +393,3 @@ function createAppRscHandler(options) {
 }
 //#endregion
 export { createAppRscHandler };
-
-//# sourceMappingURL=app-rsc-handler.js.map

package/dist/server/app-rsc-render-mode.d.ts

@@ -8,5 +8,4 @@ declare function shouldSuppressLoadingBoundaries(mode: AppRscRenderMode): boolea
 declare function getRscRenderModeCacheVariant(mode: AppRscRenderMode): string | null;
 declare function parseAppRscRenderMode(value: string | null): AppRscRenderMode;
 //#endregion
-export { APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI, APP_RSC_RENDER_MODE_NAVIGATION, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI, AppRscRenderMode, getRscRenderModeCacheVariant, parseAppRscRenderMode, shouldSuppressLoadingBoundaries };
-//# sourceMappingURL=app-rsc-render-mode.d.ts.map
+export { APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI, APP_RSC_RENDER_MODE_NAVIGATION, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI, AppRscRenderMode, getRscRenderModeCacheVariant, parseAppRscRenderMode, shouldSuppressLoadingBoundaries };

package/dist/server/app-rsc-render-mode.js

@@ -23,5 +23,3 @@ function parseAppRscRenderMode(value) {
 }
 //#endregion
 export { APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI, APP_RSC_RENDER_MODE_NAVIGATION, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI, getRscRenderModeCacheVariant, parseAppRscRenderMode, shouldSuppressLoadingBoundaries };
-
-//# sourceMappingURL=app-rsc-render-mode.js.map

package/dist/server/app-rsc-request-normalization.d.ts

@@ -1,6 +1,6 @@
+import { ClientReuseManifestParseResult } from "./client-reuse-manifest.js";
 import { normalizeMountedSlotsHeader } from "./app-mounted-slots-header.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
-import { ClientReuseManifestParseResult } from "./client-reuse-manifest.js";
 
 //#region src/server/app-rsc-request-normalization.d.ts
 type NormalizedRscRequest = {
@@ -10,7 +10,7 @@ type NormalizedRscRequest = {
   isRscRequest: boolean; /** Sanitized X-Vinext-Interception-Context header (null bytes stripped). null when absent. */
   interceptionContextHeader: string | null; /** Normalized x-vinext-mounted-slots header (deduplicated, sorted). null when absent or blank. */
   mountedSlotsHeader: string | null; /** Semantic RSC payload mode. HTML requests always normalize to "navigation". */
-  renderMode: AppRscRenderMode; /** Disabled ClientReuseManifest hint. Never authorizes skip transport in this stage. */
+  renderMode: AppRscRenderMode; /** Parsed ClientReuseManifest hint. Verification and skip authorization happen later. */
   clientReuseManifest: ClientReuseManifestParseResult;
 };
 /**
@@ -38,12 +38,11 @@ type NormalizedRscRequest = {
  *   8. Sanitize X-Vinext-Interception-Context — strip null bytes (header injection)
  *   9. Normalize x-vinext-mounted-slots — dedup and sort for canonical cache keys
  *   10. Read semantic render mode for refresh/action payload rendering
- *   11. Parse disabled ClientReuseManifest hints on canonical RSC payload requests
+ *   11. Parse ClientReuseManifest hints on canonical RSC payload requests
  *
  * @returns A 400 or 404 Response for invalid or out-of-scope inputs,
  *          or a NormalizedRscRequest for valid requests.
  */
 declare function normalizeRscRequest(request: Request, basePath: string): Response | NormalizedRscRequest;
 //#endregion
-export { NormalizedRscRequest, normalizeMountedSlotsHeader, normalizeRscRequest };
-//# sourceMappingURL=app-rsc-request-normalization.d.ts.map
+export { NormalizedRscRequest, normalizeMountedSlotsHeader, normalizeRscRequest };

package/dist/server/app-rsc-request-normalization.js

@@ -7,8 +7,8 @@ import { guardProtocolRelativeUrl } from "./request-pipeline.js";
 import { normalizeMountedSlotsHeader } from "./app-mounted-slots-header.js";
 import { APP_RSC_RENDER_MODE_NAVIGATION, parseAppRscRenderMode } from "./app-rsc-render-mode.js";
 import { stripRscSuffix } from "./app-rsc-cache-busting.js";
-import { normalizeInterceptionContextHeader } from "./app-interception-context-header.js";
 import { parseClientReuseManifestHeader } from "./client-reuse-manifest.js";
+import { normalizeInterceptionContextHeader } from "./app-interception-context-header.js";
 //#region src/server/app-rsc-request-normalization.ts
 /**
 * Normalize an App Router RSC request.
@@ -35,7 +35,7 @@ import { parseClientReuseManifestHeader } from "./client-reuse-manifest.js";
 *   8. Sanitize X-Vinext-Interception-Context — strip null bytes (header injection)
 *   9. Normalize x-vinext-mounted-slots — dedup and sort for canonical cache keys
 *   10. Read semantic render mode for refresh/action payload rendering
-*   11. Parse disabled ClientReuseManifest hints on canonical RSC payload requests
+*   11. Parse ClientReuseManifest hints on canonical RSC payload requests
 *
 * @returns A 400 or 404 Response for invalid or out-of-scope inputs,
 *          or a NormalizedRscRequest for valid requests.
@@ -73,5 +73,3 @@ function normalizeRscRequest(request, basePath) {
 }
 //#endregion
 export { normalizeMountedSlotsHeader, normalizeRscRequest };
-
-//# sourceMappingURL=app-rsc-request-normalization.js.map

package/dist/server/app-rsc-response-finalizer.d.ts

@@ -34,5 +34,4 @@ type FinalizeAppRscResponseOptions = {
  */
 declare function finalizeAppRscResponse(response: Response, request: Request, options: FinalizeAppRscResponseOptions): Response;
 //#endregion
-export { finalizeAppRscResponse };
-//# sourceMappingURL=app-rsc-response-finalizer.d.ts.map
+export { finalizeAppRscResponse };

package/dist/server/app-rsc-response-finalizer.js

@@ -5,6 +5,7 @@ import { normalizePath } from "./normalize-path.js";
 import { applyConfigHeadersToResponse } from "./request-pipeline.js";
 import { VINEXT_RSC_VARY_HEADER } from "./app-rsc-cache-busting.js";
 import { normalizeDefaultLocalePathname } from "./pages-i18n.js";
+import { applyCdnResponseHeaders } from "./cache-control.js";
 import { mergeVaryHeader } from "./middleware-response-headers.js";
 //#region src/server/app-rsc-response-finalizer.ts
 /**
@@ -22,6 +23,7 @@ import { mergeVaryHeader } from "./middleware-response-headers.js";
 function finalizeAppRscResponse(response, request, options) {
 	if (response.status >= 300 && response.status < 400) return response;
 	if (!response.headers.has("x-vinext-static-file")) mergeVaryHeader(response.headers, VINEXT_RSC_VARY_HEADER);
+	if (!response.headers.has("Cache-Control")) applyCdnResponseHeaders(response.headers, { cacheControl: "" });
 	if (!options.configHeaders.length) return response;
 	const url = new URL(request.url);
 	let pathname;
@@ -46,5 +48,3 @@ function finalizeAppRscResponse(response, request, options) {
 }
 //#endregion
 export { finalizeAppRscResponse };
-
-//# sourceMappingURL=app-rsc-response-finalizer.js.map

package/dist/server/app-rsc-route-matching.d.ts

@@ -59,5 +59,4 @@ declare function createAppRscRouteMatcher<Route extends AppRscRouteForMatching>(
 };
 declare function matchAppRscRoutePattern(urlParts: string[], patternParts: string[]): AppRscRouteParams | null;
 //#endregion
-export { createAppRscRouteMatcher, matchAppRscRoutePattern };
-//# sourceMappingURL=app-rsc-route-matching.d.ts.map
+export { createAppRscRouteMatcher, matchAppRscRoutePattern };