vinext 0.1.3 → 0.1.5

package/dist/shims/cache-handler.js

@@ -0,0 +1,176 @@
+import { readCacheControlNumberField } from "../utils/cache-control-metadata.js";
+//#region src/shims/cache-handler.ts
+var NoOpCacheHandler = class {
+	async get(_key, _ctx) {
+		return null;
+	}
+	async set(_key, _data, _ctx) {}
+	async revalidateTag(_tags, _durations) {}
+};
+const DEFAULT_MEMORY_CACHE_MAX_SIZE = 50 * 1024 * 1024;
+const MAX_REVALIDATED_TAG_ENTRIES = 1e4;
+function estimateStringMapSize(map) {
+	if (!map) return 0;
+	let size = 0;
+	for (const [key, value] of Object.entries(map)) {
+		size += key.length;
+		if (Array.isArray(value)) for (const item of value) size += item.length;
+		else size += value.length;
+	}
+	return size;
+}
+function estimateIncrementalCacheValueSize(value) {
+	if (value === null) return 25;
+	switch (value.kind) {
+		case "FETCH": return JSON.stringify(value.data ?? "").length;
+		case "PAGES": return value.html.length + JSON.stringify(value.pageData ?? {}).length + estimateStringMapSize(value.headers);
+		case "APP_PAGE": return value.html.length + (value.rscData?.byteLength ?? 0) + (value.postponed?.length ?? 0) + estimateStringMapSize(value.headers);
+		case "APP_ROUTE": return value.body.byteLength + estimateStringMapSize(value.headers);
+		case "REDIRECT": return JSON.stringify(value.props ?? {}).length;
+		case "IMAGE": return value.buffer.byteLength + value.extension.length + value.etag.length;
+		default: return JSON.stringify(value).length;
+	}
+}
+function resolveMemoryCacheMaxSize(options) {
+	if (typeof options === "number") return options;
+	if (typeof options?.cacheMaxMemorySize === "number") return options.cacheMaxMemorySize;
+	if (typeof options?.maxMemoryCacheSize === "number") return options.maxMemoryCacheSize;
+	return DEFAULT_MEMORY_CACHE_MAX_SIZE;
+}
+function readStringArrayField(ctx, field) {
+	const value = ctx?.[field];
+	if (!Array.isArray(value)) return [];
+	return value.filter((item) => typeof item === "string");
+}
+var MemoryCacheHandler = class {
+	store = /* @__PURE__ */ new Map();
+	tagRevalidatedAt = /* @__PURE__ */ new Map();
+	maxMemoryCacheSize;
+	currentMemoryCacheSize = 0;
+	constructor(options) {
+		this.maxMemoryCacheSize = resolveMemoryCacheMaxSize(options);
+	}
+	estimateEntrySize(entry) {
+		return estimateIncrementalCacheValueSize(entry.value) + entry.tags.reduce((sum, tag) => sum + tag.length, 0) + 64;
+	}
+	deleteEntry(key) {
+		const existing = this.store.get(key);
+		if (!existing) return;
+		this.currentMemoryCacheSize -= this.estimateEntrySize(existing);
+		this.store.delete(key);
+	}
+	touchEntry(key, entry) {
+		this.store.delete(key);
+		this.store.set(key, entry);
+	}
+	evictLeastRecentlyUsed() {
+		while (this.maxMemoryCacheSize > 0 && this.currentMemoryCacheSize > this.maxMemoryCacheSize) {
+			const oldestKey = this.store.keys().next().value;
+			if (oldestKey === void 0) return;
+			this.deleteEntry(oldestKey);
+		}
+	}
+	async get(key, ctx) {
+		const entry = this.store.get(key);
+		if (!entry) return null;
+		for (const tag of entry.tags) {
+			const revalidatedAt = this.tagRevalidatedAt.get(tag);
+			if (revalidatedAt && revalidatedAt >= entry.lastModified) {
+				this.deleteEntry(key);
+				return null;
+			}
+		}
+		for (const tag of readStringArrayField(ctx, "softTags")) {
+			const revalidatedAt = this.tagRevalidatedAt.get(tag);
+			if (revalidatedAt && revalidatedAt >= entry.lastModified) return null;
+		}
+		if (entry.expireAt !== null && Date.now() > entry.expireAt) {
+			this.deleteEntry(key);
+			return null;
+		}
+		this.touchEntry(key, entry);
+		if (entry.revalidateAt !== null && Date.now() > entry.revalidateAt) return {
+			lastModified: entry.lastModified,
+			value: entry.value,
+			cacheState: "stale",
+			cacheControl: entry.cacheControl
+		};
+		return {
+			lastModified: entry.lastModified,
+			value: entry.value,
+			cacheControl: entry.cacheControl
+		};
+	}
+	async set(key, data, ctx) {
+		const tagSet = /* @__PURE__ */ new Set();
+		if (data && "tags" in data && Array.isArray(data.tags)) for (const tag of data.tags) tagSet.add(tag);
+		for (const tag of readStringArrayField(ctx, "tags")) tagSet.add(tag);
+		const tags = [...tagSet];
+		let effectiveRevalidate = readCacheControlNumberField(ctx, "revalidate");
+		const effectiveExpire = readCacheControlNumberField(ctx, "expire");
+		if (data && "revalidate" in data && typeof data.revalidate === "number") effectiveRevalidate = data.revalidate;
+		if (effectiveRevalidate === 0) return;
+		const now = 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" ? effectiveExpire === void 0 ? { revalidate: effectiveRevalidate } : {
+			revalidate: effectiveRevalidate,
+			expire: effectiveExpire
+		} : void 0;
+		if (this.maxMemoryCacheSize === 0) return;
+		const entry = {
+			value: data,
+			tags,
+			lastModified: now,
+			revalidateAt,
+			expireAt,
+			cacheControl
+		};
+		const entrySize = this.estimateEntrySize(entry);
+		if (entrySize > this.maxMemoryCacheSize) {
+			this.deleteEntry(key);
+			return;
+		}
+		this.deleteEntry(key);
+		this.store.set(key, entry);
+		this.currentMemoryCacheSize += entrySize;
+		this.evictLeastRecentlyUsed();
+	}
+	async revalidateTag(tags) {
+		const tagList = Array.isArray(tags) ? tags : [tags];
+		const now = Date.now();
+		for (const tag of tagList) {
+			this.tagRevalidatedAt.set(tag, now);
+			while (this.tagRevalidatedAt.size > MAX_REVALIDATED_TAG_ENTRIES) {
+				const oldest = this.tagRevalidatedAt.keys().next().value;
+				if (oldest === void 0) break;
+				this.tagRevalidatedAt.delete(oldest);
+			}
+		}
+	}
+	resetRequestCache() {}
+};
+const HANDLER_KEY = Symbol.for("vinext.cacheHandler");
+const globalHandlers = globalThis;
+function getActiveHandler() {
+	return globalHandlers[HANDLER_KEY] ?? (globalHandlers[HANDLER_KEY] = new MemoryCacheHandler());
+}
+function configureMemoryCacheHandler(options) {
+	const current = globalHandlers[HANDLER_KEY];
+	if (current && !(current instanceof MemoryCacheHandler)) return;
+	globalHandlers[HANDLER_KEY] = new MemoryCacheHandler(options);
+}
+function setDataCacheHandler(handler) {
+	globalHandlers[HANDLER_KEY] = handler;
+}
+function getDataCacheHandler() {
+	return getActiveHandler();
+}
+function setCacheHandler(handler) {
+	setDataCacheHandler(handler);
+}
+function getCacheHandler() {
+	return getDataCacheHandler();
+}
+//#endregion
+export { MemoryCacheHandler, NoOpCacheHandler, configureMemoryCacheHandler, getCacheHandler, getDataCacheHandler, setCacheHandler, setDataCacheHandler };

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

