vinext 0.0.54 → 0.1.0

package/dist/server/app-inline-css-client.d.ts

@@ -3,5 +3,4 @@ type InlineCssStylesheetLinkElement = Pick<HTMLLinkElement, "getAttribute" | "ha
 declare function isInlineCssStylesheetLinkElement(link: InlineCssStylesheetLinkElement): boolean;
 declare function removeStylesheetLinksCoveredByInlineCss(): void;
 //#endregion
-export { isInlineCssStylesheetLinkElement, removeStylesheetLinksCoveredByInlineCss };
-//# sourceMappingURL=app-inline-css-client.d.ts.map
+export { isInlineCssStylesheetLinkElement, removeStylesheetLinksCoveredByInlineCss };

package/dist/server/app-inline-css-client.js

@@ -33,5 +33,3 @@ function removeStylesheetLinksCoveredByInlineCss() {
 }
 //#endregion
 export { isInlineCssStylesheetLinkElement, removeStylesheetLinksCoveredByInlineCss };
-
-//# sourceMappingURL=app-inline-css-client.js.map

package/dist/server/app-interception-context-header.d.ts

@@ -29,5 +29,4 @@
  */
 declare function normalizeInterceptionContextHeader(raw: string | null | undefined): string | null;
 //#endregion
-export { normalizeInterceptionContextHeader };
-//# sourceMappingURL=app-interception-context-header.d.ts.map
+export { normalizeInterceptionContextHeader };

package/dist/server/app-interception-context-header.js

@@ -40,5 +40,3 @@ function normalizeInterceptionContextHeader(raw) {
 }
 //#endregion
 export { normalizeInterceptionContextHeader };
-
-//# sourceMappingURL=app-interception-context-header.js.map

package/dist/server/app-layout-param-observation.d.ts

@@ -0,0 +1,43 @@
+import { RenderRequestApiKind } from "./cache-proof.js";
+import { UnstableCacheObservation } from "../shims/cache.js";
+import { ClientReuseManifestRejectionCode, ClientReuseManifestTraceFields } from "./client-reuse-manifest.js";
+import { ThenableParamsObserver } from "../shims/thenable-params.js";
+
+//#region src/server/app-layout-param-observation.d.ts
+type AppLayoutParamAccessObservation = Readonly<{
+  cacheLifeObserved: boolean;
+  cacheTags: readonly string[];
+  cacheableFetchCount: number;
+  completeness: "complete" | "unknown";
+  dynamicFetchCount: number;
+  /**
+   * `markDynamicUsage()` fired during the probe (e.g. `"use cache: private"`,
+   * `connection()`) with no other observable trace. Folded in from the
+   * isolated probe scope so this signal can't diverge from the Layer-3
+   * `dynamicDetected` path it replaced.
+   */
+  dynamicUsageObserved: boolean;
+  finiteRevalidateSeconds: number | null;
+  keys: readonly string[];
+  observed: boolean;
+  paramScopeKeys: readonly string[];
+  requestApis: readonly RenderRequestApiKind[];
+  unstableCaches: readonly UnstableCacheObservation[];
+}>;
+type AppLayoutParamAccessTracker = Readonly<{
+  createThenableParamsObserver: (layoutId: string) => ThenableParamsObserver;
+  getLayoutObservation: (layoutId: string) => AppLayoutParamAccessObservation;
+  recordLayoutFiniteRevalidate: (layoutId: string, revalidateSeconds: number) => void;
+  recordLayoutParamScope: (layoutId: string, paramScopeKeys: readonly string[]) => void;
+  runLayoutProbe: (layoutId: string, probe: () => unknown) => unknown;
+}>;
+type StaticLayoutObservationSkipCode = Extract<ClientReuseManifestRejectionCode, `SKIP_LAYOUT_${string}`>;
+type StaticLayoutObservationSkipRejection = Readonly<{
+  code: StaticLayoutObservationSkipCode;
+  fields: ClientReuseManifestTraceFields;
+}>;
+declare function getStaticLayoutObservationSkipRejection(observation: AppLayoutParamAccessObservation): StaticLayoutObservationSkipRejection | null;
+declare function isAppLayoutObservationUnsafeForStaticReuse(observation: AppLayoutParamAccessObservation): boolean;
+declare function createAppLayoutParamAccessTracker(): AppLayoutParamAccessTracker;
+//#endregion
+export { AppLayoutParamAccessObservation, AppLayoutParamAccessTracker, StaticLayoutObservationSkipRejection, createAppLayoutParamAccessTracker, getStaticLayoutObservationSkipRejection, isAppLayoutObservationUnsafeForStaticReuse };

package/dist/server/app-layout-param-observation.js

