vinext 0.0.55 → 0.1.0

package/dist/server/app-prerender-static-params.js

@@ -1,29 +1,62 @@
+import { isUnknownRecord } from "../utils/record.js";
 import { pickRootParams, runWithRootParamsScope } from "../shims/root-params.js";
 //#region src/server/app-prerender-static-params.ts
 function isGenerateStaticParamsFunction(value) {
 	return typeof value === "function";
 }
+function isLazyStaticParamsSource(value) {
+	return typeof value === "object" && value !== null && "load" in value && typeof value.load === "function";
+}
 function isRootParams(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value);
+	return isUnknownRecord(value);
 }
+/**
+* Build a prerender `generateStaticParams` resolver for one route pattern.
+*
+* `sources` may mix eager functions (layout `generateStaticParams`, which stay
+* eagerly imported) and lazy `{ load }` page sources (code-split page modules).
+* Lazy sources are imported once on first invocation. The returned resolver:
+*
+*  - returns `null` when, after resolving every source, no `generateStaticParams`
+*    export exists for the pattern — the sentinel the prerender driver uses to
+*    skip the route (or error under `output: export`);
+*  - otherwise composes all sources into the cartesian set of param objects.
+*
+* Returns `null` (no resolver) only when the pattern has zero sources at all.
+*/
 function createAppPrerenderStaticParamsResolver(sources, rootParamNames) {
-	const generateStaticParamsFns = sources.filter(isGenerateStaticParamsFunction);
-	if (generateStaticParamsFns.length === 0) return null;
+	const usableSources = sources.filter((source) => isGenerateStaticParamsFunction(source) || isLazyStaticParamsSource(source));
+	if (usableSources.length === 0) return null;
 	const filterRootParams = (params) => pickRootParams(params, rootParamNames ?? []);
-	if (generateStaticParamsFns.length === 1) {
-		const single = generateStaticParamsFns[0];
-		return async (input) => {
+	let resolvedFns = null;
+	let resolvePromise = null;
+	const resolveFns = () => {
+		if (resolvedFns) return Promise.resolve(resolvedFns);
+		if (!resolvePromise) resolvePromise = (async () => {
+			resolvedFns = (await Promise.all(usableSources.map(async (source) => {
+				if (isGenerateStaticParamsFunction(source)) return source;
+				const mod = await source.load();
+				const fn = mod && typeof mod === "object" ? mod.generateStaticParams : void 0;
+				return isGenerateStaticParamsFunction(fn) ? fn : null;
+			}))).filter((fn) => fn !== null);
+			return resolvedFns;
+		})();
+		return resolvePromise;
+	};
+	return async (input) => {
+		const fns = await resolveFns();
+		if (fns.length === 0) return null;
+		if (fns.length === 1) {
+			const single = fns[0];
 			return runWithRootParamsScope(filterRootParams(input.params), async () => {
 				const result = await single(input);
 				if (!Array.isArray(result)) return [];
 				for (const item of result) if (!isRootParams(item)) return [];
 				return result;
 			});
-		};
-	}
-	return async ({ params }) => {
-		let paramSets = [params];
-		for (const generateStaticParams of generateStaticParamsFns) {
+		}
+		let paramSets = [input.params];
+		for (const generateStaticParams of fns) {
 			const nextParamSets = [];
 			for (const parentParams of paramSets) {
 				const result = await runWithRootParamsScope(filterRootParams(parentParams), async () => generateStaticParams({ params: parentParams }));
@@ -46,5 +79,3 @@ async function callAppPrerenderStaticParams(options) {
 }
 //#endregion
 export { callAppPrerenderStaticParams, createAppPrerenderStaticParamsResolver };
-
-//# sourceMappingURL=app-prerender-static-params.js.map

package/dist/server/app-render-dependency.d.ts

@@ -5,9 +5,10 @@ type AppRenderDependency = {
   promise: Promise<void>;
   release: () => void;
 };
+declare function registerAppElementRenderDependencies(elements: Readonly<Record<string, unknown>>, dependenciesByElementId: ReadonlyMap<string, AppRenderDependency>): void;
+declare function releaseAppElementRenderDependency(elements: Readonly<Record<string, unknown>>, elementId: string): void;
 declare function createAppRenderDependency(): AppRenderDependency;
 declare function renderAfterAppDependencies(children: ReactNode, dependencies: readonly AppRenderDependency[]): ReactNode;
 declare function renderWithAppDependencyBarrier(children: ReactNode, dependency: AppRenderDependency): ReactNode;
 //#endregion
-export { AppRenderDependency, createAppRenderDependency, renderAfterAppDependencies, renderWithAppDependencyBarrier };
-//# sourceMappingURL=app-render-dependency.d.ts.map
+export { AppRenderDependency, createAppRenderDependency, registerAppElementRenderDependencies, releaseAppElementRenderDependency, renderAfterAppDependencies, renderWithAppDependencyBarrier };

package/dist/server/app-render-dependency.js

@@ -1,5 +1,13 @@
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 //#region src/server/app-render-dependency.tsx
+const appElementRenderDependencies = /* @__PURE__ */ new WeakMap();
+function registerAppElementRenderDependencies(elements, dependenciesByElementId) {
+	if (dependenciesByElementId.size === 0) return;
+	appElementRenderDependencies.set(elements, dependenciesByElementId);
+}
+function releaseAppElementRenderDependency(elements, elementId) {
+	appElementRenderDependencies.get(elements)?.get(elementId)?.release();
+}
 function createAppRenderDependency() {
 	let released = false;
 	let resolve;
@@ -30,6 +38,4 @@ function renderWithAppDependencyBarrier(children, dependency) {
 	return /* @__PURE__ */ jsxs(Fragment, { children: [children, /* @__PURE__ */ jsx(ReleaseAppRenderDependency, {})] });
 }
 //#endregion
-export { createAppRenderDependency, renderAfterAppDependencies, renderWithAppDependencyBarrier };
-
-//# sourceMappingURL=app-render-dependency.js.map
+export { createAppRenderDependency, registerAppElementRenderDependencies, releaseAppElementRenderDependency, renderAfterAppDependencies, renderWithAppDependencyBarrier };

package/dist/server/app-request-context.d.ts

@@ -18,5 +18,4 @@ declare function setAppNavigationContext(ctx: NavigationContext | null): void;
  */
 declare function clearAppRequestContext(): void;
 //#endregion
-export { clearAppRequestContext, setAppNavigationContext };
-//# sourceMappingURL=app-request-context.d.ts.map
+export { clearAppRequestContext, setAppNavigationContext };

package/dist/server/app-request-context.js

@@ -26,5 +26,3 @@ function clearAppRequestContext() {
 }
 //#endregion
 export { clearAppRequestContext, setAppNavigationContext };
-
-//# sourceMappingURL=app-request-context.js.map

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

@@ -42,5 +42,4 @@ type ReadAppRouteHandlerCacheOptions = {
 };
 declare function readAppRouteHandlerCacheResponse(options: ReadAppRouteHandlerCacheOptions): Promise<Response | null>;
 //#endregion
-export { readAppRouteHandlerCacheResponse };
-//# sourceMappingURL=app-route-handler-cache.d.ts.map
+export { readAppRouteHandlerCacheResponse };

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

@@ -75,5 +75,3 @@ async function readAppRouteHandlerCacheResponse(options) {
 }
 //#endregion
 export { readAppRouteHandlerCacheResponse };
-
-//# sourceMappingURL=app-route-handler-cache.js.map

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

@@ -45,5 +45,4 @@ type DispatchAppRouteHandlerOptions = {
 };
 declare function dispatchAppRouteHandler(options: DispatchAppRouteHandlerOptions): Promise<Response>;
 //#endregion
-export { dispatchAppRouteHandler };
-//# sourceMappingURL=app-route-handler-dispatch.d.ts.map
+export { dispatchAppRouteHandler };

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

@@ -151,5 +151,3 @@ async function dispatchAppRouteHandler(options) {
 }
 //#endregion
 export { dispatchAppRouteHandler };
-
-//# sourceMappingURL=app-route-handler-dispatch.js.map

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

@@ -82,5 +82,4 @@ type ExecuteAppRouteHandlerOptions = {
 declare function runAppRouteHandler(options: RunAppRouteHandlerOptions): Promise<RunAppRouteHandlerResult>;
 declare function executeAppRouteHandler(options: ExecuteAppRouteHandlerOptions): Promise<Response>;
 //#endregion
-export { AppRouteDebugLogger, AppRouteDynamicUsageFn, AppRouteHandlerFunction, AppRouteParams, MarkAppRouteDynamicUsageFn, RouteHandlerCacheSetter, executeAppRouteHandler, runAppRouteHandler };
-//# sourceMappingURL=app-route-handler-execution.d.ts.map
+export { AppRouteDebugLogger, AppRouteDynamicUsageFn, AppRouteHandlerFunction, AppRouteParams, MarkAppRouteDynamicUsageFn, RouteHandlerCacheSetter, executeAppRouteHandler, runAppRouteHandler };

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

@@ -46,6 +46,7 @@ async function executeAppRouteHandler(options) {
 		assertSupportedAppRouteHandlerResponse(response);
 		const handlerSetCacheControl = response.headers.has("cache-control");
 		if (dynamicUsedInHandler) markKnownDynamicAppRoute(options.routePattern);
+		const routeTags = options.buildPageCacheTags(options.cleanPathname, options.getCollectedFetchTags());
 		if (shouldApplyAppRouteHandlerRevalidateHeader({
 			dynamicUsedInHandler,
 			handlerSetCacheControl,
@@ -55,7 +56,7 @@ async function executeAppRouteHandler(options) {
 		})) {
 			const revalidateSeconds = options.revalidateSeconds;
 			if (revalidateSeconds == null) throw new Error("Expected route handler revalidate seconds");
-			applyRouteHandlerRevalidateHeader(response, revalidateSeconds, options.expireSeconds);
+			applyRouteHandlerRevalidateHeader(response, revalidateSeconds, options.expireSeconds, routeTags);
 		}
 		if (shouldWriteAppRouteHandlerCache({
 			dynamicConfig: options.handler.dynamic,
@@ -71,7 +72,6 @@ async function executeAppRouteHandler(options) {
 			const routeKey = options.isrRouteKey(options.cleanPathname);
 			const revalidateSeconds = options.revalidateSeconds;
 			if (revalidateSeconds == null) throw new Error("Expected route handler cache revalidate seconds");
-			const routeTags = options.buildPageCacheTags(options.cleanPathname, options.getCollectedFetchTags());
 			const routeWritePromise = (async () => {
 				try {
 					const routeCacheValue = await buildAppRouteCacheValue(routeClone);
@@ -124,5 +124,3 @@ async function executeAppRouteHandler(options) {
 }
 //#endregion
 export { executeAppRouteHandler, runAppRouteHandler };
-
-//# sourceMappingURL=app-route-handler-execution.js.map

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

@@ -51,5 +51,4 @@ declare function shouldApplyAppRouteHandlerRevalidateHeader(options: Omit<AppRou
 declare function shouldWriteAppRouteHandlerCache(options: AppRouteHandlerResponseCacheOptions): boolean;
 declare function resolveAppRouteHandlerSpecialError(error: unknown, requestUrl: string, options?: AppRouteHandlerSpecialErrorOptions): AppRouteHandlerSpecialError | null;
 //#endregion
-export { AppRouteHandlerModule, getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, isPossibleAppRouteActionRequest, resolveAppRouteHandlerMethod, resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidateHeader, shouldReadAppRouteHandlerCache, shouldWriteAppRouteHandlerCache };
-//# sourceMappingURL=app-route-handler-policy.d.ts.map
+export { AppRouteHandlerModule, getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, isPossibleAppRouteActionRequest, resolveAppRouteHandlerMethod, resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidateHeader, shouldReadAppRouteHandlerCache, shouldWriteAppRouteHandlerCache };

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

@@ -61,5 +61,3 @@ function resolveAppRouteHandlerSpecialError(error, requestUrl, options) {
 }
 //#endregion
 export { getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, isPossibleAppRouteActionRequest, resolveAppRouteHandlerMethod, resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidateHeader, shouldReadAppRouteHandlerCache, shouldWriteAppRouteHandlerCache };
-
-//# sourceMappingURL=app-route-handler-policy.js.map

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

@@ -20,10 +20,9 @@ type FinalizeRouteHandlerResponseOptions = {
 declare function applyRouteHandlerMiddlewareContext(response: Response, middlewareContext: RouteHandlerMiddlewareContext): Response;
 declare function assertSupportedAppRouteHandlerResponse(response: Response): void;
 declare function buildRouteHandlerCachedResponse(cachedValue: CachedRouteValue, options: BuildRouteHandlerCachedResponseOptions): Response;
-declare function applyRouteHandlerRevalidateHeader(response: Response, revalidateSeconds: number, expireSeconds?: number): void;
+declare function applyRouteHandlerRevalidateHeader(response: Response, revalidateSeconds: number, expireSeconds?: number, tags?: readonly string[]): void;
 declare function markRouteHandlerCacheMiss(response: Response): void;
 declare function buildAppRouteCacheValue(response: Response): Promise<CachedRouteValue>;
 declare function finalizeRouteHandlerResponse(response: Response, options: FinalizeRouteHandlerResponseOptions): Response;
 //#endregion
-export { RouteHandlerMiddlewareContext, applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, buildRouteHandlerCachedResponse, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss };
-//# sourceMappingURL=app-route-handler-response.d.ts.map
+export { RouteHandlerMiddlewareContext, applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, buildRouteHandlerCachedResponse, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss };

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");
@@ -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

@@ -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;
@@ -52,5 +61,4 @@ 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, 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,4 +1,4 @@
-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
@@ -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,6 +150,7 @@ 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;
@@ -190,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, createServerActionRequestUrl, 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 };