@@ -0,0 +1,47 @@
+//#region src/shims/cache-request-state.d.ts
+type CacheLifeConfig = {
+  stale?: number;
+  revalidate?: number;
+  expire?: number;
+};
+declare const cacheLifeProfiles: Record<string, CacheLifeConfig>;
+type CacheContextLike = {
+  tags: string[];
+  lifeConfigs: CacheLifeConfig[];
+  variant: string;
+  hasExplicitRevalidate: boolean;
+  hasExplicitExpire: boolean;
+  dynamicNestedCacheError: Error | undefined;
+};
+declare function _registerCacheContextAccessor(fn: () => CacheContextLike | null): void;
+declare function getRegisteredCacheContext(): CacheContextLike | null;
+type UnstableCacheRevalidationMode = "foreground" | "background";
+type ActionRevalidationKind = 0 | 1 | 2;
+type UnstableCacheObservation = Readonly<{
+  kind: "unstable_cache";
+  keyHash: string;
+  revalidate: number | false | null;
+  tagCount: number;
+  tagHash: string | null;
+}>;
+type CacheState = {
+  actionRevalidationKind: ActionRevalidationKind;
+  requestScopedCacheLife: CacheLifeConfig | null;
+  unstableCacheObservations: Map<string, UnstableCacheObservation>;
+  unstableCacheRevalidation: UnstableCacheRevalidationMode;
+};
+declare const ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC = 1;
+declare const ACTION_DID_REVALIDATE_DYNAMIC_ONLY = 2;
+declare function _runWithCacheState<T>(fn: () => Promise<T>): Promise<T>;
+declare function _runWithCacheState<T>(fn: () => T | Promise<T>): T | Promise<T>;
+declare function _initRequestScopedCacheState(): void;
+declare function markActionRevalidation(kind: ActionRevalidationKind): void;
+declare function getAndClearActionRevalidationKind(): ActionRevalidationKind;
+declare function _setRequestScopedCacheLife(config: CacheLifeConfig): void;
+declare function _peekRequestScopedCacheLife(): CacheLifeConfig | null;
+declare function _consumeRequestScopedCacheLife(): CacheLifeConfig | null;
+declare function recordUnstableCacheObservation(observation: UnstableCacheObservation): void;
+declare function _peekUnstableCacheObservations(): UnstableCacheObservation[];
+declare function shouldServeStaleUnstableCacheEntry(): boolean;
+//#endregion
+export { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, ActionRevalidationKind, CacheLifeConfig, CacheState, UnstableCacheObservation, UnstableCacheRevalidationMode, _consumeRequestScopedCacheLife, _initRequestScopedCacheState, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _registerCacheContextAccessor, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, getRegisteredCacheContext, markActionRevalidation, recordUnstableCacheObservation, shouldServeStaleUnstableCacheEntry };

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