@@ -0,0 +1,168 @@
+import { isInsideUnifiedScope, runWithUnifiedStateMutation } from "../shims/unified-request-context.js";
+import { peekDynamicUsage, peekRenderRequestApiUsage } from "../shims/headers.js";
+import { _peekRequestScopedCacheLife, _peekUnstableCacheObservations } from "../shims/cache.js";
+import { getCollectedFetchTags, peekCacheableFetchObservations, peekDynamicFetchObservations } from "../shims/fetch-cache.js";
+import { isPromiseLike } from "../utils/promise.js";
+//#region src/server/app-layout-param-observation.ts
+const STATIC_LAYOUT_OBSERVATION_SKIP_RULES = [
+	["SKIP_LAYOUT_PARAMS_OBSERVATION_INCOMPLETE", (observation) => observation.completeness !== "complete"],
+	["SKIP_LAYOUT_PARAMS_PRESENT", (observation) => observation.paramScopeKeys.length > 0],
+	["SKIP_LAYOUT_PARAMS_OBSERVED", (observation) => observation.observed],
+	["SKIP_LAYOUT_DYNAMIC_USAGE_OBSERVED", (observation) => observation.dynamicUsageObserved],
+	["SKIP_LAYOUT_REQUEST_API_OBSERVED", (observation) => observation.requestApis.length > 0],
+	["SKIP_LAYOUT_REVALIDATE_PRESENT", (observation) => observation.finiteRevalidateSeconds !== null],
+	["SKIP_LAYOUT_CACHE_LIFE_OBSERVED", (observation) => observation.cacheLifeObserved],
+	["SKIP_LAYOUT_UNSTABLE_CACHE_OBSERVED", (observation) => observation.unstableCaches.length > 0],
+	["SKIP_LAYOUT_CACHE_TAGS_OBSERVED", (observation) => observation.cacheTags.length > 0],
+	["SKIP_LAYOUT_CACHEABLE_FETCHES_OBSERVED", (observation) => observation.cacheableFetchCount > 0],
+	["SKIP_LAYOUT_DYNAMIC_FETCHES_OBSERVED", (observation) => observation.dynamicFetchCount > 0]
+];
+function createStaticLayoutObservationTraceFields(observation) {
+	return {
+		cacheLifeObserved: observation.cacheLifeObserved,
+		cacheTags: observation.cacheTags,
+		cacheableFetchCount: observation.cacheableFetchCount,
+		dynamicFetchCount: observation.dynamicFetchCount,
+		dynamicUsageObserved: observation.dynamicUsageObserved,
+		finiteRevalidateSeconds: observation.finiteRevalidateSeconds,
+		observedParamKeys: observation.keys,
+		paramScopeKeys: observation.paramScopeKeys,
+		requestApis: observation.requestApis,
+		unstableCacheCount: observation.unstableCaches.length,
+		unstableCacheKeyHashes: observation.unstableCaches.map((cache) => cache.keyHash),
+		unstableCacheRevalidates: observation.unstableCaches.map((cache) => String(cache.revalidate)),
+		unstableCacheTagCounts: observation.unstableCaches.map((cache) => String(cache.tagCount)),
+		unstableCacheTagHashes: observation.unstableCaches.map((cache) => cache.tagHash ?? "none")
+	};
+}
+function getStaticLayoutObservationSkipRejection(observation) {
+	for (const [code, matches] of STATIC_LAYOUT_OBSERVATION_SKIP_RULES) if (matches(observation)) return {
+		code,
+		fields: createStaticLayoutObservationTraceFields(observation)
+	};
+	return null;
+}
+function isAppLayoutObservationUnsafeForStaticReuse(observation) {
+	return getStaticLayoutObservationSkipRejection(observation) !== null;
+}
+function createAppLayoutParamAccessTracker() {
+	const observations = /* @__PURE__ */ new Map();
+	const ensureObservation = (layoutId) => {
+		const existing = observations.get(layoutId);
+		if (existing) return existing;
+		const created = {
+			cacheLifeObserved: false,
+			cacheTags: /* @__PURE__ */ new Set(),
+			cacheableFetches: /* @__PURE__ */ new Set(),
+			dynamicFetches: /* @__PURE__ */ new Set(),
+			dynamicUsageObserved: false,
+			finiteRevalidateSeconds: null,
+			keys: /* @__PURE__ */ new Set(),
+			observed: false,
+			paramScopeKeys: /* @__PURE__ */ new Set(),
+			probeComplete: false,
+			requestApis: /* @__PURE__ */ new Set(),
+			unstableCaches: /* @__PURE__ */ new Map()
+		};
+		observations.set(layoutId, created);
+		return created;
+	};
+	const markObserved = (layoutId, keys) => {
+		const observation = ensureObservation(layoutId);
+		observation.observed = true;
+		for (const key of keys) observation.keys.add(key);
+	};
+	const markProbeComplete = (layoutId) => {
+		ensureObservation(layoutId).probeComplete = true;
+	};
+	const runWithIsolatedProbeDependencies = (probe) => {
+		if (!isInsideUnifiedScope()) return probe();
+		return runWithUnifiedStateMutation((ctx) => {
+			ctx.cacheableFetchUrls = /* @__PURE__ */ new Set();
+			ctx.currentRequestTags = [];
+			ctx.currentFetchSoftTags = [];
+			ctx.dynamicFetchUrls = /* @__PURE__ */ new Set();
+			ctx.dynamicUsageDetected = false;
+			ctx.renderRequestApiUsage = /* @__PURE__ */ new Set();
+			ctx.requestScopedCacheLife = null;
+			ctx.unstableCacheObservations = /* @__PURE__ */ new Map();
+		}, probe);
+	};
+	const recordProbeDependencies = (layoutId) => {
+		const observation = ensureObservation(layoutId);
+		if (peekDynamicUsage()) observation.dynamicUsageObserved = true;
+		if (_peekRequestScopedCacheLife() !== null) observation.cacheLifeObserved = true;
+		for (const tag of getCollectedFetchTags()) observation.cacheTags.add(tag);
+		for (const url of peekCacheableFetchObservations()) observation.cacheableFetches.add(url);
+		for (const url of peekDynamicFetchObservations()) observation.dynamicFetches.add(url);
+		for (const requestApi of peekRenderRequestApiUsage()) observation.requestApis.add(requestApi);
+		for (const unstableCache of _peekUnstableCacheObservations()) observation.unstableCaches.set(unstableCache.keyHash, unstableCache);
+	};
+	return {
+		createThenableParamsObserver(layoutId) {
+			return { observeParamAccess(keys) {
+				markObserved(layoutId, keys);
+			} };
+		},
+		getLayoutObservation(layoutId) {
+			const observation = observations.get(layoutId);
+			if (!observation) return {
+				cacheLifeObserved: false,
+				cacheTags: [],
+				cacheableFetchCount: 0,
+				completeness: "unknown",
+				dynamicFetchCount: 0,
+				dynamicUsageObserved: false,
+				finiteRevalidateSeconds: null,
+				keys: [],
+				observed: false,
+				paramScopeKeys: [],
+				requestApis: [],
+				unstableCaches: []
+			};
+			return {
+				cacheLifeObserved: observation.cacheLifeObserved,
+				cacheTags: [...observation.cacheTags].sort(),
+				cacheableFetchCount: observation.cacheableFetches.size,
+				completeness: observation.probeComplete ? "complete" : "unknown",
+				dynamicFetchCount: observation.dynamicFetches.size,
+				dynamicUsageObserved: observation.dynamicUsageObserved,
+				finiteRevalidateSeconds: observation.finiteRevalidateSeconds,
+				keys: [...observation.keys].sort(),
+				observed: observation.observed,
+				paramScopeKeys: [...observation.paramScopeKeys].sort(),
+				requestApis: [...observation.requestApis].sort(),
+				unstableCaches: [...observation.unstableCaches.values()].sort((a, b) => a.keyHash.localeCompare(b.keyHash))
+			};
+		},
+		recordLayoutFiniteRevalidate(layoutId, revalidateSeconds) {
+			if (!Number.isFinite(revalidateSeconds) || revalidateSeconds <= 0) return;
+			const observation = ensureObservation(layoutId);
+			observation.finiteRevalidateSeconds = observation.finiteRevalidateSeconds === null ? revalidateSeconds : Math.min(observation.finiteRevalidateSeconds, revalidateSeconds);
+		},
+		recordLayoutParamScope(layoutId, paramScopeKeys) {
+			const observation = ensureObservation(layoutId);
+			for (const key of paramScopeKeys) observation.paramScopeKeys.add(key);
+		},
+		runLayoutProbe(layoutId, probe) {
+			return runWithIsolatedProbeDependencies(() => {
+				const result = probe();
+				if (!isPromiseLike(result)) {
+					recordProbeDependencies(layoutId);
+					markProbeComplete(layoutId);
+					return result;
+				}
+				return Promise.resolve(result).then((resolved) => {
+					recordProbeDependencies(layoutId);
+					markProbeComplete(layoutId);
+					return resolved;
+				}, (error) => {
+					recordProbeDependencies(layoutId);
+					throw error;
+				});
+			});
+		}
+	};
+}
+//#endregion
+export { createAppLayoutParamAccessTracker, getStaticLayoutObservationSkipRejection, isAppLayoutObservationUnsafeForStaticReuse };

