vinext 1.0.0-beta.8 → 1.0.0

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

@@ -1,13 +1,13 @@
 import { RenderObservation } from "../server/cache-proof.js";
 //#region src/shims/cache-handler.d.ts
-type CacheHandlerValue = {
+export type CacheHandlerValue = {
   lastModified: number;
   age?: number;
   cacheState?: string;
   cacheControl?: CacheControlMetadata;
   value: IncrementalCacheValue | null;
 };
-type CacheControlMetadata = {
+export type CacheControlMetadata = {
   revalidate: number | false;
   expire?: number;
   /**
@@ -17,8 +17,8 @@ type CacheControlMetadata = {
    */
   stale?: number;
 };
-type IncrementalCacheValue = CachedFetchValue | CachedAppPageValue | CachedPagesValue | CachedRouteValue | CachedRedirectValue | CachedImageValue;
-type CachedFetchValue = {
+export type IncrementalCacheValue = CachedFetchValue | CachedAppPageValue | CachedPagesValue | CachedRouteValue | CachedRedirectValue | CachedImageValue;
+export type CachedFetchValue = {
   kind: "FETCH";
   data: {
     headers: Record<string, string>;
@@ -29,16 +29,23 @@ type CachedFetchValue = {
   tags?: string[];
   revalidate: number | false;
 };
-type CachedAppPageValue = {
+export type CachedAppPageValue = {
   kind: "APP_PAGE";
   html: string;
   rscData: ArrayBuffer | undefined;
   headers: Record<string, string | string[]> | undefined;
   postponed: string | undefined;
+  /**
+   * Set by a read-only adapter whose entries are build-time prerenders. A
+   * prerender that reads the query is skipped as dynamic, so such an entry
+   * serves every query without a render observation, as Next.js serves its
+   * static output.
+   */
+  prerendered?: true;
   renderObservation?: RenderObservation;
   status: number | undefined;
 };
-type CachedPagesValue = {
+export type CachedPagesValue = {
   kind: "PAGES";
   html: string;
   pageData: object;
@@ -46,30 +53,30 @@ type CachedPagesValue = {
   headers: Record<string, string | string[]> | undefined;
   status: number | undefined;
 };
-type CachedRouteValue = {
+export type CachedRouteValue = {
   kind: "APP_ROUTE";
   body: ArrayBuffer;
   status: number;
   headers: Record<string, string | string[]>;
 };
-type CachedRedirectValue = {
+export type CachedRedirectValue = {
   kind: "REDIRECT";
   props: object;
 };
-type CachedImageValue = {
+export type CachedImageValue = {
   kind: "IMAGE";
   etag: string;
   buffer: ArrayBuffer;
   extension: string;
   revalidate?: number;
 };
-type CacheHandlerContext = {
+export type CacheHandlerContext = {
   dev?: boolean;
   maxMemoryCacheSize?: number;
   revalidatedTags?: string[];
   [key: string]: unknown;
 };
-type CacheHandler = {
+export 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?: {
@@ -77,7 +84,7 @@ type CacheHandler = {
   }): Promise<void>;
   resetRequestCache?(): void;
 };
-declare class NoOpCacheHandler implements CacheHandler {
+export 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?: {
@@ -87,7 +94,7 @@ declare class NoOpCacheHandler implements CacheHandler {
 type MemoryCacheHandlerOptions = Pick<CacheHandlerContext, "maxMemoryCacheSize"> & {
   cacheMaxMemorySize?: number;
 };
-declare class MemoryCacheHandler implements CacheHandler {
+export declare class MemoryCacheHandler implements CacheHandler {
   private store;
   private tagRevalidatedAt;
   private readonly maxMemoryCacheSize;
@@ -102,10 +109,16 @@ declare class MemoryCacheHandler implements CacheHandler {
   revalidateTag(tags: string | string[]): Promise<void>;
   resetRequestCache(): void;
 }
-declare function configureMemoryCacheHandler(options?: MemoryCacheHandlerOptions): void;
-declare function setDataCacheHandler(handler: CacheHandler): void;
-declare function getDataCacheHandler(): CacheHandler;
-declare function setCacheHandler(handler: CacheHandler): void;
-declare function getCacheHandler(): CacheHandler;
-//#endregion
-export { CacheControlMetadata, CacheHandler, CacheHandlerContext, CacheHandlerValue, CachedAppPageValue, CachedFetchValue, CachedImageValue, CachedPagesValue, CachedRedirectValue, CachedRouteValue, IncrementalCacheValue, MemoryCacheHandler, NoOpCacheHandler, configureMemoryCacheHandler, getCacheHandler, getDataCacheHandler, setCacheHandler, setDataCacheHandler };
+export declare function configureMemoryCacheHandler(options?: MemoryCacheHandlerOptions): void;
+export declare function setDataCacheHandler(handler: CacheHandler): void;
+/**
+ * Lazily keep the first declaratively configured handler shared across
+ * duplicated stage modules. Imperative setters remain able to replace it.
+ */
+export declare function registerDataCacheHandler(factory: () => CacheHandler): void;
+/** Register a lightweight proxy that imports the configured handler on first use. */
+export declare function registerLazyDataCacheHandler(load: () => Promise<void>): void;
+export declare function getDataCacheHandler(): CacheHandler;
+export declare function setCacheHandler(handler: CacheHandler): void;
+export declare function getCacheHandler(): CacheHandler;
+//#endregion

package/dist/shims/cache-handler.js

@@ -7,7 +7,7 @@ var NoOpCacheHandler = class {
 	async set(_key, _data, _ctx) {}
 	async revalidateTag(_tags, _durations) {}
 };
-const DEFAULT_MEMORY_CACHE_MAX_SIZE = 50 * 1024 * 1024;
+const DEFAULT_MEMORY_CACHE_MAX_SIZE = 52428800;
 const MAX_REVALIDATED_TAG_ENTRIES = 1e4;
 function estimateStringMapSize(map) {
 	if (!map) return 0;
@@ -163,7 +163,45 @@ var MemoryCacheHandler = class {
 	resetRequestCache() {}
 };
 const HANDLER_KEY = Symbol.for("vinext.cacheHandler");
+const CONFIGURED_HANDLER_KEY = Symbol.for("vinext.configuredCacheHandler");
+const EXPLICIT_HANDLER_KEY = Symbol.for("vinext.explicitCacheHandler");
+const LAZY_HANDLER_KEY = Symbol.for("vinext.lazyCacheHandler");
 const globalHandlers = globalThis;
+var LazyDataCacheHandler = class {
+	load;
+	resolved;
+	loadedHandler;
+	constructor(load) {
+		this.load = load;
+	}
+	resolve() {
+		return this.resolved ??= this.load().then(() => {
+			const registered = globalHandlers[HANDLER_KEY];
+			if (registered && registered !== this) {
+				this.loadedHandler = registered;
+				return registered;
+			}
+			const fallback = new MemoryCacheHandler();
+			globalHandlers[HANDLER_KEY] = fallback;
+			globalHandlers[CONFIGURED_HANDLER_KEY] = fallback;
+			delete globalHandlers[LAZY_HANDLER_KEY];
+			this.loadedHandler = fallback;
+			return fallback;
+		});
+	}
+	async get(key, ctx) {
+		return (await this.resolve()).get(key, ctx);
+	}
+	async set(key, data, ctx) {
+		await (await this.resolve()).set(key, data, ctx);
+	}
+	async revalidateTag(tags, durations) {
+		await (await this.resolve()).revalidateTag(tags, durations);
+	}
+	resetRequestCache() {
+		this.loadedHandler?.resetRequestCache?.();
+	}
+};
 function getActiveHandler() {
 	return globalHandlers[HANDLER_KEY] ?? (globalHandlers[HANDLER_KEY] = new MemoryCacheHandler());
 }
@@ -174,6 +212,27 @@ function configureMemoryCacheHandler(options) {
 }
 function setDataCacheHandler(handler) {
 	globalHandlers[HANDLER_KEY] = handler;
+	globalHandlers[EXPLICIT_HANDLER_KEY] = handler;
+	delete globalHandlers[LAZY_HANDLER_KEY];
+}
+/**
+* Lazily keep the first declaratively configured handler shared across
+* duplicated stage modules. Imperative setters remain able to replace it.
+*/
+function registerDataCacheHandler(factory) {
+	if (globalHandlers[EXPLICIT_HANDLER_KEY] !== void 0 || globalHandlers[CONFIGURED_HANDLER_KEY] !== void 0) return;
+	const handler = factory();
+	if (globalHandlers[EXPLICIT_HANDLER_KEY] !== void 0 || globalHandlers[CONFIGURED_HANDLER_KEY] !== void 0) return;
+	globalHandlers[HANDLER_KEY] = handler;
+	globalHandlers[CONFIGURED_HANDLER_KEY] = handler;
+	delete globalHandlers[LAZY_HANDLER_KEY];
+}
+/** Register a lightweight proxy that imports the configured handler on first use. */
+function registerLazyDataCacheHandler(load) {
+	if (globalHandlers[EXPLICIT_HANDLER_KEY] !== void 0 || globalHandlers[CONFIGURED_HANDLER_KEY] !== void 0 || globalHandlers[LAZY_HANDLER_KEY] !== void 0) return;
+	const handler = new LazyDataCacheHandler(load);
+	globalHandlers[HANDLER_KEY] = handler;
+	globalHandlers[LAZY_HANDLER_KEY] = handler;
 }
 function getDataCacheHandler() {
 	return getActiveHandler();
@@ -185,4 +244,4 @@ function getCacheHandler() {
 	return getDataCacheHandler();
 }
 //#endregion
-export { MemoryCacheHandler, NoOpCacheHandler, configureMemoryCacheHandler, getCacheHandler, getDataCacheHandler, setCacheHandler, setDataCacheHandler };
+export { MemoryCacheHandler, NoOpCacheHandler, configureMemoryCacheHandler, getCacheHandler, getDataCacheHandler, registerDataCacheHandler, registerLazyDataCacheHandler, setCacheHandler, setDataCacheHandler };

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

@@ -1,10 +1,10 @@
 //#region src/shims/cache-request-state.d.ts
-type CacheLifeConfig = {
+export type CacheLifeConfig = {
   stale?: number;
   revalidate?: number;
   expire?: number;
 };
-declare const cacheLifeProfiles: Record<string, CacheLifeConfig>;
+export declare const cacheLifeProfiles: Record<string, CacheLifeConfig>;
 type CacheContextLike = {
   tags: string[];
   lifeConfigs: CacheLifeConfig[];
@@ -14,20 +14,20 @@ type CacheContextLike = {
   hasExplicitExpire: boolean;
   dynamicNestedCacheError: Error | undefined;
 };
-declare function _registerCacheContextAccessor(fn: () => CacheContextLike | null): void;
-declare function getRegisteredCacheContext(): CacheContextLike | null;
+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. */
-declare function _recordUseCacheRootParamRead(name: string): void;
-type UnstableCacheRevalidationMode = "foreground" | "background";
-type ActionRevalidationKind = 0 | 1 | 2;
-type UnstableCacheObservation = Readonly<{
+export declare function _recordUseCacheRootParamRead(name: string): void;
+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;
 }>;
-type CacheState = {
+export type CacheState = {
   actionRevalidationKind: ActionRevalidationKind;
   pendingRevalidatedTags: Set<string>;
   pendingRevalidations: Set<Promise<void>>;
@@ -35,17 +35,17 @@ type CacheState = {
   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;
+export declare const ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC = 1;
+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;
+export declare function markActionRevalidation(kind: ActionRevalidationKind): void;
+export declare function getAndClearActionRevalidationKind(): ActionRevalidationKind;
 /** @internal */
-declare function _markPendingRevalidatedTag(tag: string): void;
+export declare function _markPendingRevalidatedTag(tag: string): void;
 /** @internal */
-declare function _hasPendingRevalidatedTag(tags: readonly string[]): boolean;
+export declare function _hasPendingRevalidatedTag(tags: readonly string[]): boolean;
 /**
  * Record a cache invalidation that must finish before the current action or
  * route-handler request is finalized. The public revalidation APIs remain
@@ -57,7 +57,7 @@ declare function _hasPendingRevalidatedTag(tags: readonly string[]): boolean;
  *
  * @internal
  */
-declare function _queuePendingRevalidation(promise: Promise<void>): boolean;
+export declare function _queuePendingRevalidation(promise: Promise<void>): boolean;
 /**
  * Await and clear every cache invalidation queued in the current request.
  * Clearing before awaiting also lets a later drain observe work enqueued by
@@ -65,10 +65,10 @@ declare function _queuePendingRevalidation(promise: Promise<void>): boolean;
  *
  * @internal
  */
-declare function _drainPendingRevalidations(): Promise<void>;
-declare function _setRequestScopedCacheLife(config: CacheLifeConfig): void;
-declare function _peekRequestScopedCacheLife(): CacheLifeConfig | null;
-declare function _consumeRequestScopedCacheLife(): CacheLifeConfig | null;
+export declare function _drainPendingRevalidations(): Promise<void>;
+export declare function _setRequestScopedCacheLife(config: CacheLifeConfig): void;
+export declare function _peekRequestScopedCacheLife(): CacheLifeConfig | null;
+export declare function _consumeRequestScopedCacheLife(): CacheLifeConfig | null;
 /**
  * Capture access to the current request's cache-life slot for work that may
  * finish after the AsyncLocalStorage request scope has returned. RSC response
@@ -76,12 +76,11 @@ declare function _consumeRequestScopedCacheLife(): CacheLifeConfig | null;
  * store from a stream-finalization callback can otherwise read a detached
  * context and lose cacheLife claims made while rendering the body.
  */
-declare function _captureRequestScopedCacheLifeAccessors(): {
+export declare function _captureRequestScopedCacheLifeAccessors(): {
   consume: () => CacheLifeConfig | null;
   peek: () => 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, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, getRegisteredCacheContext, markActionRevalidation, recordUnstableCacheObservation, shouldServeStaleUnstableCacheEntry };
+export declare function recordUnstableCacheObservation(observation: UnstableCacheObservation): void;
+export declare function _peekUnstableCacheObservations(): UnstableCacheObservation[];
+export declare function shouldServeStaleUnstableCacheEntry(): boolean;
+//#endregion

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

@@ -7,10 +7,10 @@ import { markAppPagePropsForUseCache } from "./internal/app-page-props-cache-key
  * life up to the outer cache. Constructed eagerly while the caller is still on
  * the synchronous stack.
  */
-declare class NestedDynamicUseCacheError extends Error {
+export declare class NestedDynamicUseCacheError extends Error {
   constructor();
 }
-type CacheContext = {
+export type CacheContext = {
   /** Tags collected via cacheTag() during execution */
   tags: string[];
   /** Cache life configs collected via cacheLife() — minimum-wins rule applies */
@@ -36,11 +36,11 @@ type CacheContext = {
    */
   invalidDynamicUsageError?: unknown;
 };
-declare const cacheContextStorage: import("node:async_hooks").AsyncLocalStorage<CacheContext>;
+export declare const cacheContextStorage: import("node:async_hooks").AsyncLocalStorage<CacheContext>;
 /**
  * Get the current cache context. Returns null if not inside a "use cache" function.
  */
-declare function getCacheContext(): CacheContext | null;
+export declare function getCacheContext(): CacheContext | null;
 /**
  * Build the shared-cache key for a "use cache" function from its build-scoped
  * identity and serialized arguments.
@@ -51,7 +51,7 @@ declare function getCacheContext(): CacheContext | null;
  *
  * Exported for testing.
  */
-declare function buildUseCacheKey(id: string, keySeed: string | undefined, argsKey?: string): string;
+export declare function buildUseCacheKey(id: string, keySeed: string | undefined, argsKey?: string): string;
 /**
  * Convert an encodeReply result (string | FormData) to a cache key string.
  * For FormData (binary args), produces a deterministic SHA-256 hash over
@@ -60,8 +60,8 @@ declare function buildUseCacheKey(id: string, keySeed: string | undefined, argsK
  *
  * Exported for testing.
  */
-declare function replyToCacheKey(reply: string | FormData): Promise<string>;
-type PrivateCacheState = {
+export declare function replyToCacheKey(reply: string | FormData): Promise<string>;
+export type PrivateCacheState = {
   _privateCache: Map<string, unknown> | null;
 };
 /**
@@ -69,31 +69,25 @@ type PrivateCacheState = {
  * Ensures per-request isolation for "use cache: private" entries
  * on concurrent runtimes.
  */
-declare function runWithPrivateCache<T>(fn: () => Promise<T>): Promise<T>;
-declare function runWithPrivateCache<T>(fn: () => T | Promise<T>): T | Promise<T>;
+export declare function runWithPrivateCache<T>(fn: () => Promise<T>): Promise<T>;
+export declare function runWithPrivateCache<T>(fn: () => T | Promise<T>): T | Promise<T>;
 /**
  * Clear the private per-request cache. Should be called at the start of each request.
  * Only needed when not using runWithPrivateCache() (legacy path).
  */
-declare function clearPrivateCache(): void;
-type RegisterCachedFunctionOptions = {
+export declare function clearPrivateCache(): void;
+export type RegisterCachedFunctionOptions = {
   /**
    * Whether the original function declaration accepts a second argument.
    * Function.length cannot represent default or rest parameters, so the
    * transform records this separately for metadata parent resolution.
    */
   acceptsSecondArgument?: boolean;
-  /**
-   * Internal transform metadata for file-level `"use cache"` default exports
-   * in App Router `page.*` files. Page components receive framework-owned
-   * `{ params, searchParams }` props. React may copy that props object before
-   * invocation, so this invariant must live at the cached function boundary
-   * rather than on the intermediate createElement config object.
-   */
-  appPageDefaultExport?: boolean;
   /** Number of declared arguments supplied by the directive transform. */
   argumentCount?: number;
   decryptCaptures?: (value: unknown) => Promise<unknown[] | undefined>;
+  encodeInvocationArgs?: (args: unknown[]) => Promise<string>;
+  serverReferenceId?: string;
 };
 /**
  * Register a function as a cached function. This is called by the Vite
@@ -104,6 +98,14 @@ type RegisterCachedFunctionOptions = {
  * @param variant - Cache variant: "" (default/shared), "remote", "private"
  * @returns A wrapper function that checks cache before calling the original
  */
-declare function registerCachedFunction<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>, id: string, variant?: string, options?: RegisterCachedFunctionOptions): (...args: TArgs) => Promise<TResult>;
+export declare function registerCachedFunction<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>, id: string, variant?: string, options?: RegisterCachedFunctionOptions): (...args: TArgs) => Promise<TResult>;
+/** Whether a loaded server reference is a transformed `"use cache"` function. */
+export declare function isUseCacheFunction(value: unknown): value is (...args: unknown[]) => Promise<unknown>;
+/**
+ * A thenable (not an array) with own enumerable properties — the
+ * `Object.assign(Promise.resolve(obj), obj)` pattern Next.js params use. The
+ * cache key is built from its fields instead of the promise.
+ */
+export declare function isThenableObject(value: object): value is PromiseLike<unknown>;
 //#endregion
-export { CacheContext, NestedDynamicUseCacheError, PrivateCacheState, RegisterCachedFunctionOptions, buildUseCacheKey, cacheContextStorage, clearPrivateCache, getCacheContext, markAppPagePropsForUseCache, registerCachedFunction, replyToCacheKey, runWithPrivateCache };
+export { markAppPagePropsForUseCache };