@@ -0,0 +1,126 @@
+import { getOrCreateAls } from "./internal/als-registry.js";
+import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
+import { getHeadersAccessPhase } from "./headers.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
+	}
+};
+let getCacheContext = null;
+function _registerCacheContextAccessor(fn) {
+	getCacheContext = fn;
+}
+function getRegisteredCacheContext() {
+	return getCacheContext?.() ?? null;
+}
+const FALLBACK_KEY = Symbol.for("vinext.cache.fallback");
+const globalState = globalThis;
+const cacheAls = getOrCreateAls("vinext.cache.als");
+const ACTION_DID_NOT_REVALIDATE = 0;
+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,
+	requestScopedCacheLife: null,
+	unstableCacheObservations: /* @__PURE__ */ new Map(),
+	unstableCacheRevalidation: "foreground"
+};
+function getCacheState() {
+	if (isInsideUnifiedScope()) return getRequestContext();
+	return cacheAls.getStore() ?? fallbackState;
+}
+function _runWithCacheState(fn) {
+	if (isInsideUnifiedScope()) return runWithUnifiedStateMutation((context) => {
+		context.actionRevalidationKind = ACTION_DID_NOT_REVALIDATE;
+		context.requestScopedCacheLife = null;
+		context.unstableCacheObservations = /* @__PURE__ */ new Map();
+		context.unstableCacheRevalidation = "foreground";
+	}, fn);
+	const state = {
+		actionRevalidationKind: ACTION_DID_NOT_REVALIDATE,
+		requestScopedCacheLife: null,
+		unstableCacheObservations: /* @__PURE__ */ new Map(),
+		unstableCacheRevalidation: "foreground"
+	};
+	return cacheAls.run(state, fn);
+}
+function _initRequestScopedCacheState() {
+	const state = getCacheState();
+	state.actionRevalidationKind = ACTION_DID_NOT_REVALIDATE;
+	state.requestScopedCacheLife = null;
+	state.unstableCacheObservations = /* @__PURE__ */ new Map();
+}
+function markActionRevalidation(kind) {
+	if (getHeadersAccessPhase() !== "action") return;
+	const state = getCacheState();
+	state.actionRevalidationKind = state.actionRevalidationKind === 1 ? 1 : kind;
+}
+function getAndClearActionRevalidationKind() {
+	const state = getCacheState();
+	const kind = state.actionRevalidationKind;
+	state.actionRevalidationKind = ACTION_DID_NOT_REVALIDATE;
+	return kind;
+}
+function _setRequestScopedCacheLife(config) {
+	const state = getCacheState();
+	if (state.requestScopedCacheLife === null) {
+		state.requestScopedCacheLife = { ...config };
+		return;
+	}
+	if (config.stale !== void 0) state.requestScopedCacheLife.stale = state.requestScopedCacheLife.stale !== void 0 ? Math.min(state.requestScopedCacheLife.stale, config.stale) : config.stale;
+	if (config.revalidate !== void 0) state.requestScopedCacheLife.revalidate = state.requestScopedCacheLife.revalidate !== void 0 ? Math.min(state.requestScopedCacheLife.revalidate, config.revalidate) : config.revalidate;
+	if (config.expire !== void 0) state.requestScopedCacheLife.expire = state.requestScopedCacheLife.expire !== void 0 ? Math.min(state.requestScopedCacheLife.expire, config.expire) : config.expire;
+}
+function _peekRequestScopedCacheLife() {
+	const config = getCacheState().requestScopedCacheLife;
+	return config === null ? null : { ...config };
+}
+function _consumeRequestScopedCacheLife() {
+	const state = getCacheState();
+	const config = state.requestScopedCacheLife;
+	state.requestScopedCacheLife = null;
+	return config;
+}
+function recordUnstableCacheObservation(observation) {
+	getCacheState().unstableCacheObservations.set(observation.keyHash, observation);
+}
+function _peekUnstableCacheObservations() {
+	return [...getCacheState().unstableCacheObservations.values()].sort((a, b) => a.keyHash.localeCompare(b.keyHash));
+}
+function shouldServeStaleUnstableCacheEntry() {
+	return getCacheState().unstableCacheRevalidation === "background";
+}
+//#endregion
+export { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, _consumeRequestScopedCacheLife, _initRequestScopedCacheState, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _registerCacheContextAccessor, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, getRegisteredCacheContext, markActionRevalidation, recordUnstableCacheObservation, shouldServeStaleUnstableCacheEntry };

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