package/dist/server/app-middleware.d.ts

@@ -42,5 +42,4 @@ declare function isExternalMiddlewareRewrite(rewriteUrl: string, request: Reques
 declare function proxyExternalMiddlewareRewrite(request: Request, rewriteUrl: string, context: AppMiddlewareContext): Promise<Response>;
 declare function applyAppMiddleware(options: ApplyAppMiddlewareOptions): Promise<ApplyAppMiddlewareResult>;
 //#endregion
-export { AppMiddlewareContext, ApplyAppMiddlewareOptions, ApplyAppMiddlewareResult, FLIGHT_HEADERS, applyAppMiddleware, isExternalMiddlewareRewrite, proxyExternalMiddlewareRewrite };
-//# sourceMappingURL=app-middleware.d.ts.map
+export { AppMiddlewareContext, ApplyAppMiddlewareOptions, ApplyAppMiddlewareResult, FLIGHT_HEADERS, applyAppMiddleware, isExternalMiddlewareRewrite, proxyExternalMiddlewareRewrite };

package/dist/server/app-middleware.js

@@ -163,5 +163,3 @@ async function applyAppMiddleware(options) {
 }
 //#endregion
 export { FLIGHT_HEADERS, applyAppMiddleware, isExternalMiddlewareRewrite, proxyExternalMiddlewareRewrite };
-
-//# sourceMappingURL=app-middleware.js.map

package/dist/server/app-mounted-slots-header.d.ts

@@ -32,5 +32,4 @@
  */
 declare function normalizeMountedSlotsHeader(raw: string | null | undefined): string | null;
 //#endregion
-export { normalizeMountedSlotsHeader };
-//# sourceMappingURL=app-mounted-slots-header.d.ts.map
+export { normalizeMountedSlotsHeader };

package/dist/server/app-mounted-slots-header.js

@@ -56,5 +56,3 @@ function normalizeMountedSlotsHeader(raw) {
 }
 //#endregion
 export { normalizeMountedSlotsHeader };
-
-//# sourceMappingURL=app-mounted-slots-header.js.map

package/dist/server/app-optimistic-routing.d.ts

@@ -50,5 +50,4 @@ declare function resolveOptimisticNavigationPayload(options: {
   templates: ReadonlyMap<string, OptimisticRouteTemplate>;
 }): OptimisticNavigationPayload | null;
 //#endregion
-export { OptimisticRouteTemplate, createOptimisticRouteElements, createOptimisticRouteTemplate, getOptimisticPrefetchSourceKey, getOptimisticRouteTemplateKey, matchOptimisticRouteManifestRoute, resolveOptimisticNavigationPayload };
-//# sourceMappingURL=app-optimistic-routing.d.ts.map
+export { OptimisticRouteTemplate, createOptimisticRouteElements, createOptimisticRouteTemplate, getOptimisticPrefetchSourceKey, getOptimisticRouteTemplateKey, matchOptimisticRouteManifestRoute, resolveOptimisticNavigationPayload };

package/dist/server/app-optimistic-routing.js

@@ -204,5 +204,3 @@ function resolveOptimisticNavigationPayload(options) {
 }
 //#endregion
 export { createOptimisticRouteElements, createOptimisticRouteTemplate, getOptimisticPrefetchSourceKey, getOptimisticRouteTemplateKey, matchOptimisticRouteManifestRoute, resolveOptimisticNavigationPayload };
-
-//# sourceMappingURL=app-optimistic-routing.js.map

package/dist/server/app-page-boundary-render.d.ts

@@ -1,5 +1,6 @@
 import { MetadataFileRoute } from "./metadata-routes.js";
 import { AppElements } from "./app-elements-wire.js";
+import { NavigationContext } from "../shims/navigation.js";
 import { AppPageParams } from "./app-page-boundary.js";
 import { AppPageFontPreload } from "./app-page-execution.js";
 import { AppPageMiddlewareContext } from "./app-page-response.js";
@@ -32,7 +33,7 @@ type AppPageBoundaryRenderCommonOptions<TModule extends AppPageModule = AppPageM
   getFontLinks: () => string[];
   getFontPreloads: () => AppPageFontPreload[];
   getFontStyles: () => string[];
-  getNavigationContext: () => unknown;
+  getNavigationContext: () => NavigationContext | null;
   globalErrorModule?: TModule | null;
   isEdgeRuntime?: boolean;
   isRscRequest: boolean;
@@ -51,6 +52,7 @@ type AppPageBoundaryRenderCommonOptions<TModule extends AppPageModule = AppPageM
 };
 type RenderAppPageHttpAccessFallbackOptions<TModule extends AppPageModule = AppPageModule> = {
   boundaryComponent?: AppPageComponent | null;
+  boundaryModule?: TModule | null;
   layoutModules?: readonly (TModule | null | undefined)[] | null;
   matchedParams: AppPageParams;
   rootForbiddenModule?: TModule | null;
@@ -76,5 +78,4 @@ type RenderAppPageErrorBoundaryOptions<TModule extends AppPageModule = AppPageMo
 declare function renderAppPageHttpAccessFallback<TModule extends AppPageModule>(options: RenderAppPageHttpAccessFallbackOptions<TModule>): Promise<Response | null>;
 declare function renderAppPageErrorBoundary<TModule extends AppPageModule>(options: RenderAppPageErrorBoundaryOptions<TModule>): Promise<Response | null>;
 //#endregion
-export { AppPageBoundaryRoute, renderAppPageErrorBoundary, renderAppPageHttpAccessFallback };
-//# sourceMappingURL=app-page-boundary-render.d.ts.map
+export { AppPageBoundaryRoute, renderAppPageErrorBoundary, renderAppPageHttpAccessFallback };

package/dist/server/app-page-boundary-render.js

@@ -3,10 +3,10 @@ import "./app-elements.js";
 import { ErrorBoundary } from "../shims/error-boundary.js";
 import { LayoutSegmentProvider } from "../shims/layout-segment-context.js";
 import { MetadataHead, ViewportHead } from "../shims/metadata.js";
+import { resolveAppPageHead } from "./app-page-head.js";
 import { createAppPageLayoutEntries } from "./app-page-route-wiring.js";
 import { buildClientHookErrorMessage } from "../shims/client-hook-error.js";
-import { resolveAppPageHead } from "./app-page-head.js";
-import { renderAppPageBoundaryResponse, resolveAppPageErrorBoundary, resolveAppPageHttpAccessBoundaryComponent, wrapAppPageBoundaryElement } from "./app-page-boundary.js";
+import { renderAppPageBoundaryResponse, resolveAppPageErrorBoundary, resolveAppPageHttpAccessBoundaryModule, wrapAppPageBoundaryElement } from "./app-page-boundary.js";
 import { createAppPageFontData, renderAppPageHtmlResponse } from "./app-page-stream.js";
 import { Fragment, createElement } from "react";
 //#region src/server/app-page-boundary-render.ts
@@ -80,7 +80,8 @@ function createAppPageBoundaryRscPayload(options) {
 	};
 }
 async function renderAppPageBoundaryElementResponse(options) {
-	const pathname = new URL(options.requestUrl).pathname;
+	const requestUrl = new URL(options.requestUrl);
+	const pathname = requestUrl.pathname;
 	return renderAppPageBoundaryResponse({
 		async createHtmlResponse(rscStream, responseStatus) {
 			const fontData = createAppPageFontData({
@@ -95,11 +96,16 @@ async function renderAppPageBoundaryElementResponse(options) {
 				fontLinkHeader: options.buildFontLinkHeader(fontData.preloads),
 				isEdgeRuntime: options.isEdgeRuntime,
 				middlewareHeaders: options.middlewareContext.headers,
-				navigationContext: options.getNavigationContext(),
+				navigationContext: options.getNavigationContext() ?? {
+					pathname,
+					searchParams: requestUrl.searchParams,
+					params: options.navigationParams ?? options.route?.params ?? {}
+				},
 				rscStream,
 				scriptNonce: options.scriptNonce,
 				ssrHandler,
-				status: responseStatus
+				status: responseStatus,
+				initialDevServerError: options.initialDevServerError
 			});
 		},
 		createRscOnErrorHandler() {
@@ -119,8 +125,7 @@ async function renderAppPageBoundaryElementResponse(options) {
 	});
 }
 async function renderAppPageHttpAccessFallback(options) {
-	const boundaryComponent = options.boundaryComponent ?? resolveAppPageHttpAccessBoundaryComponent({
-		getDefaultExport,
+	const resolvedBoundaryModule = resolveAppPageHttpAccessBoundaryModule({
 		rootForbiddenModule: options.rootForbiddenModule,
 		rootNotFoundModule: options.rootNotFoundModule,
 		rootUnauthorizedModule: options.rootUnauthorizedModule,
@@ -129,6 +134,8 @@ async function renderAppPageHttpAccessFallback(options) {
 		routeUnauthorizedModule: options.route?.unauthorized,
 		statusCode: options.statusCode
 	});
+	const boundaryModule = options.boundaryModule ?? resolvedBoundaryModule;
+	const boundaryComponent = options.boundaryComponent ?? getDefaultExport(boundaryModule);
 	if (!boundaryComponent) return null;
 	const layoutModules = options.layoutModules ?? options.route?.layouts ?? options.rootLayouts;
 	const pathname = new URL(options.requestUrl).pathname;
@@ -138,6 +145,7 @@ async function renderAppPageHttpAccessFallback(options) {
 		layoutModules,
 		layoutTreePositions: resolveHttpAccessFallbackHeadLayoutTreePositions(options.route, layoutModules),
 		metadataRoutes: options.metadataRoutes,
+		pageModule: boundaryModule,
 		params: options.matchedParams,
 		routePath: options.route?.pattern ?? pathname,
 		routeSegments
@@ -146,9 +154,9 @@ async function renderAppPageHttpAccessFallback(options) {
 		charSet: "utf-8",
 		key: "charset"
 	}), createElement("meta", {
-		content: "noindex",
 		key: "robots",
-		name: "robots"
+		name: "robots",
+		content: "noindex"
 	})];
 	if (metadata) headElements.push(createElement(MetadataHead, {
 		key: "metadata",
@@ -177,6 +185,7 @@ async function renderAppPageHttpAccessFallback(options) {
 		...options,
 		element,
 		layoutModules: skipLayoutWrapping ? [] : layoutModules,
+		navigationParams: options.matchedParams,
 		route: skipLayoutWrapping ? null : options.route,
 		routePattern: options.route?.pattern,
 		status: options.statusCode
@@ -240,7 +249,9 @@ async function renderAppPageErrorBoundary(options) {
 	return renderAppPageBoundaryElementResponse({
 		...options,
 		element,
+		initialDevServerError: rawError,
 		layoutModules,
+		navigationParams: matchedParams,
 		route: options.route,
 		routePattern: options.route?.pattern,
 		status: 200
@@ -253,5 +264,3 @@ function rewriteClientHookError(error) {
 }
 //#endregion
 export { renderAppPageErrorBoundary, renderAppPageHttpAccessFallback };
-
-//# sourceMappingURL=app-page-boundary-render.js.map

package/dist/server/app-page-boundary.d.ts

@@ -10,6 +10,15 @@ type ResolveAppPageHttpAccessBoundaryComponentOptions<TModule, TComponent> = {
   routeUnauthorizedModule?: TModule | null;
   statusCode: number;
 };
+type ResolveAppPageHttpAccessBoundaryModuleOptions<TModule> = {
+  rootForbiddenModule?: TModule | null;
+  rootNotFoundModule?: TModule | null;
+  rootUnauthorizedModule?: TModule | null;
+  routeForbiddenModule?: TModule | null;
+  routeNotFoundModule?: TModule | null;
+  routeUnauthorizedModule?: TModule | null;
+  statusCode: number;
+};
 type ResolveAppPageParentHttpAccessBoundaryModuleOptions<TModule> = {
   layoutIndex: number;
   rootForbiddenModule?: TModule | null;
@@ -64,6 +73,7 @@ type RenderAppPageBoundaryResponseOptions<TElement> = {
   status: number;
 };
 declare function resolveAppPageHttpAccessBoundaryComponent<TModule, TComponent>(options: ResolveAppPageHttpAccessBoundaryComponentOptions<TModule, TComponent>): TComponent | null;
+declare function resolveAppPageHttpAccessBoundaryModule<TModule>(options: ResolveAppPageHttpAccessBoundaryModuleOptions<TModule>): TModule | null;
 declare function resolveAppPageParentHttpAccessBoundaryModule<TModule>(options: ResolveAppPageParentHttpAccessBoundaryModuleOptions<TModule>): TModule | null;
 /**
  * Like {@link resolveAppPageParentHttpAccessBoundaryModule}, but also returns
@@ -89,5 +99,4 @@ declare function resolveAppPageErrorBoundary<TModule, TComponent>(options: Resol
 declare function wrapAppPageBoundaryElement<TElement, TLayoutModule, TLayoutComponent, TChildSegments, TGlobalErrorComponent>(options: WrapAppPageBoundaryElementOptions<TElement, TLayoutModule, TLayoutComponent, TChildSegments, TGlobalErrorComponent>): TElement;
 declare function renderAppPageBoundaryResponse<TElement>(options: RenderAppPageBoundaryResponseOptions<TElement>): Promise<Response>;
 //#endregion
-export { AppPageParams, renderAppPageBoundaryResponse, resolveAppPageErrorBoundary, resolveAppPageHttpAccessBoundaryComponent, resolveAppPageParentHttpAccessBoundary, resolveAppPageParentHttpAccessBoundaryModule, wrapAppPageBoundaryElement };
-//# sourceMappingURL=app-page-boundary.d.ts.map
+export { AppPageParams, renderAppPageBoundaryResponse, resolveAppPageErrorBoundary, resolveAppPageHttpAccessBoundaryComponent, resolveAppPageHttpAccessBoundaryModule, resolveAppPageParentHttpAccessBoundary, resolveAppPageParentHttpAccessBoundaryModule, wrapAppPageBoundaryElement };

package/dist/server/app-page-boundary.js

@@ -5,11 +5,22 @@ import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 //#region src/server/app-page-boundary.ts
 function resolveAppPageHttpAccessBoundaryComponent(options) {
+	return options.getDefaultExport(resolveAppPageHttpAccessBoundaryModule({
+		rootForbiddenModule: options.rootForbiddenModule,
+		rootNotFoundModule: options.rootNotFoundModule,
+		rootUnauthorizedModule: options.rootUnauthorizedModule,
+		routeForbiddenModule: options.routeForbiddenModule,
+		routeNotFoundModule: options.routeNotFoundModule,
+		routeUnauthorizedModule: options.routeUnauthorizedModule,
+		statusCode: options.statusCode
+	})) ?? null;
+}
+function resolveAppPageHttpAccessBoundaryModule(options) {
 	let boundaryModule;
 	if (options.statusCode === 403) boundaryModule = options.routeForbiddenModule ?? options.rootForbiddenModule;
 	else if (options.statusCode === 401) boundaryModule = options.routeUnauthorizedModule ?? options.rootUnauthorizedModule;
 	else boundaryModule = options.routeNotFoundModule ?? options.rootNotFoundModule;
-	return options.getDefaultExport(boundaryModule) ?? null;
+	return boundaryModule ?? null;
 }
 function resolveAppPageParentHttpAccessBoundaryModule(options) {
 	return resolveAppPageParentHttpAccessBoundary(options).module;
@@ -106,6 +117,4 @@ async function renderAppPageBoundaryResponse(options) {
 	return options.createHtmlResponse(rscStream, options.status);
 }
 //#endregion
-export { renderAppPageBoundaryResponse, resolveAppPageErrorBoundary, resolveAppPageHttpAccessBoundaryComponent, resolveAppPageParentHttpAccessBoundary, resolveAppPageParentHttpAccessBoundaryModule, wrapAppPageBoundaryElement };
-
-//# sourceMappingURL=app-page-boundary.js.map
+export { renderAppPageBoundaryResponse, resolveAppPageErrorBoundary, resolveAppPageHttpAccessBoundaryComponent, resolveAppPageHttpAccessBoundaryModule, resolveAppPageParentHttpAccessBoundary, resolveAppPageParentHttpAccessBoundaryModule, wrapAppPageBoundaryElement };

package/dist/server/app-page-cache.d.ts

@@ -22,7 +22,7 @@ type AppPageCacheOutcomeMetric = Readonly<{
    */
   cacheKey: string;
   outcome: "hit" | "miss" | "stale";
-  reason: "empty-entry" | "no-entry" | "non-app-page-entry" | "read-error" | "served" | "stale-empty-entry";
+  reason: "empty-entry" | "no-entry" | "non-app-page-entry" | "query-variant-unproven" | "read-error" | "served" | "stale-empty-entry";
 }>;
 type AppPageCacheOutcomeRecorder = (metric: AppPageCacheOutcomeMetric) => void;
 type BuildAppPageCacheRenderObservation = (input: {
@@ -59,6 +59,7 @@ type ReadAppPageCacheResponseOptions = {
   isrRscKey: AppPageRscCacheKeyBuilder;
   isrSet: AppPageCacheSetter;
   interceptionContext?: string | null;
+  hasRequestSearchParams?: boolean;
   middlewareHeaders?: Headers | null;
   middlewareStatus?: number | null;
   mountedSlotsHeader?: string | null;
@@ -116,5 +117,4 @@ declare function finalizeAppPageHtmlCacheResponse(response: Response, options: F
 declare function finalizeAppPageRscCacheResponse(response: Response, options: ScheduleAppPageRscCacheWriteOptions): Response;
 declare function scheduleAppPageRscCacheWrite(options: ScheduleAppPageRscCacheWriteOptions): boolean;
 //#endregion
-export { AppPageCacheOutcomeMetric, buildAppPageCacheTags, buildAppPageCachedResponse, finalizeAppPageHtmlCacheResponse, finalizeAppPageRscCacheResponse, readAppPageCacheResponse, scheduleAppPageRscCacheWrite };
-//# sourceMappingURL=app-page-cache.d.ts.map
+export { AppPageCacheOutcomeMetric, buildAppPageCacheTags, buildAppPageCachedResponse, finalizeAppPageHtmlCacheResponse, finalizeAppPageRscCacheResponse, readAppPageCacheResponse, scheduleAppPageRscCacheWrite };

package/dist/server/app-page-cache.js

@@ -4,12 +4,30 @@ import { encodeCacheTag } from "../utils/encode-cache-tag.js";
 import { buildAppPageCacheValue } from "./isr-cache.js";
 import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
 import { readStreamAsText } from "../utils/text-stream.js";
-import { buildCachedRevalidateCacheControl } from "./cache-control.js";
+import { applyCdnResponseHeaders, buildCachedRevalidateCacheControl } from "./cache-control.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
+import { hasCompleteNegativeRequestApiProof } from "./cache-proof.js";
 import { createEmptyAppPageRenderObservationState } from "./app-page-render-observation.js";
 //#region src/server/app-page-cache.ts
-const NO_STORE_CACHE_CONTROL = "no-store, must-revalidate";
+/**
+* Apply the CDN cache adapter's headers to a freshly-streamed response whose
+* dynamic-ness is not yet proven.
+*
+* The cacheable `Cache-Control` value computed by the response policy is already
+* present on `headers`; the default adapter replaces it with `no-store` (so the
+* page is served from the origin store on later requests), while an edge adapter
+* may instead emit `CDN-Cache-Control`/`Cache-Tag` so the CDN performs SWR and
+* can be purged by tag. `tags` are the page's render tags (canonicalised).
+*/
+function applyPendingDynamicCdnHeaders(headers, tags) {
+	applyCdnResponseHeaders(headers, {
+		cacheControl: headers.get("Cache-Control") ?? "",
+		pendingDynamicCheck: true,
+		tags
+	});
+	setCacheStateHeaders(headers, "MISS");
+}
 function recordAppPageCacheOutcome(recordCacheOutcome, input) {
 	try {
 		recordCacheOutcome?.(input);
@@ -39,10 +57,10 @@ function buildAppPageCacheControl(cacheState, revalidateSeconds, expireSeconds)
 }
 function buildAppPageCachedHeaders(options) {
 	const headers = new Headers({
-		"Cache-Control": options.cacheControl,
 		"Content-Type": options.contentType,
 		Vary: VINEXT_RSC_VARY_HEADER
 	});
+	applyCdnResponseHeaders(headers, { cacheControl: options.cacheControl });
 	setCacheStateHeaders(headers, options.cacheState);
 	applyEdgeRuntimeHeader(headers, options.isEdgeRuntime);
 	if (options.mountedSlotsHeader) headers.set(VINEXT_MOUNTED_SLOTS_HEADER, options.mountedSlotsHeader);
@@ -52,6 +70,9 @@ function buildAppPageCachedHeaders(options) {
 function getCachedAppPageValue(entry) {
 	return entry?.value.value && entry.value.value.kind === "APP_PAGE" ? entry.value.value : null;
 }
+function hasQueryInvariantAppPageProof(cachedValue) {
+	return cachedValue.renderObservation !== void 0 && hasCompleteNegativeRequestApiProof(cachedValue.renderObservation, ["searchParams"]);
+}
 function resolveAppPageCacheWritePolicy(options) {
 	let revalidateSeconds = options.revalidateSeconds;
 	let expireSeconds = options.expireSeconds;
@@ -114,6 +135,16 @@ async function readAppPageCacheResponse(options) {
 			options.isrDebug?.("MISS (non app-page cache entry)", options.cleanPathname);
 			return null;
 		}
+		if (cachedValue && options.hasRequestSearchParams === true && !hasQueryInvariantAppPageProof(cachedValue)) {
+			recordAppPageCacheOutcome(options.recordCacheOutcome, {
+				artifact,
+				cacheKey: isrKey,
+				outcome: "miss",
+				reason: "query-variant-unproven"
+			});
+			options.isrDebug?.("MISS (query-bearing request lacks cache proof)", options.cleanPathname);
+			return null;
+		}
 		if (cachedValue && !cached?.isStale) {
 			const hitResponse = buildAppPageCachedResponse(cachedValue, {
 				cacheState: "HIT",
@@ -212,10 +243,7 @@ function finalizeAppPageHtmlCacheResponse(response, options) {
 	const htmlKey = options.isrHtmlKey(options.cleanPathname);
 	const rscKey = options.isrRscKey(options.cleanPathname, null, void 0, options.interceptionContext);
 	const clientHeaders = new Headers(response.headers);
-	if (options.preserveClientResponseHeaders !== true) {
-		clientHeaders.set("Cache-Control", NO_STORE_CACHE_CONTROL);
-		setCacheStateHeaders(clientHeaders, "MISS");
-	}
+	if (options.preserveClientResponseHeaders !== true) applyPendingDynamicCdnHeaders(clientHeaders, options.getPageTags());
 	const cachePromise = (async () => {
 		try {
 			const cachedHtml = await readStreamAsText(streamForCache);
@@ -261,8 +289,7 @@ function finalizeAppPageRscCacheResponse(response, options) {
 	if (!scheduleAppPageRscCacheWrite(options)) return response;
 	if (options.preserveClientResponseHeaders === true) return response;
 	const clientHeaders = new Headers(response.headers);
-	clientHeaders.set("Cache-Control", NO_STORE_CACHE_CONTROL);
-	setCacheStateHeaders(clientHeaders, "MISS");
+	applyPendingDynamicCdnHeaders(clientHeaders, options.getPageTags());
 	return new Response(response.body, {
 		status: response.status,
 		statusText: response.statusText,
@@ -306,5 +333,3 @@ function scheduleAppPageRscCacheWrite(options) {
 }
 //#endregion
 export { buildAppPageCacheTags, buildAppPageCachedResponse, finalizeAppPageHtmlCacheResponse, finalizeAppPageRscCacheResponse, readAppPageCacheResponse, scheduleAppPageRscCacheWrite };
-
-//# sourceMappingURL=app-page-cache.js.map