vinext 1.0.0 → 1.0.1

package/dist/server/pages-request-pipeline.js

@@ -2,9 +2,11 @@ import { PRERENDER_REVALIDATE_HEADER } from "../utils/protocol-headers.js";
 import { requestContextFromRequest } from "../config/request-context.js";
 import { isExternalUrl } from "../utils/external-url.js";
 import { applyMiddlewareRequestHeaders, matchRedirect, matchRewrite, preserveRedirectDestinationQuery, proxyExternalRequest, sanitizeDestination } from "../config/config-matchers.js";
+import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
 import { addBasePathToPathname, hasBasePath } from "../utils/base-path.js";
 import { patternToNextFormat } from "../routing/route-validation.js";
-import { methodNotAllowedResponse, sanitizeMethodNotAllowedHeaders } from "./http-error-responses.js";
+import { VINEXT_PRERENDER_REWRITTEN_HEADER } from "./headers.js";
+import { methodNotAllowedResponse, notFoundStaticAssetResponse, sanitizeMethodNotAllowedHeaders } from "./http-error-responses.js";
 import { cloneRequestWithUrl, normalizeTrailingSlash } from "./request-pipeline.js";
 import { normalizeDefaultLocalePathname, stripI18nLocaleForApiRoute } from "./pages-i18n.js";
 import { markRouteCacheabilityDynamic } from "../shims/cacheability-classification.js";
@@ -13,7 +15,7 @@ import { mergeRewriteQuery } from "../utils/query.js";
 import { buildMiddlewarePrefetchSkipResponse } from "./pages-data-route.js";
 import { setFrameworkRequestRoute } from "./request-tracing.js";
 import { applyConfigHeadersToHeaderRecord } from "./config-headers.js";