@@ -1,4 +1,5 @@
-import { CacheLifeConfig } from "./cache.js";
+import { CacheLifeConfig } from "./cache-request-state.js";
+import { markAppPagePropsForUseCache } from "./internal/app-page-props-cache-key.js";
 
 //#region src/shims/cache-runtime.d.ts
 /**
@@ -58,7 +59,6 @@ declare function runWithPrivateCache<T>(fn: () => T | Promise<T>): T | Promise<T
  * Only needed when not using runWithPrivateCache() (legacy path).
  */
 declare function clearPrivateCache(): void;
-declare function markAppPagePropsForUseCache<T extends object>(props: T): T;
 type RegisterCachedFunctionOptions = {
   /**
    * Internal transform metadata for file-level `"use cache"` default exports

package/dist/shims/cache-runtime.js

@@ -1,10 +1,12 @@
 import { getOrCreateAls } from "./internal/als-registry.js";
 import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
 import { VINEXT_RSC_MARKER_HEADER } from "../server/headers.js";
+import { getDataCacheHandler } from "./cache-handler.js";
 import { trackPprFallbackShellCacheTask } from "./ppr-fallback-shell.js";
 import { markDynamicUsage } from "./headers.js";
-import { _registerCacheContextAccessor, _setRequestScopedCacheLife, cacheLifeProfiles, getDataCacheHandler } from "./cache.js";
+import { _registerCacheContextAccessor, _setRequestScopedCacheLife, cacheLifeProfiles } from "./cache-request-state.js";
 import { addCollectedRequestTags, getCurrentFetchSoftTags } from "./fetch-cache.js";
+import { isMarkedAppPagePropsObject, markAppPagePropsForUseCache } from "./internal/app-page-props-cache-key.js";
 //#region src/shims/cache-runtime.ts
 /**
 * "use cache" runtime
@@ -35,7 +37,6 @@ import { addCollectedRequestTags, getCurrentFetchSoftTags } from "./fetch-cache.
 * - "use cache: remote"   — shared cache (explicit)
 * - "use cache: private"  — per-request cache (not shared across requests)
 */
-const APP_PAGE_PROPS_CACHE_KEY_MARKER = Symbol.for("vinext.appPagePropsCacheKeyMarker");
 /** Threshold below which expire is considered "dynamic" (5 minutes in seconds). */
 const DYNAMIC_EXPIRE = 300;
 /**
@@ -222,15 +223,6 @@ function clearPrivateCache() {
 	if (state) state._privateCache = /* @__PURE__ */ new Map();
 	else _privateFallbackState._privateCache = /* @__PURE__ */ new Map();
 }
