vinext 1.3.1 → 1.4.1

package/dist/server/static-file-cache.d.ts

@@ -3,6 +3,15 @@
 export declare const CONTENT_TYPES: Record<string, string>;
 /** Resolve a path's MIME type with case-insensitive extension matching. */
 export declare function contentTypeForPath(filePath: string): string;
+/**
+ * Default `Cache-Control` for a file in the client build directory. Hashed
+ * build assets never change at their URL. Every other file (`public/`) must be
+ * revalidated on each reuse, as Next.js's `send` serves it with `max-age=0`:
+ * middleware may admit it per request, so a shared cache must not reuse it
+ * without asking the origin. A `Cache-Control` set by middleware or config
+ * headers replaces this default.
+ */
+export declare function staticFileCacheControl(isHashed: boolean): string;
 /** A servable file variant with pre-computed response headers. */
 type FileVariant = {
   /** Absolute file path (used for streaming large files). */

package/dist/server/static-file-cache.js

@@ -57,6 +57,17 @@ function contentTypeForPath(filePath) {
 	return CONTENT_TYPES[path.extname(filePath).toLowerCase()] ?? "application/octet-stream";
 }
 /**
+* Default `Cache-Control` for a file in the client build directory. Hashed
+* build assets never change at their URL. Every other file (`public/`) must be
+* revalidated on each reuse, as Next.js's `send` serves it with `max-age=0`:
+* middleware may admit it per request, so a shared cache must not reuse it
+* without asking the origin. A `Cache-Control` set by middleware or config
+* headers replaces this default.
+*/
+function staticFileCacheControl(isHashed) {
+	return isHashed ? "public, max-age=31536000, immutable" : "public, max-age=0";
+}
+/**
 * Files below this size are buffered in memory at startup for zero-syscall
 * serving via res.end(buffer). Above this, files stream via createReadStream.
 * 64KB covers virtually all precompressed assets (a 200KB JS bundle compresses
@@ -98,7 +109,7 @@ var StaticFileCache = class StaticFileCache {
 			if (isHashed && PRECOMPRESSION_TEMP_FILE_RE.test(relativePath)) continue;
 			const ext = path.extname(relativePath);
 			const contentType = contentTypeForPath(relativePath);
-			const cacheControl = isHashed ? "public, max-age=31536000, immutable" : "public, max-age=3600";
+			const cacheControl = staticFileCacheControl(isHashed);
 			const etag = isHashed && etagFromFilenameHash(relativePath, ext) || `W/"${fileInfo.size}-${Math.floor(fileInfo.mtimeMs / 1e3)}"`;
 			const lastModified = new Date(fileInfo.mtimeMs).toUTCString();
 			const baseHeaders = {
@@ -266,4 +277,4 @@ async function* walkFilesWithStats(dir, base = dir) {
 	}
 }
 //#endregion
-export { CONTENT_TYPES, StaticFileCache, contentTypeForPath, etagFromFilenameHash };
+export { CONTENT_TYPES, StaticFileCache, contentTypeForPath, etagFromFilenameHash, staticFileCacheControl };

package/dist/server/worker-stages.d.ts

@@ -1,7 +1,7 @@
-import { VinextResponseStageCacheability, VinextResponseStageTransport } from "./multi-stage.js";
+import { VinextResponseStageCacheability, VinextResponseStageDispatchOptions, VinextResponseStageTransport } from "./multi-stage.js";
 import { PagesRenderOptions } from "./pages-request-pipeline.js";
 //#region src/server/worker-stages.d.ts
-export declare const PAGES_RESPONSE_STAGE_PROTOCOL_VERSION = 5;
+export declare const PAGES_RESPONSE_STAGE_PROTOCOL_VERSION = 6;
 export declare const PAGES_RESPONSE_STAGE_POLICY_OWNER_HEADER = "x-vinext-pages-response-stage-policy-owner";
 export type PagesResponseStagePolicyOwner = "request-time" | "static";
 type PagesResponseStageEnvelope = {
@@ -14,10 +14,16 @@ type PagesResponseStageEnvelope = {
   stagedHeaders: Array<[string, string]> | null;
 };
 /** Serializable Pages page render delegated to a cacheable Worker stage. */
-type PagesPageResponseStageProps = PagesResponseStageEnvelope & {
+export type PagesPageResponseStageProps = PagesResponseStageEnvelope & {
   kind: "pages-page";
   renderOptions: PagesRenderOptions | null;
   resolvedUrl: string;
+  /**
+   * The shared cache entry answers every host, as Next.js keys a static page
+   * by its path, so a getInitialProps render of a page without
+   * getStaticProps, which reads the request, is not stored.
+   */
+  sharedAcrossHosts: boolean;
 };
 /** Serializable Pages API dispatch delegated to a cacheable Worker stage. */
 type PagesApiResponseStageProps = PagesResponseStageEnvelope & {
@@ -39,6 +45,13 @@ export type WorkerResponseStageProps = PagesApiResponseStageProps | PagesPageRes
  * response as Next.js.
  */
 export type DispatchWorkerResponseStage = VinextResponseStageTransport<WorkerResponseStageProps>;
+type PagesPageResponseStageCacheIdentity = NonNullable<VinextResponseStageDispatchOptions["cacheIdentity"]>;
+/**
+ * Build the cache identity of a shared Pages page dispatch: the dispatched
+ * request and props under `origin`, so every host that names it shares one
+ * entry.
+ */
+export declare function createSharedPagesPageCacheIdentity(request: Request, props: PagesPageResponseStageProps, origin: string): PagesPageResponseStageCacheIdentity;
 export declare function isPagesResponseStageProps(value: unknown): value is WorkerResponseStageProps;
 //#endregion
 export {};

package/dist/server/worker-stages.js

@@ -1,6 +1,25 @@
+import { withCacheIdentityOrigin } from "./multi-stage.js";
 //#region src/server/worker-stages.ts
-const PAGES_RESPONSE_STAGE_PROTOCOL_VERSION = 5;
+const PAGES_RESPONSE_STAGE_PROTOCOL_VERSION = 6;
 const PAGES_RESPONSE_STAGE_POLICY_OWNER_HEADER = "x-vinext-pages-response-stage-policy-owner";
+/**
+* Build the cache identity of a shared Pages page dispatch: the dispatched
+* request and props under `origin`, so every host that names it shares one
+* entry.
+*/
+function createSharedPagesPageCacheIdentity(request, props, origin) {
+	return {
+		props: {
+			...props,
+			requestHost: new URL(origin).host
+		},
+		regenerateFromDispatch: true,
+		request: new Request(withCacheIdentityOrigin(request.url, origin), {
+			headers: new Headers(request.headers),
+			method: request.method
+		})
+	};
+}
 function isSerializedHeaders(value) {
 	return Array.isArray(value) && value.every((entry) => Array.isArray(entry) && entry.length === 2 && typeof entry[0] === "string" && typeof entry[1] === "string");
 }
@@ -12,14 +31,14 @@ function isResponseStageCacheability(value) {
 function isPagesResponseStageProps(value) {
 	if (!value || typeof value !== "object") return false;
 	const props = value;
-	if (props.protocolVersion !== 5 || props.buildId !== null && typeof props.buildId !== "string" || !isResponseStageCacheability(props.cacheability) || typeof props.requestHost !== "string" || props.requestHost.length === 0 || props.stagedHeaders !== null && !isSerializedHeaders(props.stagedHeaders)) return false;
+	if (props.protocolVersion !== 6 || props.buildId !== null && typeof props.buildId !== "string" || !isResponseStageCacheability(props.cacheability) || typeof props.requestHost !== "string" || props.requestHost.length === 0 || props.stagedHeaders !== null && !isSerializedHeaders(props.stagedHeaders)) return false;
 	if (props.kind === "pages-api") return typeof props.apiUrl === "string";
 	if (props.kind === "pages-prerender-discovery") return true;
-	if (props.kind !== "pages-page" || typeof props.resolvedUrl !== "string") return false;
+	if (props.kind !== "pages-page" || typeof props.resolvedUrl !== "string" || typeof props.sharedAcrossHosts !== "boolean") return false;
 	if (props.renderOptions === null) return true;
 	if (!props.renderOptions || typeof props.renderOptions !== "object") return false;
 	const options = props.renderOptions;
 	return (options.isDataReq === void 0 || typeof options.isDataReq === "boolean") && (options.renderErrorPageOnMiss === void 0 || typeof options.renderErrorPageOnMiss === "boolean") && (options.originalUrl === void 0 || typeof options.originalUrl === "string");
 }
 //#endregion
-export { PAGES_RESPONSE_STAGE_POLICY_OWNER_HEADER, PAGES_RESPONSE_STAGE_PROTOCOL_VERSION, isPagesResponseStageProps };
+export { PAGES_RESPONSE_STAGE_POLICY_OWNER_HEADER, PAGES_RESPONSE_STAGE_PROTOCOL_VERSION, createSharedPagesPageCacheIdentity, isPagesResponseStageProps };

package/dist/shims/cache-handler.js

@@ -1,5 +1,5 @@
 import { shareIsolatePromise } from "../server/isolate-shared-promise.js";
-import { readCacheControlNumberField, readCacheControlRevalidateField } from "../utils/cache-control-metadata.js";
+import { readCacheControlNumberField, readCacheControlRevalidateField, readCacheTimestamp } from "../utils/cache-control-metadata.js";
 //#region src/shims/cache-handler.ts
 var NoOpCacheHandler = class {
 	async get(_key, _ctx) {
@@ -122,7 +122,7 @@ var MemoryCacheHandler = class {
 		if (data && "revalidate" in data && typeof data.revalidate === "number") effectiveRevalidate = data.revalidate;
 		else if (data && "revalidate" in data && data.revalidate === false) effectiveRevalidate ??= false;
 		if (effectiveRevalidate === 0) return;
-		const now = Date.now();
+		const now = readCacheTimestamp(ctx, Date.now());
 		const revalidateAt = typeof effectiveRevalidate === "number" && effectiveRevalidate > 0 ? now + effectiveRevalidate * 1e3 : null;
 		const expireAt = typeof effectiveExpire === "number" && effectiveExpire > 0 ? now + effectiveExpire * 1e3 : null;
 		const cacheControl = typeof effectiveRevalidate === "number" || effectiveRevalidate === false ? {

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

@@ -1,28 +1,13 @@
+import { CacheLifeConfig } from "../utils/cache-life-profiles.js";
 import { _recordUseCacheRootParamRead, _registerCacheContextAccessor, getRegisteredCacheContext } from "./internal/cache-context-accessor.js";
 //#region src/shims/cache-request-state.d.ts
-export type CacheLifeConfig = {
-  stale?: number;
-  revalidate?: number;
-  expire?: number;
-};
+/**
+ * The built-in profiles merged with next.config `cacheLife`, baked in at
+ * build time like Next.js's `process.env.__NEXT_CACHE_LIFE` define.
+ */
 export declare const cacheLifeProfiles: Record<string, CacheLifeConfig>;
 export type UnstableCacheRevalidationMode = "foreground" | "background";
 export type ActionRevalidationKind = 0 | 1 | 2;
-export type UnstableCacheObservation = Readonly<{
-  kind: "unstable_cache";
-  keyHash: string;
-  revalidate: number | false | null;
-  tagCount: number;
-  tagHash: string | null;
-}>;
-/**
- * Collects the cacheLife claims made anywhere below the scope that installed
- * it, including nested scopes that reset `requestScopedCacheLife`. Shallow
- * scope clones share it by reference.
- */
-export type CacheLifeSink = {
-  cacheLife: CacheLifeConfig | null;
-};
 type TagInvalidationDurations = {
   expire?: number;
 } | undefined;
@@ -34,12 +19,17 @@ export type PendingCdnTagInvalidation = Readonly<{
 }>;
 export type CacheState = {
   actionRevalidationKind: ActionRevalidationKind;
-  cacheLifeSink: CacheLifeSink | null;
+  /**
+   * The request is an authorized on-demand revalidation (`res.revalidate()`).
+   * Like Next.js's `workStore.isOnDemandRevalidate`, the data caches then skip
+   * their reads but still execute and store fresh results. Set once when the
+   * request context is created; nested scopes inherit it.
+   */
+  isOnDemandRevalidate: boolean;
   pendingCdnTagInvalidations: PendingCdnTagInvalidation[];
   pendingRevalidatedTags: Set<string>;
   pendingRevalidations: Set<Promise<void>>;
   requestScopedCacheLife: CacheLifeConfig | null;
-  unstableCacheObservations: Map<string, UnstableCacheObservation>;
   unstableCacheRevalidation: UnstableCacheRevalidationMode;
 };
 export declare const ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC = 1;
@@ -47,6 +37,15 @@ export declare const ACTION_DID_REVALIDATE_DYNAMIC_ONLY = 2;
 export declare function _runWithCacheState<T>(fn: () => Promise<T>): Promise<T>;
 export declare function _runWithCacheState<T>(fn: () => T | Promise<T>): T | Promise<T>;
 export declare function _initRequestScopedCacheState(): void;
+/**
+ * Whether the current request is an authorized on-demand revalidation, so the
+ * data caches must skip their reads (not their writes). Mirrors Next.js's
+ * `workStore.isOnDemandRevalidate` checks in use-cache-wrapper, patch-fetch
+ * and unstable-cache.
+ *
+ * @internal
+ */
+export declare function _isOnDemandRevalidate(): boolean;
 export declare function markActionRevalidation(kind: ActionRevalidationKind): void;
 export declare function getAndClearActionRevalidationKind(): ActionRevalidationKind;
 /** @internal */
@@ -114,14 +113,12 @@ export declare function _captureRequestScopedCacheLifeAccessors(): {
   consume: () => CacheLifeConfig | null;
   peek: () => CacheLifeConfig | null;
 };
-export declare function recordUnstableCacheObservation(observation: UnstableCacheObservation): void;
-export declare function _peekUnstableCacheObservations(): UnstableCacheObservation[];
 /**
  * Run `fn` with the request's cache settings, including its revalidation mode,
- * but its own record of cache lives and unstable_cache observations, so work
+ * but its own record of cache lives, so work
  * done on the request's behalf after the fact leaves the request untouched.
  */
 export declare function runWithDetachedCacheObservations<T>(fn: () => Promise<T>): Promise<T>;
 export declare function shouldServeStaleUnstableCacheEntry(): boolean;
 //#endregion
-export { _recordUseCacheRootParamRead, _registerCacheContextAccessor, getRegisteredCacheContext };
+export { type CacheLifeConfig, _recordUseCacheRootParamRead, _registerCacheContextAccessor, getRegisteredCacheContext };

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

@@ -1,45 +1,15 @@
 import { getOrCreateAls } from "./internal/als-registry.js";
 import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
+import { parseCacheLifeProfiles } from "../utils/cache-life-profiles.js";
 import { getCdnCacheAdapter } from "./cdn-cache.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: {
-		revalidate: 900,
-		expire: 4294967294
-	},
-	seconds: {
-		stale: 30,
-		revalidate: 1,
-		expire: 60
-	},
-	minutes: {
-		stale: 300,
-		revalidate: 60,
-		expire: 3600
-	},
-	hours: {
-		stale: 300,
-		revalidate: 3600,
-		expire: 86400
-	},
-	days: {
-		stale: 300,
-		revalidate: 86400,
-		expire: 604800
-	},
-	weeks: {
-		stale: 300,
-		revalidate: 604800,
-		expire: 2592e3
-	},
-	max: {
-		stale: 300,
-		revalidate: 2592e3,
-		expire: 31536e3
-	}
-};
+/**
+* The built-in profiles merged with next.config `cacheLife`, baked in at
+* build time like Next.js's `process.env.__NEXT_CACHE_LIFE` define.
+*/
+const cacheLifeProfiles = parseCacheLifeProfiles(process.env.__VINEXT_CACHE_LIFE_PROFILES);
 const FALLBACK_KEY = Symbol.for("vinext.cache.fallback");
 const globalState = globalThis;
 const cacheAls = getOrCreateAls("vinext.cache.als");
@@ -48,12 +18,11 @@ const ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC = 1;
 const ACTION_DID_REVALIDATE_DYNAMIC_ONLY = 2;
 const fallbackState = globalState[FALLBACK_KEY] ??= {
 	actionRevalidationKind: ACTION_DID_NOT_REVALIDATE,
-	cacheLifeSink: null,
+	isOnDemandRevalidate: false,
 	pendingCdnTagInvalidations: [],
 	pendingRevalidatedTags: /* @__PURE__ */ new Set(),
 	pendingRevalidations: /* @__PURE__ */ new Set(),
 	requestScopedCacheLife: null,
-	unstableCacheObservations: /* @__PURE__ */ new Map(),
 	unstableCacheRevalidation: "foreground"
 };
 function getCacheState() {
@@ -63,19 +32,16 @@ function getCacheState() {
 function _runWithCacheState(fn) {
 	if (isInsideUnifiedScope()) return runWithUnifiedStateMutation((context) => {
 		context.actionRevalidationKind = ACTION_DID_NOT_REVALIDATE;
-		context.cacheLifeSink = null;
 		context.requestScopedCacheLife = null;
-		context.unstableCacheObservations = /* @__PURE__ */ new Map();
 		context.unstableCacheRevalidation = "foreground";
 	}, fn);
 	const state = {
 		actionRevalidationKind: ACTION_DID_NOT_REVALIDATE,
-		cacheLifeSink: null,
+		isOnDemandRevalidate: false,
 		pendingCdnTagInvalidations: [],
 		pendingRevalidatedTags: /* @__PURE__ */ new Set(),
 		pendingRevalidations: /* @__PURE__ */ new Set(),
 		requestScopedCacheLife: null,
-		unstableCacheObservations: /* @__PURE__ */ new Map(),
 		unstableCacheRevalidation: "foreground"
 	};
 	return cacheAls.run(state, fn);
@@ -84,7 +50,17 @@ function _initRequestScopedCacheState() {
 	const state = getCacheState();
 	state.actionRevalidationKind = ACTION_DID_NOT_REVALIDATE;
 	state.requestScopedCacheLife = null;
-	state.unstableCacheObservations = /* @__PURE__ */ new Map();
+}
+/**
+* Whether the current request is an authorized on-demand revalidation, so the
+* data caches must skip their reads (not their writes). Mirrors Next.js's
+* `workStore.isOnDemandRevalidate` checks in use-cache-wrapper, patch-fetch
+* and unstable-cache.
+*
+* @internal
+*/
+function _isOnDemandRevalidate() {
+	return getCacheState().isOnDemandRevalidate === true;
 }
 function markActionRevalidation(kind) {
 	if (getHeadersAccessPhase() !== "action") return;
@@ -224,7 +200,6 @@ function mergeCacheLife(current, config) {
 function _setRequestScopedCacheLife(config) {
 	const state = getCacheState();
 	state.requestScopedCacheLife = mergeCacheLife(state.requestScopedCacheLife, config);
-	if (state.cacheLifeSink) state.cacheLifeSink.cacheLife = mergeCacheLife(state.cacheLifeSink.cacheLife, config);
 }
 function _peekRequestScopedCacheLife() {
 	const config = getCacheState().requestScopedCacheLife;
@@ -257,32 +232,22 @@ function _captureRequestScopedCacheLifeAccessors() {
 		}
 	};
 }
-function recordUnstableCacheObservation(observation) {
-	getCacheState().unstableCacheObservations.set(observation.keyHash, observation);
-}
-function _peekUnstableCacheObservations() {
-	return [...getCacheState().unstableCacheObservations.values()].sort((a, b) => a.keyHash.localeCompare(b.keyHash));
-}
 /**
 * Run `fn` with the request's cache settings, including its revalidation mode,
-* but its own record of cache lives and unstable_cache observations, so work
+* but its own record of cache lives, so work
 * done on the request's behalf after the fact leaves the request untouched.
 */
 function runWithDetachedCacheObservations(fn) {
 	if (isInsideUnifiedScope()) return runWithUnifiedStateMutation((context) => {
-		context.cacheLifeSink = null;
 		context.requestScopedCacheLife = null;
-		context.unstableCacheObservations = /* @__PURE__ */ new Map();
 	}, fn);
 	return cacheAls.run({
 		...getCacheState(),
-		cacheLifeSink: null,
-		requestScopedCacheLife: null,
-		unstableCacheObservations: /* @__PURE__ */ new Map()
+		requestScopedCacheLife: null
 	}, fn);
 }
 function shouldServeStaleUnstableCacheEntry() {
 	return getCacheState().unstableCacheRevalidation === "background";
 }
 //#endregion
-export { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingCdnTagInvalidation, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _revalidateCdnTags, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, getRegisteredCacheContext, markActionRevalidation, recordUnstableCacheObservation, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry };
+export { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _isOnDemandRevalidate, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _queuePendingCdnTagInvalidation, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _revalidateCdnTags, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, getRegisteredCacheContext, markActionRevalidation, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry };

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

@@ -1,4 +1,4 @@
-import { CacheLifeConfig } from "./cache-request-state.js";
+import { CacheLifeConfig } from "../utils/cache-life-profiles.js";
 import { CacheFlightArguments } from "./cache-flight-arguments.js";
 //#region src/shims/cache-runtime.d.ts
 export declare function replayCachedFunction(fn: object, args: CacheFlightArguments): Promise<unknown>;
@@ -16,6 +16,8 @@ export type CacheContext = {
   tags: string[];
   /** Cache life configs collected via cacheLife() — minimum-wins rule applies */
   lifeConfigs: CacheLifeConfig[];
+  /** Resolved lives of nested caches; they only constrain fields cacheLife() left unset */
+  nestedLifeConfigs: CacheLifeConfig[];
   /** Cache variant: "default" | "remote" | "private" */
   variant: string;
   /** Root params observed while producing this public cache entry. */