-import { mergeHeaders } from "./worker-utils.js";
+import { finalizeMissingStaticAssetResponse, mergeHeaders } from "./worker-utils.js";
 //#region src/server/pages-request-pipeline.ts
 function ruleUsesUnkeyedRequestCondition(rule) {
 	return [...rule.has ?? [], ...rule.missing ?? []].some((condition) => condition.type === "header" || condition.type === "cookie" || condition.type === "host");
@@ -30,12 +32,19 @@ function headersFromRecord(record) {
 	else headers.set(name, value);
 	return headers;
 }
-async function fetchWorkerFilesystemRoute(request, requestPathname, phase, fetchAsset, publicFiles, isDirectBuildAsset = false) {
+async function fetchWorkerFilesystemRoute(request, requestPathname, phase, fetchAsset, publicFiles, basePath = "", assetPathPrefix = "") {
 	const isRetrievalMethod = request.method === "GET" || request.method === "HEAD";
-	if (phase === "direct" && isRetrievalMethod || phase === "direct" && publicFiles !== void 0 && !isDirectBuildAsset && !publicFiles.has(requestPathname) || requestPathname === "/api" || requestPathname.startsWith("/api/")) return false;
+	if (phase === "direct" && isRetrievalMethod || requestPathname === "/api" || requestPathname.startsWith("/api/")) return false;
 	const assetUrl = new URL(request.url);
 	assetUrl.pathname = requestPathname;
 	assetUrl.search = "";
+	const decodedAssetUrl = new URL(assetUrl);
+	try {
+		decodedAssetUrl.pathname = decodeURIComponent(assetUrl.pathname);
+	} catch {
+		return false;
+	}
+	if (!publicFiles.has(assetUrl.pathname) && !publicFiles.has(decodedAssetUrl.pathname) && !isNextStaticPath(decodedAssetUrl.pathname, basePath, assetPathPrefix)) return false;
 	const response = await fetchAsset(isRetrievalMethod ? new Request(assetUrl, request) : new Request(assetUrl, {
 		method: "HEAD",
 		headers: request.headers
@@ -254,10 +263,11 @@ async function runPagesRequest(request, deps) {
 	}
 	const initialFilesystemResult = await serveFilesystemRoute(resolvedPathname, resolvedPathnameIsRequestPathname ? "direct" : "beforeFiles");
 	if (initialFilesystemResult) return initialFilesystemResult;
+	const isMissingBuildAsset = () => isNextStaticPath(resolvedPathname, "", assetPrefixPathname(deps.assetPrefix ?? ""));
 	const isOutsideBasePathUnclaimed = () => basePath && !hadBasePath && !configRewriteFired;
 	const outOfBasePathNotFound = () => ({
 		type: "response",
-		response: new Response("This page could not be found", {
+		response: isMissingBuildAsset() ? notFoundStaticAssetResponse(headersFromRecord(middlewareHeaders)) : new Response("This page could not be found", {
 			status: 404,
 			headers: { "Content-Type": "text/html; charset=utf-8" }
 		})
@@ -375,6 +385,10 @@ async function runPagesRequest(request, deps) {
 			matchedFallbackRewrite = true;
 			if (response.status !== 404) break;
 		}
+		if (!renderPageMatch && response.status === 404 && isMissingBuildAsset()) return {
+			type: "response",
+			response: finalizeMissingStaticAssetResponse(mergeHeaders(response, middlewareHeaders, middlewareStatus), true)
+		};
 		if (response.status === 404 && shouldDeferErrorPageOnMiss && !matchedFallbackRewrite) response = await deps.renderPage(request, resolvedUrl, void 0, stagedHeaders);
 		const matchedPathHeaders = { ...middlewareHeaders };
 		if ((isDataReq || isDataRequest) && deps.hasMiddleware && !renderPageMatch && response.status === 404 && (middlewareStatus === void 0 || middlewareStatus === 200 || middlewareStatus === 404)) {
@@ -392,6 +406,7 @@ async function runPagesRequest(request, deps) {
 			};
 		}
 		if ((isDataReq || isDataRequest) && renderPageMatch && (middlewareStatus ?? response.status) === 200) matchedPathHeaders["x-nextjs-matched-path"] = matchedPathnameForRoute(renderPageMatch?.route.pattern);
+		if (typeof process !== "undefined" && process.env?.VINEXT_PRERENDER === "1") matchedPathHeaders[VINEXT_PRERENDER_REWRITTEN_HEADER] = resolvedUrl === originalResolvedUrl ? "0" : "1";
 		const merged = mergeHeaders(response, matchedPathHeaders, middlewareStatus);
 		if (merged !== response) merged.__vinextStreamedHtmlResponse = response.__vinextStreamedHtmlResponse;
 		return {

package/dist/server/pages-request-stage-entry.js

@@ -9,13 +9,13 @@ import { notFoundStaticAssetResponse } from "./http-error-responses.js";
 import { isOpenRedirectShaped } from "./open-redirect.js";
 import { attachRequestCfMetadata, cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders } from "./request-pipeline.js";
 import { normalizeDefaultLocalePathname } from "./pages-i18n.js";
+import { getExplicitCdnCacheAdapter } from "../shims/cdn-cache-state.js";
 import { CACHEABILITY_REQUEST_STATE } from "../shims/cacheability-classification.js";
 import { applyCdnResponseIdentityHeaders, captureCdnResponsePolicyOverrides, reconcileCdnResponseHeadersAfterOuterPolicy, validateCdnRequest } from "./cache-control.js";
 import { registerLazyDataCacheHandler } from "../shims/cache-handler.js";
 import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, handleConfiguredImageOptimization, isImageOptimizationPath } from "./image-optimization.js";
 import { traceFrameworkRequest } from "./request-tracing.js";
 import { resolveResponseStageCachePolicy } from "./config-headers.js";
-import { finalizeMissingStaticAssetResponse } from "./worker-utils.js";
 import { fetchWorkerFilesystemRoute, runPagesRequest, wrapMiddlewareWithBasePath } from "./pages-request-pipeline.js";
 import { createWorkerRevalidationContext } from "./worker-revalidation-context.js";
 import { createWorkerPrerenderDiscoveryContext, createWorkerPrerenderReadinessResponse, isWorkerPrerenderDiscoveryPath } from "./worker-prerender-discovery.js";
@@ -69,7 +69,7 @@ function handleRequestStage(request, env, ctx, dispatchResponseStage) {
 /** Preserve the direct single-entry Worker path without retaining it in request-only builds. */
 function handleRequestStageLocally(request, env, ctx, dispatchResponseStage) {
 	const originalRequest = request;
-	return handleRequest(request, env, ctx, (stageRequest, props, _options, stageEnv, stageCtx) => dispatchResponseStage(stageRequest, stageEnv, stageCtx, props), true, "worker", env?.ASSETS).then((response) => applyCdnResponseIdentityHeaders(response, originalRequest));
+	return handleRequest(request, env, ctx, (stageRequest, props, _options, stageEnv, stageCtx) => dispatchResponseStage(stageRequest, stageEnv, stageCtx, props), true, "worker", ctx?.assets).then((response) => applyCdnResponseIdentityHeaders(response, originalRequest));
 }
 function handleRequest(request, env, platformCtx, dispatchResponseStage, forceCacheBypass, defaultHostRuntime, assets) {
 	const url = new URL(request.url);
@@ -90,6 +90,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 	let sharedOuterPolicyHeaders = null;
 	let ctx = createWorkerRevalidationContext(platformCtx, (internalRequest, internalCtx) => handleRequest(internalRequest, env, internalCtx, dispatchResponseStage, forceCacheBypass, defaultHostRuntime, assets), defaultHostRuntime);
 	configuredCdnCacheAdapters.registerConfiguredCacheAdapters(env);
+	assets ??= getExplicitCdnCacheAdapter()?.assets ?? (defaultHostRuntime === "worker" ? env?.ASSETS : void 0);
 	if (configuredCdnCacheAdapters.hasConfiguredDataCache) registerLazyDataCacheHandler(async () => {
 		(await import("virtual:vinext-cache-adapters")).registerConfiguredCacheAdapters(env);
 	});
@@ -184,6 +185,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 		});
 		let speculativeRenderRequest = null;
 		const deps = {
+			assetPrefix: vinextConfig?.assetPrefix,
 			basePath,
 			trailingSlash,
 			i18nConfig,
@@ -287,12 +289,12 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 					const allowedWidths = [...vinextConfig?.images?.deviceSizes ?? DEFAULT_DEVICE_SIZES, ...vinextConfig?.images?.imageSizes ?? DEFAULT_IMAGE_SIZES];
 					return handleConfiguredImageOptimization(imageRequest, (assetPath) => Promise.resolve(assets.fetch(new Request(new URL(assetPath, request.url)))), allowedWidths, imageConfig);
 				}
-				return fetchWorkerFilesystemRoute(request, requestPathname, phase, (assetRequest) => Promise.resolve(assets.fetch(assetRequest)), publicFiles, missingBuildAsset);
+				return fetchWorkerFilesystemRoute(request, requestPathname, phase, (assetRequest) => Promise.resolve(assets.fetch(assetRequest)), publicFiles, basePath, assetPathPrefix);
 			}
 		};
 		const result = await runPagesRequest(request, deps);
 		if (result.type === "response") {
-			let response = finalizeMissingStaticAssetResponse(result.response, missingBuildAsset);
+			let response = result.response;
 			if (sharedResponseHeaders && sharedOuterPolicyHeaders) reconcileCdnResponseHeadersAfterOuterPolicy(response.headers, sharedOuterPolicyHeaders);
 			if (probeMode && probeRoute && !responseStageDispatched) {
 				const { finalizeRequestStageCacheabilityProbe } = await import("./cacheability-request.js");

package/dist/server/prerender-manifest.d.ts

@@ -16,6 +16,12 @@ export type PrerenderManifestRoute = {
   fallback?: boolean;
   headers?: Record<string, string | string[]>;
   responseStatus?: number;
+  /** Pages source returned notFound, rather than rendering a custom 404 document. */
+  notFound?: true;
+  /** Original Pages redirect props, including client navigation semantics. */
+  redirectProps?: object;
+  /** Pages locale rendered for this public pathname. */
+  locale?: string;
   routeSegments?: string[];
   tags?: string[];
 };

package/dist/server/prerender-manifest.js

@@ -74,7 +74,7 @@ function getPrerenderedConcretePaths(manifest, options) {
 	const paths = [];
 	const seen = /* @__PURE__ */ new Set();
 	for (const route of routes) {
-		if (route.status !== "rendered") continue;
+		if (route.status !== "rendered" || route.notFound) continue;
 		const pathname = route.path ?? route.route;
 		if (!options?.includeFallbackShells && isFallbackShellArtifactPath(pathname, route)) continue;
 		if (!options?.includeErrorDocuments && isErrorDocumentRoute(pathname, route)) continue;

package/dist/server/prod-server.js

@@ -21,7 +21,7 @@ import { installSocketErrorBackstop } from "./socket-error-backstop.js";
 import { collectInlineCssManifest } from "../build/inline-css.js";
 import { readTrustedRevalidationHostname } from "./revalidation-host.js";
 import { traceFrameworkRequest } from "./request-tracing.js";
-import { finalizeMissingStaticAssetResponse, mergeHeaders } from "./worker-utils.js";
+import { mergeHeaders } from "./worker-utils.js";
 import { runPagesRequest, wrapMiddlewareWithBasePath } from "./pages-request-pipeline.js";
 import { computeClientRuntimeMetadata } from "../utils/client-runtime-metadata.js";
 import { readPrerenderSecret } from "../build/server-manifest.js";
@@ -1070,12 +1070,10 @@ async function startAppRouterServer(options) {
 				return;
 			}
 		}
-		let missingBuildAsset = false;
 		{
 			const assetLookupPath = resolveAppRouterAssetPath(pathname, appAssetPathPrefix, appRouterAssetPrefix);
 			if (assetLookupPath) {
 				if (await tryServeStatic(req, res, clientDir, assetLookupPath, compress, staticCache)) return;
-				missingBuildAsset = true;
 			}
 		}
 		if (isImageOptimizationPath(pathname)) {
@@ -1105,10 +1103,6 @@ async function startAppRouterServer(options) {
 		try {
 			const request = nodeToWebRequest(req, rawUrl, prerenderSecret, appRouterI18nConfig, appRouterAuthorizeOnDemandRevalidate);
 			const response = await rscHandler(request, createNodeExecutionContext(resolveTrustedNodeRevalidateOrigin(req, host, port)));
-			if (missingBuildAsset && response.status === 404) {
-				await sendWebResponse(finalizeMissingStaticAssetResponse(response, true), req, res, compress);
-				return;
-			}
 			const staticFileSignal = readStaticFileSignal(response);
 			if (staticFileSignal) {
 				let staticFilePath = "/";
@@ -1316,7 +1310,6 @@ async function startPagesRouterServer(options) {
 			return;
 		}
 		const pagesAssetLookup = resolveAppRouterAssetPath(pathname, pagesAssetPathPrefix, assetPrefix);
-		const missingBuildAsset = pagesAssetLookup !== null;
 		if (pagesAssetLookup) {
 			if (await tryServeStatic(req, res, clientDir, pagesAssetLookup, compress, staticCache)) return;
 		}
@@ -1382,6 +1375,7 @@ async function startPagesRouterServer(options) {
 			});
 			const middlewareRequest = isDataReq && skipProxyUrlNormalize ? new Request(new URL(originalRenderUrl, webRequest.url), webRequest) : void 0;
 			const deps = {
+				assetPrefix,
 				basePath,
 				trailingSlash,
 				i18nConfig,
@@ -1404,7 +1398,7 @@ async function startPagesRouterServer(options) {
 				renderPage: typeof renderPage === "function" ? (request, resolvedUrl, options, stagedHeaders) => renderPage(request, resolvedUrl, ssrManifest, void 0, stagedHeaders, {
 					...options,
 					originalUrl: originalRenderUrl
-				}) : null,
+				}, stagedHeaders?.has("Cache-Control") ? new Headers({ "Cache-Control": stagedHeaders.get("Cache-Control") }) : void 0) : null,
 				handleApi: typeof handleApi === "function" ? (request, apiUrl) => handleApi(request, apiUrl, createNodeExecutionContext(), resolveTrustedNodeRevalidateOrigin(req, host, port), "node") : null,
 				serveFilesystemRoute: async (requestPathname, stagedHeaders, phase, resolvedUrl) => {
 					if (isImageOptimizationPath(requestPathname)) {
@@ -1440,10 +1434,6 @@ async function startPagesRouterServer(options) {
 			if (result.type === "handled") return;
 			if (result.type === "response") {
 				const { response } = result;
-				if (missingBuildAsset && response.status === 404) {
-					await sendWebResponse(finalizeMissingStaticAssetResponse(response, true), req, res, compress);
-					return;
-				}
 				const streamedApi = isVinextStreamedApiResponse(response);
 				if (isVinextStreamedHtmlResponse(response) || streamedApi || !response.body || result.defaultContentType === void 0) {
 					if (streamedApi && result.defaultContentType !== void 0 && !response.headers.has("content-type")) response.headers.set("content-type", result.defaultContentType);

package/dist/server/response-stage-cacheability.js

@@ -34,7 +34,7 @@ async function withResponseStageCacheability(options, render) {
 	const response = options.policyHeadersAppliedBeforeRender ? rendered : cacheability.applyResponseStageCachePolicy(rendered, context, options.policyHeaders);
 	const complete = (candidate) => cacheability.finalizeWorkerCacheabilityResponse(candidate, context);
 	const route = state?.route;
-	if (!options.probeMode && state?.admission?.policy !== "manifest" && (route?.kind === "app-page" || route?.kind === "pages-page")) {
+	if (!options.probeMode && state?.admission?.policy !== "manifest" && (route?.kind === "app-page" || route?.kind === "pages-page") && !(route.kind === "pages-page" && state?.outcome?.cacheable === false)) {
 		const deferred = adapter.deferCompletedPageResponseAdmission?.(response, complete);
 		if (deferred) return deferred;
 	}

package/dist/server/worker-revalidation-context.d.ts

@@ -1,6 +1,7 @@
+import { VinextRequestStageContext } from "./multi-stage.js";
 import { ExecutionContextLike } from "../shims/request-context.js";
 //#region src/server/worker-revalidation-context.d.ts
-type PlatformExecutionContext = Partial<ExecutionContextLike>;
+type PlatformExecutionContext = Partial<ExecutionContextLike> & VinextRequestStageContext;
 /**
  * Add a request-local, in-process Pages revalidation dispatcher to a Worker
  * execution context. Re-entering with the derived internal context preserves

package/dist/server/worker-revalidation-context.js

@@ -10,6 +10,7 @@ function deriveExecutionContext(base, dispatchPagesRevalidate, isInternalPagesRe
 		} } : {},
 		hostRuntime: base?.hostRuntime ?? defaultHostRuntime,
 		...base?.cache === void 0 ? {} : { cache: base.cache },
+		...base?.assets === void 0 ? {} : { assets: base.assets },
 		...base?.trustedRevalidateOrigin === void 0 ? {} : { trustedRevalidateOrigin: base.trustedRevalidateOrigin },
 		dispatchPagesRevalidate,
 		isInternalPagesRevalidation

package/dist/server/workers-tracing.d.ts

@@ -1,7 +1,18 @@
 import { FrameworkTracingIntegration } from "./framework-tracer.js";
 //#region src/server/workers-tracing.d.ts
 export type WorkersTracingException = string | {
+  code: string | number;
+  name?: string;
+  message?: string;
+  stack?: string;
+} | {
+  code?: string | number;
   name: string;
+  message?: string;
+  stack?: string;
+} | {
+  code?: string | number;
+  name?: string;
   message: string;
   stack?: string;
 };
@@ -9,9 +20,15 @@ export type WorkersTracingSpan = {
   readonly isTraced: boolean;
   recordException?(exception: WorkersTracingException): void;
   setAttribute(key: string, value: boolean | number | string): void;
+  setStatus?(status: {
+    code: "error";
+    message?: string;
+  }): void;
+  updateName?(name: string): void;
 };
 export type WorkersTracing = {
   enterSpan<T>(name: string, callback: (span: WorkersTracingSpan) => T): T;
+  getActiveSpan?(): WorkersTracingSpan | undefined;
 };
 export declare function createWorkersTracingIntegration(tracing: WorkersTracing): FrameworkTracingIntegration;
 //#endregion

package/dist/server/workers-tracing.js

@@ -1,20 +1,60 @@
 //#region src/server/workers-tracing.ts
+function readExceptionField(error, key) {
+	try {
+		return Reflect.get(error, key);
+	} catch {
+		return;
+	}
+}
 function normalizeException(error) {
 	if (typeof error === "string") return error;
-	if (error instanceof Error) return {
-		message: error.message,
-		name: error.name,
-		...error.stack ? { stack: error.stack } : {}
-	};
-	return String(error);
+	if (error && typeof error === "object") {
+		const code = readExceptionField(error, "code");
+		const name = readExceptionField(error, "name");
+		const message = readExceptionField(error, "message");
+		const stack = readExceptionField(error, "stack");
+		const details = {
+			...typeof name === "string" ? { name } : {},
+			...typeof message === "string" ? { message } : {},
+			...typeof stack === "string" ? { stack } : {}
+		};
+		if (typeof code === "string" || typeof code === "number") return {
+			...details,
+			code
+		};
+		if (typeof name === "string") return {
+			...details,
+			name
+		};
+		if (typeof message === "string") return {
+			...details,
+			message
+		};
+	}
+	try {
+		return String(error);
+	} catch {
+		return "Unknown exception";
+	}
 }
 function createWorkersTracingIntegration(tracing) {
 	const backendSpan = (span) => ({
-		recordException: (error) => span.recordException?.(normalizeException(error)),
-		setAttribute: (key, value) => span.setAttribute(key, value)
+		recordException: (error) => {
+			if (span.isTraced) span.recordException?.(normalizeException(error));
+		},
+		setAttribute: (key, value) => span.setAttribute(key, value),
+		setErrorStatus: (message) => span.setStatus?.({
+			code: "error",
+			message
+		}),
+		updateName: (name) => span.updateName?.(name)
 	});
 	return {
 		id: "cloudflare-workers",
+		getActiveSpan() {
+			const span = tracing.getActiveSpan?.();
+			return span ? backendSpan(span) : void 0;
+		},
 		enterSpan(descriptor, callback) {
 			return tracing.enterSpan(descriptor.name, (span) => {
 				for (const [key, value] of Object.entries(descriptor.attributes)) span.setAttribute(key, value);

package/dist/shims/cache-request-state.d.ts

@@ -1,3 +1,4 @@
+import { _recordUseCacheRootParamRead, _registerCacheContextAccessor, getRegisteredCacheContext } from "./internal/cache-context-accessor.js";
 //#region src/shims/cache-request-state.d.ts
 export type CacheLifeConfig = {
   stale?: number;
@@ -5,19 +6,6 @@ export type CacheLifeConfig = {
   expire?: number;
 };
 export declare const cacheLifeProfiles: Record<string, CacheLifeConfig>;
-type CacheContextLike = {
-  tags: string[];
-  lifeConfigs: CacheLifeConfig[];
-  variant: string;
-  readRootParamNames?: Set<string>;
-  hasExplicitRevalidate: boolean;
-  hasExplicitExpire: boolean;
-  dynamicNestedCacheError: Error | undefined;
-};
-export declare function _registerCacheContextAccessor(fn: () => CacheContextLike | null): void;
-export declare function getRegisteredCacheContext(): CacheContextLike | null;
-/** Record a root-param dependency on the active public `"use cache"` scope. */
-export declare function _recordUseCacheRootParamRead(name: string): void;
 export type UnstableCacheRevalidationMode = "foreground" | "background";
 export type ActionRevalidationKind = 0 | 1 | 2;
 export type UnstableCacheObservation = Readonly<{
@@ -83,4 +71,5 @@ export declare function _captureRequestScopedCacheLifeAccessors(): {
 export declare function recordUnstableCacheObservation(observation: UnstableCacheObservation): void;
 export declare function _peekUnstableCacheObservations(): UnstableCacheObservation[];
 export declare function shouldServeStaleUnstableCacheEntry(): boolean;
-//#endregion
+//#endregion
+export { _recordUseCacheRootParamRead, _registerCacheContextAccessor, getRegisteredCacheContext };

package/dist/shims/cache-request-state.js

@@ -1,6 +1,7 @@
 import { getOrCreateAls } from "./internal/als-registry.js";
 import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
-import { getHeadersAccessPhase } from "./headers.js";
+import { getHeadersAccessPhase } from "./internal/headers-state.js";
+import { _recordUseCacheRootParamRead, _registerCacheContextAccessor, getRegisteredCacheContext } from "./internal/cache-context-accessor.js";
 //#region src/shims/cache-request-state.ts
 const cacheLifeProfiles = {
 	default: {
@@ -38,18 +39,6 @@ const cacheLifeProfiles = {
 		expire: 31536e3
 	}
 };
-let getCacheContext = null;
-function _registerCacheContextAccessor(fn) {
-	getCacheContext = fn;
-}
-function getRegisteredCacheContext() {
-	return getCacheContext?.() ?? null;
-}
-/** Record a root-param dependency on the active public `"use cache"` scope. */
-function _recordUseCacheRootParamRead(name) {
-	const context = getRegisteredCacheContext();
-	if (context && context.variant !== "private") context.readRootParamNames?.add(name);
-}
 const FALLBACK_KEY = Symbol.for("vinext.cache.fallback");
 const globalState = globalThis;
 const cacheAls = getOrCreateAls("vinext.cache.als");

package/dist/shims/cache-runtime.js

@@ -6,8 +6,10 @@ import { isRouteCacheabilityProbe, recordRouteCacheabilityProbeBailout } from ".
 import { getDataCacheHandler } from "./cache-handler.js";
 import { suppressHangingPromiseAbortRejections } from "./internal/make-hanging-promise.js";
 import { createPprFallbackShellSuspensePromise, trackPprFallbackShellCacheTask } from "./ppr-fallback-shell.js";
-import { isDraftModeEnabled, markDynamicUsage, throwIfInsideCacheScope } from "./headers.js";
-import { _hasPendingRevalidatedTag, _registerCacheContextAccessor, _setRequestScopedCacheLife, cacheLifeProfiles } from "./cache-request-state.js";
+import { markDynamicUsage, throwIfInsideCacheScope } from "./internal/headers-state.js";
+import { isDraftModeEnabled } from "./headers.js";
+import { _registerCacheContextAccessor } from "./internal/cache-context-accessor.js";
+import { _hasPendingRevalidatedTag, _setRequestScopedCacheLife, cacheLifeProfiles } from "./cache-request-state.js";
 import { addCollectedRequestTags, getCurrentFetchSoftTags } from "./fetch-cache.js";
 import { makeThenableParams } from "./thenable-params.js";
 import { APP_PAGE_USE_CACHE_MARKER, hasUseCachePageMarker, isMarkedAppPagePropsObject, isUseCacheFunctionReference, markAppPagePropsForUseCache } from "./internal/app-page-props-cache-key.js";

package/dist/shims/cache.d.ts

@@ -1,5 +1,6 @@
 import { ExecutionContextLike, getRequestExecutionContext, runWithExecutionContext } from "./request-context.js";
-import { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, ActionRevalidationKind, CacheLifeConfig, CacheState, UnstableCacheObservation, UnstableCacheRevalidationMode, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, getRegisteredCacheContext, markActionRevalidation, recordUnstableCacheObservation, shouldServeStaleUnstableCacheEntry } from "./cache-request-state.js";
+import { _recordUseCacheRootParamRead, _registerCacheContextAccessor, getRegisteredCacheContext } from "./internal/cache-context-accessor.js";
+import { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, ActionRevalidationKind, CacheLifeConfig, CacheState, UnstableCacheObservation, UnstableCacheRevalidationMode, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingRevalidation, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, markActionRevalidation, recordUnstableCacheObservation, shouldServeStaleUnstableCacheEntry } from "./cache-request-state.js";
 import { CacheControlMetadata, CacheHandler, CacheHandlerContext, CacheHandlerValue, CachedAppPageValue, CachedFetchValue, CachedImageValue, CachedPagesValue, CachedRedirectValue, CachedRouteValue, IncrementalCacheValue, MemoryCacheHandler, NoOpCacheHandler, configureMemoryCacheHandler, getCacheHandler, getDataCacheHandler, registerDataCacheHandler, registerLazyDataCacheHandler, setCacheHandler, setDataCacheHandler } from "./cache-handler.js";
 //#region src/shims/cache.d.ts
 /**

package/dist/shims/cache.js

@@ -8,8 +8,10 @@ import { fnv1a64 } from "../utils/hash.js";
 import { MemoryCacheHandler, NoOpCacheHandler, configureMemoryCacheHandler, getCacheHandler, getDataCacheHandler, registerDataCacheHandler, registerLazyDataCacheHandler, setCacheHandler, setDataCacheHandler } from "./cache-handler.js";
 import { encodeCacheTag, encodeCacheTags } from "../utils/encode-cache-tag.js";
 import { makeHangingPromise } from "./internal/make-hanging-promise.js";
-import { getHeadersAccessPhase, isDraftModeEnabled, markDynamicUsage } from "./headers.js";
-import { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, getRegisteredCacheContext, markActionRevalidation, recordUnstableCacheObservation, shouldServeStaleUnstableCacheEntry } from "./cache-request-state.js";
+import { getHeadersAccessPhase, markDynamicUsage } from "./internal/headers-state.js";
+import { isDraftModeEnabled } from "./headers.js";
+import { _recordUseCacheRootParamRead, _registerCacheContextAccessor, getRegisteredCacheContext } from "./internal/cache-context-accessor.js";
+import { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingRevalidation, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, markActionRevalidation, recordUnstableCacheObservation, shouldServeStaleUnstableCacheEntry } from "./cache-request-state.js";
 import { addCollectedRequestTags, getCurrentFetchSoftTags } from "./fetch-cache.js";
 //#region src/shims/cache.ts
 /**

package/dist/shims/cacheability-classification.d.ts

@@ -86,7 +86,7 @@ export declare function markRouteCacheabilityExplicitConfigPolicy(): void;
 export declare function markRouteCacheabilityConfigCdnCachePolicy(name: string, value: string): void;
 /** Record a next.config cache policy header with the value a response carries. */
 export declare function recordConfigCdnCachePolicyHeader(state: RouteCacheabilityState, name: string, value: string): void;
-/** Record a public cache policy supplied by the Route Handler itself. */
+/** Record an explicit cache policy supplied by the Route Handler itself. */
 export declare function markRouteCacheabilityExplicitResponsePolicy(): void;
 /** Record that the response body reached clean EOF and is now a replay stream. */
 export declare function markRouteCacheabilityResponseBodyComplete(): void;

package/dist/shims/cacheability-classification.js

@@ -84,10 +84,10 @@ function recordConfigCdnCachePolicyHeader(state, name, value) {
 	const applied = new Headers([[name, value]]).get(name) ?? value;
 	(state.configCdnCachePolicy ??= /* @__PURE__ */ new Map()).set(name.toLowerCase(), applied);
 }
-/** Record a public cache policy supplied by the Route Handler itself. */
+/** Record an explicit cache policy supplied by the Route Handler itself. */
 function markRouteCacheabilityExplicitResponsePolicy() {
 	const state = readRouteCacheabilityState();
-	if (!state || state.mode !== "admit") return;
+	if (!state) return;
 	state.explicitResponseCachePolicy = true;
 }
 /** Record that the response body reached clean EOF and is now a replay stream. */

package/dist/shims/cdn-cache.d.ts

@@ -1,3 +1,4 @@
+import { VinextAssetFetcher } from "../server/multi-stage.js";
 import { CacheHandlerValue, IncrementalCacheValue } from "./cache-handler.js";
 import { setCdnCacheAdapter } from "./cdn-cache-state.js";
 //#region src/shims/cdn-cache.d.ts
@@ -10,6 +11,8 @@ export type CdnCacheableHeaderInput = {
    * when no cacheable policy applies.
    */
   cacheControl: string;
+  /** Explicit endpoint policy returned to clients, independent of shared admission. */
+  browserCacheControl?: string;
   /**
    * True when this is a freshly-rendered **streaming** response whose
    * dynamic-ness is not yet proven (late Server Component request-API usage can
@@ -47,8 +50,10 @@ export type CdnResponsePolicy = {
   /** Whether provider policy explicitly opts out of storage. */
   hasExplicitNonCacheablePolicy(headers: Headers, baseline?: Headers): boolean;
 };
+/** Split Cache-Control directives without treating quoted commas as separators. */
+export declare function splitCacheControlDirectives(cacheControl: string): string[];
 /** Whether a Cache-Control value contains an exact non-cacheable directive. */
-export declare function isNonCacheableCacheControl(cacheControl: string): boolean;
+export declare function isNonCacheableCacheControl(cacheControl: string, scope?: "shared" | "browser"): boolean;
 /**
  * The serving strategy for page-level ISR. Implement this to delegate
  * page/route/image caching to a CDN edge instead of the origin store.
@@ -100,6 +105,10 @@ export type CdnCacheAdapter = {
    * edge owns serving.
    */
   get(key: string, ctx?: Record<string, unknown>): Promise<CacheHandlerValue | null>;
+  /** Also supplies build-time PAGES entries for pages without getStaticProps. */
+  readonly hasPrerenderedPages?: boolean;
+  /** Optional host asset fetcher resolved by the adapter's platform bindings. */
+  readonly assets?: VinextAssetFetcher;
   /**
    * Persist a freshly-rendered page-level artifact.
    *

package/dist/shims/cdn-cache.js

@@ -1,17 +1,16 @@
 import { getExplicitCdnCacheAdapter, setCdnCacheAdapter } from "./cdn-cache-state.js";
 //#region src/shims/cdn-cache.ts
-/** Whether a Cache-Control value contains an exact non-cacheable directive. */
-function isNonCacheableCacheControl(cacheControl) {
+/** Split Cache-Control directives without treating quoted commas as separators. */
+function splitCacheControlDirectives(cacheControl) {
+	const directives = [];
 	let start = 0;
 	let quoted = false;
 	let escaped = false;
 	for (let index = 0; index <= cacheControl.length; index++) {
 		const char = cacheControl[index];
 		if (index === cacheControl.length || char === "," && !quoted) {
-			const directive = cacheControl.slice(start, index);
-			const equals = directive.indexOf("=");
-			const name = (equals === -1 ? directive : directive.slice(0, equals)).trim().toLowerCase();
-			if (name === "no-store" || equals === -1 && (name === "private" || name === "no-cache")) return true;
+			const directive = cacheControl.slice(start, index).trim();
+			if (directive) directives.push(directive);
 			start = index + 1;
 			continue;
 		}
@@ -22,7 +21,15 @@ function isNonCacheableCacheControl(cacheControl) {
 		if (char === "\"" && !escaped) quoted = !quoted;
 		escaped = false;
 	}
-	return false;
+	return directives;
+}
+/** Whether a Cache-Control value contains an exact non-cacheable directive. */
+function isNonCacheableCacheControl(cacheControl, scope = "shared") {
+	return splitCacheControlDirectives(cacheControl).some((directive) => {
+		const equals = directive.indexOf("=");
+		const name = (equals === -1 ? directive : directive.slice(0, equals)).trim().toLowerCase();
+		return name === "no-store" || equals === -1 && (name === "no-cache" || scope === "shared" && name === "private");
+	});
 }
 const PENDING_DYNAMIC_CACHE_CONTROL = "no-store, must-revalidate";
 /**
@@ -48,7 +55,7 @@ var DefaultCdnCacheAdapter = class {
 	}
 	buildResponseHeaders(input) {
 		if (input.pendingDynamicCheck) return { "Cache-Control": PENDING_DYNAMIC_CACHE_CONTROL };
-		return { "Cache-Control": input.cacheControl };
+		return { "Cache-Control": input.browserCacheControl ?? input.cacheControl };
 	}
 	buildResponseIdentityHeaders() {
 		return this.buildIdentity ? { "X-Vinext-Build-Id": this.buildIdentity } : {};
@@ -88,4 +95,4 @@ function getCdnCacheAdapter() {
 	return _defaultAdapter ??= new DefaultCdnCacheAdapter();
 }
 //#endregion
-export { DefaultCdnCacheAdapter, getCdnCacheAdapter, isNonCacheableCacheControl, setCdnCacheAdapter };
+export { DefaultCdnCacheAdapter, getCdnCacheAdapter, isNonCacheableCacheControl, setCdnCacheAdapter, splitCacheControlDirectives };

package/dist/shims/error.d.ts

@@ -1,5 +1,6 @@
 import React from "react";
 import { IncomingMessage, ServerResponse } from "node:http";
+import { ErrorInfo, catchError as catchError$1, unstable_catchError as unstable_catchError$1 } from "@vinext/types/next/vinext/error";
 //#region src/shims/error.d.ts
 export type ErrorProps = {
   statusCode: number;
@@ -21,22 +22,7 @@ declare class ErrorComponent<P = {}> extends React.Component<P & ErrorProps> {
   static origGetInitialProps: typeof getErrorInitialProps;
   render(): React.ReactElement;
 }
-export type ErrorInfo = {
-  error: Error;
-  reset: () => void;
-  unstable_retry: () => void;
-};
-type _UserProps = Record<string, unknown>;
-/**
- * Wrap a fallback render function in a Component-level error boundary.
- * Returns a Component that renders `children` and, on error, renders the
- * supplied fallback with an `ErrorInfo` value.
- *
- * Ported from Next.js:
- *   https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/catch-error.tsx
- */
-export declare function unstable_catchError<P extends _UserProps>(fallback: (props: P, errorInfo: ErrorInfo) => React.ReactNode): React.ComponentType<P & {
-  children?: React.ReactNode;
-}>;
+export declare const catchError: typeof catchError$1;
+export declare const unstable_catchError: typeof unstable_catchError$1;
 //#endregion
-export { ErrorComponent as default };
+export { type ErrorInfo, ErrorComponent as default };