-function markAppPagePropsForUseCache(props) {
-	Object.defineProperty(props, APP_PAGE_PROPS_CACHE_KEY_MARKER, {
-		configurable: false,
-		enumerable: false,
-		value: true,
-		writable: false
-	});
-	return props;
-}
 /**
 * Register a function as a cached function. This is called by the Vite
 * transform for each "use cache" function.
@@ -429,9 +421,6 @@ function unwrapThenableObjects(value, options = {}) {
 	}
 	return result;
 }
-function isMarkedAppPagePropsObject(value) {
-	return Reflect.get(value, APP_PAGE_PROPS_CACHE_KEY_MARKER) === true;
-}
 function unwrapThenableObjectArray(values, options) {
 	return values.map((value, index) => unwrapThenableObjects(value, { omitAppPageSearchParamsAtRoot: index === 0 && options.omitAppPageSearchParamsFromFirstArg }));
 }

package/dist/shims/cache.d.ts

@@ -1,175 +1,8 @@
-import { CacheContext } from "./cache-runtime.js";
-import { RenderObservation } from "../server/cache-proof.js";
+import { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, ActionRevalidationKind, CacheLifeConfig, CacheState, UnstableCacheObservation, UnstableCacheRevalidationMode, _consumeRequestScopedCacheLife, _initRequestScopedCacheState, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _registerCacheContextAccessor, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, getRegisteredCacheContext, 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, setCacheHandler, setDataCacheHandler } from "./cache-handler.js";
 import { ExecutionContextLike, getRequestExecutionContext, runWithExecutionContext } from "./request-context.js";
 
 //#region src/shims/cache.d.ts
-type CacheContextLike = {
-  tags: string[];
-  lifeConfigs: CacheContext["lifeConfigs"];
-  variant: string;
-  hasExplicitRevalidate: boolean;
-  hasExplicitExpire: boolean;
-  dynamicNestedCacheError: Error | undefined;
-};
-/**
- * Register the cache context accessor. Called by cache-runtime.ts on load.
- * @internal
- */
-declare function _registerCacheContextAccessor(fn: () => CacheContextLike | null): void;
-type CacheHandlerValue = {
-  lastModified: number;
-  age?: number;
-  cacheState?: string;
-  cacheControl?: CacheControlMetadata;
-  value: IncrementalCacheValue | null;
-};
-type CacheControlMetadata = {
-  revalidate: number;
-  expire?: number;
-};
-/** Discriminated union of cache value types. */
-type IncrementalCacheValue = CachedFetchValue | CachedAppPageValue | CachedPagesValue | CachedRouteValue | CachedRedirectValue | CachedImageValue;
-type CachedFetchValue = {
-  kind: "FETCH";
-  data: {
-    headers: Record<string, string>;
-    body: string;
-    url: string;
-    status?: number;
-  };
-  tags?: string[];
-  revalidate: number | false;
-};
-type CachedAppPageValue = {
-  kind: "APP_PAGE";
-  html: string;
-  rscData: ArrayBuffer | undefined;
-  headers: Record<string, string | string[]> | undefined;
-  postponed: string | undefined;
-  renderObservation?: RenderObservation;
-  status: number | undefined;
-};
-type CachedPagesValue = {
-  kind: "PAGES";
-  html: string;
-  pageData: object;
-  generatedFromDataRequest?: boolean;
-  headers: Record<string, string | string[]> | undefined;
-  status: number | undefined;
-};
-type CachedRouteValue = {
-  kind: "APP_ROUTE";
-  body: ArrayBuffer;
-  status: number;
-  headers: Record<string, string | string[]>;
-};
-type CachedRedirectValue = {
-  kind: "REDIRECT";
-  props: object;
-};
-type CachedImageValue = {
-  kind: "IMAGE";
-  etag: string;
-  buffer: ArrayBuffer;
-  extension: string;
-  revalidate?: number;
-};
-type CacheHandlerContext = {
-  dev?: boolean;
-  maxMemoryCacheSize?: number;
-  revalidatedTags?: string[];
-  [key: string]: unknown;
-};
-type CacheHandler = {
-  get(key: string, ctx?: Record<string, unknown>): Promise<CacheHandlerValue | null>;
-  set(key: string, data: IncrementalCacheValue | null, ctx?: Record<string, unknown>): Promise<void>;
-  revalidateTag(tags: string | string[], durations?: {
-    expire?: number;
-  }): Promise<void>;
-  resetRequestCache?(): void;
-};
-declare class NoOpCacheHandler implements CacheHandler {
-  get(_key: string, _ctx?: Record<string, unknown>): Promise<CacheHandlerValue | null>;
-  set(_key: string, _data: IncrementalCacheValue | null, _ctx?: Record<string, unknown>): Promise<void>;
-  revalidateTag(_tags: string | string[], _durations?: {
-    expire?: number;
-  }): Promise<void>;
-}
-type MemoryCacheHandlerOptions = Pick<CacheHandlerContext, "maxMemoryCacheSize"> & {
-  cacheMaxMemorySize?: number;
-};
-/**
- * In-memory data cache handler. This is the built-in default — vinext installs
- * it automatically, so consumers should not construct or register it by hand.
- *
- * @deprecated Consumers should not instantiate cache handlers directly.
- * Configure caching declaratively via the `cache` option on the `vinext()`
- * plugin (see {@link setDataCacheHandler}); the in-memory handler is the
- * default when nothing is configured, and its size is tuned via the
- * `cacheMaxMemorySize` plugin option.
- */
-declare class MemoryCacheHandler implements CacheHandler {
-  private store;
-  private tagRevalidatedAt;
-  private readonly maxMemoryCacheSize;
-  private currentMemoryCacheSize;
-  constructor(options?: number | MemoryCacheHandlerOptions);
-  private estimateEntrySize;
-  private deleteEntry;
-  private touchEntry;
-  private evictLeastRecentlyUsed;
-  get(key: string, _ctx?: Record<string, unknown>): Promise<CacheHandlerValue | null>;
-  set(key: string, data: IncrementalCacheValue | null, ctx?: Record<string, unknown>): Promise<void>;
-  revalidateTag(tags: string | string[], _durations?: {
-    expire?: number;
-  }): Promise<void>;
-  resetRequestCache(): void;
-}
-declare function configureMemoryCacheHandler(options?: MemoryCacheHandlerOptions): void;
-/**
- * Set the **data cache** handler. This backs all data-cache concerns —
- * `fetch` caching, `"use cache"`, `unstable_cache` — and is also the default
- * underlying store for page-level ISR (via the default CDN cache adapter).
- *
- * The handler must implement the CacheHandler interface (same shape as
- * Next.js 16's CacheHandler class).
- *
- * @deprecated Don't wire up the data cache imperatively. Configure it
- * declaratively via the `cache.data` option on the `vinext()` plugin in your
- * `vite.config.ts`, using a config-time adapter builder. On Cloudflare Workers:
- *
- * ```ts
- * import { vinext } from "vinext";
- * import { kvDataAdapter } from "@vinext/cloudflare/cache/kv-data-adapter";
- *
- * export default defineConfig({
- *   plugins: [vinext({ cache: { data: kvDataAdapter({ binding: "VINEXT_KV_CACHE" }) } })],
- * });
- * ```
- *
- * The plugin defers instantiation to the first request and registers the
- * handler across every runtime/router entry, so you don't have to call this
- * from a worker entry. This setter remains as the internal registration target
- * and for backwards compatibility, but is not the recommended consumer API.
- */
-declare function setDataCacheHandler(handler: CacheHandler): void;
-/**
- * Get the active data cache handler (for internal use or testing).
- */
-declare function getDataCacheHandler(): CacheHandler;
-/**
- * @deprecated Don't wire up the data cache imperatively. Configure it
- * declaratively via the `cache.data` option on the `vinext()` plugin (e.g.
- * `kvDataAdapter()` from `@vinext/cloudflare/cache/kv-data-adapter`). See
- * {@link setDataCacheHandler} for the migration example. Retained as a
- * backwards-compatible alias — `setCacheHandler` has always configured the
- * data cache handler.
- */
-declare function setCacheHandler(handler: CacheHandler): void;
-/**
- * @deprecated Prefer {@link getDataCacheHandler}.
- */
-declare function getCacheHandler(): CacheHandler;
 /**
  * Revalidate cached data associated with a specific cache tag.
  *
@@ -264,67 +97,6 @@ declare function io(): Promise<void>;
  * removed in a future minor.
  */
 declare function unstable_io(): Promise<void>;
-type UnstableCacheRevalidationMode = "foreground" | "background";
-type ActionRevalidationKind = 0 | 1 | 2;
-type UnstableCacheObservation = Readonly<{
-  kind: "unstable_cache";
-  keyHash: string;
-  revalidate: number | false | null;
-  tagCount: number;
-  tagHash: string | null;
-}>;
-type CacheState = {
-  actionRevalidationKind: ActionRevalidationKind;
-  requestScopedCacheLife: CacheLifeConfig | null;
-  unstableCacheObservations: Map<string, UnstableCacheObservation>;
-  unstableCacheRevalidation: UnstableCacheRevalidationMode;
-};
-/**
- * Run a function within a cache state ALS scope.
- * Ensures per-request isolation for request-scoped cacheLife config
- * on concurrent runtimes.
- * @internal
- */
-declare function _runWithCacheState<T>(fn: () => Promise<T>): Promise<T>;
-declare function _runWithCacheState<T>(fn: () => T | Promise<T>): T | Promise<T>;
-/**
- * Initialize cache ALS for a new request. Call at request entry.
- * Only needed when not using _runWithCacheState() (legacy path).
- * @internal
- */
-declare function _initRequestScopedCacheState(): void;
-declare function getAndClearActionRevalidationKind(): ActionRevalidationKind;
-/**
- * Set a request-scoped cache life config. Called by cacheLife() so the route
- * render can inherit cache policy from file-level and nested "use cache" work.
- * @internal
- */
-declare function _setRequestScopedCacheLife(config: CacheLifeConfig): void;
-/**
- * Read the request-scoped cache life without clearing it. Prerender response
- * shaping needs the metadata before the manifest writer consumes it after the
- * body has been fully rendered.
- * @internal
- */
-declare function _peekRequestScopedCacheLife(): CacheLifeConfig | null;
-/**
- * Consume and reset the request-scoped cache life. Returns null if none was set.
- * @internal
- */
-declare function _consumeRequestScopedCacheLife(): CacheLifeConfig | null;
-declare function _peekUnstableCacheObservations(): UnstableCacheObservation[];
-/**
- * Cache life configuration. Controls stale-while-revalidate behavior.
- */
-type CacheLifeConfig = {
-  /** How long (seconds) the client can cache without checking the server */stale?: number; /** How frequently (seconds) the server cache refreshes */
-  revalidate?: number; /** Max staleness (seconds) before deoptimizing to dynamic */
-  expire?: number;
-};
-/**
- * Built-in cache life profiles matching Next.js 16.
- */
-declare const cacheLifeProfiles: Record<string, CacheLifeConfig>;
 /**
  * Set the cache lifetime for a "use cache" function.
  *
@@ -370,4 +142,4 @@ type UnstableCacheOptions = {
  */
 declare function unstable_cache<T extends (...args: any[]) => Promise<any>>(fn: T, keyParts?: string[], options?: UnstableCacheOptions): T;
 //#endregion
-export { ActionRevalidationKind, CacheControlMetadata, CacheHandler, CacheHandlerContext, CacheHandlerValue, CacheLifeConfig, CacheState, CachedAppPageValue, CachedFetchValue, CachedImageValue, CachedPagesValue, CachedRedirectValue, CachedRouteValue, type ExecutionContextLike, IncrementalCacheValue, MemoryCacheHandler, NoOpCacheHandler, UnstableCacheObservation, UnstableCacheRevalidationMode, _consumeRequestScopedCacheLife, _initRequestScopedCacheState, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _registerCacheContextAccessor, _runWithCacheState, _setRequestScopedCacheLife, cacheLife, cacheLifeProfiles, cacheTag, configureMemoryCacheHandler, getAndClearActionRevalidationKind, getCacheHandler, getDataCacheHandler, getRequestExecutionContext, io, isInsideUnstableCacheScope, unstable_noStore as noStore, unstable_noStore, refresh, revalidatePath, revalidateTag, runWithExecutionContext, setCacheHandler, setDataCacheHandler, unstable_cache, unstable_cacheLife, unstable_cacheTag, unstable_io, updateTag };
+export { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, ActionRevalidationKind, CacheControlMetadata, CacheHandler, CacheHandlerContext, CacheHandlerValue, CacheLifeConfig, CacheState, CachedAppPageValue, CachedFetchValue, CachedImageValue, CachedPagesValue, CachedRedirectValue, CachedRouteValue, type ExecutionContextLike, IncrementalCacheValue, MemoryCacheHandler, NoOpCacheHandler, UnstableCacheObservation, UnstableCacheRevalidationMode, _consumeRequestScopedCacheLife, _initRequestScopedCacheState, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _registerCacheContextAccessor, _runWithCacheState, _setRequestScopedCacheLife, cacheLife, cacheLifeProfiles, cacheTag, configureMemoryCacheHandler, getAndClearActionRevalidationKind, getCacheHandler, getDataCacheHandler, getRegisteredCacheContext, getRequestExecutionContext, io, isInsideUnstableCacheScope, markActionRevalidation, unstable_noStore as noStore, unstable_noStore, recordUnstableCacheObservation, refresh, revalidatePath, revalidateTag, runWithExecutionContext, setCacheHandler, setDataCacheHandler, shouldServeStaleUnstableCacheEntry, unstable_cache, unstable_cacheLife, unstable_cacheTag, unstable_io, updateTag };