cdk-nextjs 0.6.2 → 0.7.0

package/lib/adapter/memory-cache-handler.d.ts

@@ -1,19 +1,21 @@
-import { CacheHandler, CacheHandlerValue, CacheHandlerContext } from "next/dist/server/lib/incremental-cache";
-import { IncrementalCacheValue, GetIncrementalFetchCacheContext, GetIncrementalResponseCacheContext, SetIncrementalResponseCacheContext, SetIncrementalFetchCacheContext } from "next/dist/server/response-cache";
-export interface MemoryCacheHandlerOptions {
-    context: CacheHandlerContext;
-}
-export declare class MemoryCacheHandler implements CacheHandler {
+import { CacheHandlerValue } from "next/dist/server/lib/incremental-cache";
+import { IncrementalCacheValue } from "next/dist/server/response-cache";
+/**
+ * The in-memory layer the orchestrating handler puts in front of
+ * `S3CacheHandler`. Not a `CacheHandler` of its own: it has no tags, since
+ * every hit is checked against the tag markers before it is served.
+ */
+export declare class MemoryCacheHandler {
     private inMemoryCache;
     private debug;
     /**
      * Time to live in milliseconds for cache entries.
      * After this duration, entries expire and are removed from the cache.
      *
-     * **Important**: Due to the distributed nature of compute instances (Lambda functions,
-     * ECS Fargate containers, etc.), this cache only provides eventual consistency across
-     * instances. Tag revalidations will clear the cache on the instance that processes
-     * the revalidation, but other instances may serve stale data until their cache entries expire.
+     * Tag revalidations never clear this cache: the orchestrating handler checks
+     * each memory hit against the tag markers before serving it
+     * (`S3CacheHandler.isRevalidated`), so a revalidated entry is not served from
+     * memory anywhere.
      *
      * @example
      * // Short TTL (5 minutes) - for frequently changing data
@@ -28,8 +30,8 @@ export declare class MemoryCacheHandler implements CacheHandler {
      * ttlMs = 24 * 60 * 60 * 1000;
      *
      * **Why adjust this?**
-     * - Lower values: More cache misses, fresher data, higher S3/DynamoDB costs
-     * - Higher values: Fewer cache misses, better performance, but longer stale data windows
+     * - Lower values: More cache misses, higher S3 costs
+     * - Higher values: Fewer cache misses, more memory held
      *
      * Set via environment variable: `CDK_NEXTJS_MEMORY_CACHE_TTL_MS`
      */
@@ -62,11 +64,18 @@ export declare class MemoryCacheHandler implements CacheHandler {
      * Set via environment variable: `CDK_NEXTJS_MEMORY_CACHE_MAX_ENTRIES`
      */
     private readonly maxEntries;
-    constructor(options: MemoryCacheHandlerOptions);
-    get(cacheKey: string, ctx: GetIncrementalFetchCacheContext | GetIncrementalResponseCacheContext): Promise<CacheHandlerValue | null>;
-    set(cacheKey: string, data: IncrementalCacheValue | null, ctx: SetIncrementalFetchCacheContext | SetIncrementalResponseCacheContext): Promise<void>;
-    revalidateTag(tag: string | string[]): Promise<void>;
-    resetRequestCache(): Promise<void>;
+    constructor();
+    get(cacheKey: string): Promise<CacheHandlerValue | null>;
+    /**
+     * `lastModified` is the time the entry was rendered, for an entry copied in
+     * from a slower layer; a fresh render leaves it out and is stamped now - on
+     * {@link markerClock}, like the S3 copy of the same render. A memory hit is
+     * checked against the tag markers, which are stamped on that clock, and
+     * `Date.now()` drifts from it for as long as the process lives: an entry
+     * stamped ahead of it looked newer than a `revalidateTag` run within the
+     * drift, and was served for the whole memory TTL.
+     */
+    set(cacheKey: string, data: IncrementalCacheValue | null, lastModified?: number): Promise<void>;
     /**
      * Remove all expired cache entries
      */

package/lib/adapter/memory-cache-handler.js

@@ -5,11 +5,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MemoryCacheHandler = void 0;
 /*
-  In-memory cache handler with tag management
+  In-memory cache handler
 */
 /* eslint-disable import/no-extraneous-dependencies */
 const debug_1 = __importDefault(require("debug"));
-const cache_utils_1 = require("./cache-utils");
+const aws_cache_store_1 = require("./aws-cache-store");
+const use_cache_common_1 = require("./use-cache-common");
+/**
+ * The in-memory layer the orchestrating handler puts in front of
+ * `S3CacheHandler`. Not a `CacheHandler` of its own: it has no tags, since
+ * every hit is checked against the tag markers before it is served.
+ */
 class MemoryCacheHandler {
     inMemoryCache = new Map();
     debug = (0, debug_1.default)("cdk-nextjs:cache-handler:memory");
@@ -17,10 +23,10 @@ class MemoryCacheHandler {
      * Time to live in milliseconds for cache entries.
      * After this duration, entries expire and are removed from the cache.
      *
-     * **Important**: Due to the distributed nature of compute instances (Lambda functions,
-     * ECS Fargate containers, etc.), this cache only provides eventual consistency across
-     * instances. Tag revalidations will clear the cache on the instance that processes
-     * the revalidation, but other instances may serve stale data until their cache entries expire.
+     * Tag revalidations never clear this cache: the orchestrating handler checks
+     * each memory hit against the tag markers before serving it
+     * (`S3CacheHandler.isRevalidated`), so a revalidated entry is not served from
+     * memory anywhere.
      *
      * @example
      * // Short TTL (5 minutes) - for frequently changing data
@@ -35,8 +41,8 @@ class MemoryCacheHandler {
      * ttlMs = 24 * 60 * 60 * 1000;
      *
      * **Why adjust this?**
-     * - Lower values: More cache misses, fresher data, higher S3/DynamoDB costs
-     * - Higher values: Fewer cache misses, better performance, but longer stale data windows
+     * - Lower values: More cache misses, higher S3 costs
+     * - Higher values: Fewer cache misses, more memory held
      *
      * Set via environment variable: `CDK_NEXTJS_MEMORY_CACHE_TTL_MS`
      */
@@ -69,26 +75,14 @@ class MemoryCacheHandler {
      * Set via environment variable: `CDK_NEXTJS_MEMORY_CACHE_MAX_ENTRIES`
      */
     maxEntries;
-    constructor(options) {
-        // Read configuration from environment variables with fallback defaults
-        const ttlFromEnv = process.env.CDK_NEXTJS_MEMORY_CACHE_TTL_MS;
-        const maxEntriesFromEnv = process.env.CDK_NEXTJS_MEMORY_CACHE_MAX_ENTRIES;
-        // Default to 1 hour TTL and 1000 max entries
-        this.ttlMs = ttlFromEnv ? parseInt(ttlFromEnv, 10) : 60 * 60 * 1000; // 1 hour
-        this.maxEntries = maxEntriesFromEnv
-            ? parseInt(maxEntriesFromEnv, 10)
-            : 1000;
-        // Log the options for debugging (optional usage to avoid unused parameter warning)
-        if (options.context.dev) {
-            this.debug("MemoryCacheHandler initialized in development mode");
-        }
+    constructor() {
+        // Default to 1 hour TTL and 1000 max entries. A value that is not a
+        // number falls back too: as NaN, nothing would ever expire or be evicted.
+        this.ttlMs = (0, use_cache_common_1.numberFromEnv)("CDK_NEXTJS_MEMORY_CACHE_TTL_MS", 60 * 60 * 1000);
+        this.maxEntries = (0, use_cache_common_1.numberFromEnv)("CDK_NEXTJS_MEMORY_CACHE_MAX_ENTRIES", 1000);
         this.debug(`TTL: ${this.ttlMs / 1000}s, Max entries: ${this.maxEntries}`);
     }
-    async get(cacheKey, ctx) {
-        // Log context for debugging (optional usage to avoid unused parameter warning)
-        if (ctx.kind) {
-            this.debug(`Memory cache get operation for ${cacheKey} with kind: ${ctx.kind}`);
-        }
+    async get(cacheKey) {
         // Check in-memory cache
         const memoryEntry = this.inMemoryCache.get(cacheKey);
         if (memoryEntry) {
@@ -107,7 +101,16 @@ class MemoryCacheHandler {
         this.debug(`MEMORY CACHE MISS: ${cacheKey}`);
         return null;
     }
-    async set(cacheKey, data, ctx) {
+    /**
+     * `lastModified` is the time the entry was rendered, for an entry copied in
+     * from a slower layer; a fresh render leaves it out and is stamped now - on
+     * {@link markerClock}, like the S3 copy of the same render. A memory hit is
+     * checked against the tag markers, which are stamped on that clock, and
+     * `Date.now()` drifts from it for as long as the process lives: an entry
+     * stamped ahead of it looked newer than a `revalidateTag` run within the
+     * drift, and was served for the whole memory TTL.
+     */
+    async set(cacheKey, data, lastModified) {
         if (!data) {
             // Delete from memory cache
             this.debug(`MEMORY CACHE DELETE: ${cacheKey}`);
@@ -118,13 +121,12 @@ class MemoryCacheHandler {
         this.debug(`MEMORY CACHE SET: ${cacheKey} (${data.kind})`);
         // Store in memory cache with proper CacheHandlerValue structure
         const cacheHandlerValue = {
-            lastModified: Date.now(),
+            lastModified: lastModified ?? (0, aws_cache_store_1.markerClock)(),
             value: data,
         };
         const entry = {
             value: cacheHandlerValue,
             expiresAt: Date.now() + this.ttlMs,
-            tags: (0, cache_utils_1.getTags)(ctx) || [],
         };
         // Clean up expired entries before adding new one
         this.cleanupExpired();
@@ -136,26 +138,6 @@ class MemoryCacheHandler {
         this.inMemoryCache.set(cacheKey, entry);
         this.debug(`Cache entries: ${this.inMemoryCache.size}/${this.maxEntries}`);
     }
-    async revalidateTag(tag) {
-        const tags = Array.isArray(tag) ? tag : [tag];
-        let invalidatedCount = 0;
-        for (const [key, entry] of this.inMemoryCache.entries()) {
-            if (entry.tags.some((entryTag) => tags.includes(entryTag))) {
-                this.inMemoryCache.delete(key);
-                invalidatedCount++;
-            }
-        }
-        this.debug(`MEMORY REVALIDATE TAGS: [${tags.join(", ")}] removed ${invalidatedCount} entries`);
-        // Note: this only clears the cache on the instance handling this request.
-        // In distributed environments (multiple Lambda functions or Fargate containers),
-        // other instances continue serving their own memory-cached entries until those
-        // entries expire (ttlMs). Set CDK_NEXTJS_MEMORY_CACHE_TTL_MS=0 to disable the
-        // memory cache entirely if strong cross-instance consistency is required.
-    }
-    async resetRequestCache() {
-        // Clear in-memory cache
-        this.inMemoryCache.clear();
-    }
     /**
      * Remove all expired cache entries
      */
@@ -192,4 +174,4 @@ class MemoryCacheHandler {
     }
 }
 exports.MemoryCacheHandler = MemoryCacheHandler;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"memory-cache-handler.js","sourceRoot":"","sources":["../../src/adapter/memory-cache-handler.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n  In-memory cache handler with tag management\n*/\n/* eslint-disable import/no-extraneous-dependencies */\nimport getDebug from \"debug\";\nimport {\n  CacheHandler,\n  CacheHandlerValue,\n  CacheHandlerContext,\n} from \"next/dist/server/lib/incremental-cache\";\nimport {\n  IncrementalCacheValue,\n  GetIncrementalFetchCacheContext,\n  GetIncrementalResponseCacheContext,\n  SetIncrementalResponseCacheContext,\n  SetIncrementalFetchCacheContext,\n} from \"next/dist/server/response-cache\";\nimport { getTags } from \"./cache-utils\";\n\ninterface MemoryCacheEntry {\n  value: CacheHandlerValue;\n  expiresAt: number; // Timestamp in milliseconds\n  tags: string[];\n}\n\nexport interface MemoryCacheHandlerOptions {\n  context: CacheHandlerContext;\n}\n\nexport class MemoryCacheHandler implements CacheHandler {\n  private inMemoryCache: Map<string, MemoryCacheEntry> = new Map();\n  private debug = getDebug(\"cdk-nextjs:cache-handler:memory\");\n\n  /**\n   * Time to live in milliseconds for cache entries.\n   * After this duration, entries expire and are removed from the cache.\n   *\n   * **Important**: Due to the distributed nature of compute instances (Lambda functions,\n   * ECS Fargate containers, etc.), this cache only provides eventual consistency across\n   * instances. Tag revalidations will clear the cache on the instance that processes\n   * the revalidation, but other instances may serve stale data until their cache entries expire.\n   *\n   * @example\n   * // Short TTL (5 minutes) - for frequently changing data\n   * ttlMs = 5 * 60 * 1000;\n   *\n   * @example\n   * // Medium TTL (1 hour) - balanced between freshness and performance\n   * ttlMs = 60 * 60 * 1000;\n   *\n   * @example\n   * // Long TTL (24 hours) - for mostly static content\n   * ttlMs = 24 * 60 * 60 * 1000;\n   *\n   * **Why adjust this?**\n   * - Lower values: More cache misses, fresher data, higher S3/DynamoDB costs\n   * - Higher values: Fewer cache misses, better performance, but longer stale data windows\n   *\n   * Set via environment variable: `CDK_NEXTJS_MEMORY_CACHE_TTL_MS`\n   */\n  private readonly ttlMs: number;\n\n  /**\n   * Maximum number of cache entries to store in memory.\n   * When this limit is reached, the least recently used (LRU) entry is evicted.\n   *\n   * @example\n   * // Small cache (100 entries) - minimal memory footprint for simple apps\n   * maxEntries = 100;\n   *\n   * @example\n   * // Medium cache (1000 entries) - good balance for typical applications\n   * maxEntries = 1000;\n   *\n   * @example\n   * // Large cache (10000 entries) - for high-traffic apps with many unique pages\n   * maxEntries = 10000;\n   *\n   * **Why adjust this?**\n   * - Lower values: Less memory usage, more cache evictions\n   * - Higher values: More memory usage, fewer cache evictions, better hit rates\n   *\n   * **Memory considerations**: Each entry stores the full cache value (HTML, JSON, etc.)\n   * A typical page cache might be 10-100KB, so 1000 entries ≈ 10-100MB of memory.\n   * Consider your compute environment's memory limits (Lambda: 128MB-10GB, Fargate: 512MB-30GB)\n   * and size accordingly.\n   *\n   * Set via environment variable: `CDK_NEXTJS_MEMORY_CACHE_MAX_ENTRIES`\n   */\n  private readonly maxEntries: number;\n\n  constructor(options: MemoryCacheHandlerOptions) {\n    // Read configuration from environment variables with fallback defaults\n    const ttlFromEnv = process.env.CDK_NEXTJS_MEMORY_CACHE_TTL_MS;\n    const maxEntriesFromEnv = process.env.CDK_NEXTJS_MEMORY_CACHE_MAX_ENTRIES;\n\n    // Default to 1 hour TTL and 1000 max entries\n    this.ttlMs = ttlFromEnv ? parseInt(ttlFromEnv, 10) : 60 * 60 * 1000; // 1 hour\n    this.maxEntries = maxEntriesFromEnv\n      ? parseInt(maxEntriesFromEnv, 10)\n      : 1000;\n\n    // Log the options for debugging (optional usage to avoid unused parameter warning)\n    if (options.context.dev) {\n      this.debug(\"MemoryCacheHandler initialized in development mode\");\n    }\n    this.debug(`TTL: ${this.ttlMs / 1000}s, Max entries: ${this.maxEntries}`);\n  }\n\n  async get(\n    cacheKey: string,\n    ctx: GetIncrementalFetchCacheContext | GetIncrementalResponseCacheContext,\n  ): Promise<CacheHandlerValue | null> {\n    // Log context for debugging (optional usage to avoid unused parameter warning)\n    if (ctx.kind) {\n      this.debug(\n        `Memory cache get operation for ${cacheKey} with kind: ${ctx.kind}`,\n      );\n    }\n\n    // Check in-memory cache\n    const memoryEntry = this.inMemoryCache.get(cacheKey);\n    if (memoryEntry) {\n      // Check if expired\n      if (Date.now() > memoryEntry.expiresAt) {\n        this.debug(`MEMORY CACHE EXPIRED: ${cacheKey}`);\n        this.inMemoryCache.delete(cacheKey);\n        return null;\n      }\n\n      // Move to end (most recently used) by deleting and re-inserting\n      this.inMemoryCache.delete(cacheKey);\n      this.inMemoryCache.set(cacheKey, memoryEntry);\n\n      this.debug(`MEMORY CACHE HIT: ${cacheKey}`);\n      return memoryEntry.value;\n    }\n\n    this.debug(`MEMORY CACHE MISS: ${cacheKey}`);\n    return null;\n  }\n\n  async set(\n    cacheKey: string,\n    data: IncrementalCacheValue | null,\n    ctx: SetIncrementalFetchCacheContext | SetIncrementalResponseCacheContext,\n  ): Promise<void> {\n    if (!data) {\n      // Delete from memory cache\n      this.debug(`MEMORY CACHE DELETE: ${cacheKey}`);\n      this.inMemoryCache.delete(cacheKey);\n      return;\n    }\n\n    // Debug logging for memory cache set\n    this.debug(`MEMORY CACHE SET: ${cacheKey} (${data.kind})`);\n\n    // Store in memory cache with proper CacheHandlerValue structure\n    const cacheHandlerValue: CacheHandlerValue = {\n      lastModified: Date.now(),\n      value: data,\n    };\n\n    const entry: MemoryCacheEntry = {\n      value: cacheHandlerValue,\n      expiresAt: Date.now() + this.ttlMs,\n      tags: getTags(ctx) || [],\n    };\n\n    // Clean up expired entries before adding new one\n    this.cleanupExpired();\n\n    // If we're at max capacity, evict oldest entry\n    if (this.inMemoryCache.size >= this.maxEntries) {\n      this.evictOldest();\n    }\n\n    // Add new entry\n    this.inMemoryCache.set(cacheKey, entry);\n\n    this.debug(`Cache entries: ${this.inMemoryCache.size}/${this.maxEntries}`);\n  }\n\n  async revalidateTag(tag: string | string[]): Promise<void> {\n    const tags = Array.isArray(tag) ? tag : [tag];\n    let invalidatedCount = 0;\n\n    for (const [key, entry] of this.inMemoryCache.entries()) {\n      if (entry.tags.some((entryTag) => tags.includes(entryTag))) {\n        this.inMemoryCache.delete(key);\n        invalidatedCount++;\n      }\n    }\n\n    this.debug(\n      `MEMORY REVALIDATE TAGS: [${tags.join(\", \")}] removed ${invalidatedCount} entries`,\n    );\n\n    // Note: this only clears the cache on the instance handling this request.\n    // In distributed environments (multiple Lambda functions or Fargate containers),\n    // other instances continue serving their own memory-cached entries until those\n    // entries expire (ttlMs). Set CDK_NEXTJS_MEMORY_CACHE_TTL_MS=0 to disable the\n    // memory cache entirely if strong cross-instance consistency is required.\n  }\n\n  async resetRequestCache(): Promise<void> {\n    // Clear in-memory cache\n    this.inMemoryCache.clear();\n  }\n\n  /**\n   * Remove all expired cache entries\n   */\n  private cleanupExpired(): void {\n    const now = Date.now();\n    let expiredCount = 0;\n\n    for (const [key, entry] of this.inMemoryCache.entries()) {\n      if (now > entry.expiresAt) {\n        this.inMemoryCache.delete(key);\n        expiredCount++;\n      }\n    }\n\n    if (expiredCount > 0) {\n      this.debug(`Cleaned up ${expiredCount} expired entries`);\n    }\n  }\n\n  /**\n   * Evict the oldest (least recently used) cache entry\n   * Map maintains insertion order, so first entry is oldest\n   */\n  private evictOldest(): void {\n    const firstKey = this.inMemoryCache.keys().next().value;\n    if (firstKey) {\n      this.debug(`MAX CAPACITY EVICT (LRU): ${firstKey}`);\n      this.inMemoryCache.delete(firstKey);\n    }\n  }\n\n  // Public methods for testing and monitoring\n  public getCacheSize(): number {\n    return this.inMemoryCache.size;\n  }\n\n  public clearCache(): void {\n    this.inMemoryCache.clear();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"memory-cache-handler.js","sourceRoot":"","sources":["../../src/adapter/memory-cache-handler.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n  In-memory cache handler\n*/\n/* eslint-disable import/no-extraneous-dependencies */\nimport getDebug from \"debug\";\nimport { CacheHandlerValue } from \"next/dist/server/lib/incremental-cache\";\nimport { IncrementalCacheValue } from \"next/dist/server/response-cache\";\nimport { markerClock } from \"./aws-cache-store\";\nimport { numberFromEnv } from \"./use-cache-common\";\n\ninterface MemoryCacheEntry {\n  value: CacheHandlerValue;\n  expiresAt: number; // Timestamp in milliseconds\n}\n\n/**\n * The in-memory layer the orchestrating handler puts in front of\n * `S3CacheHandler`. Not a `CacheHandler` of its own: it has no tags, since\n * every hit is checked against the tag markers before it is served.\n */\nexport class MemoryCacheHandler {\n  private inMemoryCache: Map<string, MemoryCacheEntry> = new Map();\n  private debug = getDebug(\"cdk-nextjs:cache-handler:memory\");\n\n  /**\n   * Time to live in milliseconds for cache entries.\n   * After this duration, entries expire and are removed from the cache.\n   *\n   * Tag revalidations never clear this cache: the orchestrating handler checks\n   * each memory hit against the tag markers before serving it\n   * (`S3CacheHandler.isRevalidated`), so a revalidated entry is not served from\n   * memory anywhere.\n   *\n   * @example\n   * // Short TTL (5 minutes) - for frequently changing data\n   * ttlMs = 5 * 60 * 1000;\n   *\n   * @example\n   * // Medium TTL (1 hour) - balanced between freshness and performance\n   * ttlMs = 60 * 60 * 1000;\n   *\n   * @example\n   * // Long TTL (24 hours) - for mostly static content\n   * ttlMs = 24 * 60 * 60 * 1000;\n   *\n   * **Why adjust this?**\n   * - Lower values: More cache misses, higher S3 costs\n   * - Higher values: Fewer cache misses, more memory held\n   *\n   * Set via environment variable: `CDK_NEXTJS_MEMORY_CACHE_TTL_MS`\n   */\n  private readonly ttlMs: number;\n\n  /**\n   * Maximum number of cache entries to store in memory.\n   * When this limit is reached, the least recently used (LRU) entry is evicted.\n   *\n   * @example\n   * // Small cache (100 entries) - minimal memory footprint for simple apps\n   * maxEntries = 100;\n   *\n   * @example\n   * // Medium cache (1000 entries) - good balance for typical applications\n   * maxEntries = 1000;\n   *\n   * @example\n   * // Large cache (10000 entries) - for high-traffic apps with many unique pages\n   * maxEntries = 10000;\n   *\n   * **Why adjust this?**\n   * - Lower values: Less memory usage, more cache evictions\n   * - Higher values: More memory usage, fewer cache evictions, better hit rates\n   *\n   * **Memory considerations**: Each entry stores the full cache value (HTML, JSON, etc.)\n   * A typical page cache might be 10-100KB, so 1000 entries ≈ 10-100MB of memory.\n   * Consider your compute environment's memory limits (Lambda: 128MB-10GB, Fargate: 512MB-30GB)\n   * and size accordingly.\n   *\n   * Set via environment variable: `CDK_NEXTJS_MEMORY_CACHE_MAX_ENTRIES`\n   */\n  private readonly maxEntries: number;\n\n  constructor() {\n    // Default to 1 hour TTL and 1000 max entries. A value that is not a\n    // number falls back too: as NaN, nothing would ever expire or be evicted.\n    this.ttlMs = numberFromEnv(\n      \"CDK_NEXTJS_MEMORY_CACHE_TTL_MS\",\n      60 * 60 * 1000,\n    );\n    this.maxEntries = numberFromEnv(\n      \"CDK_NEXTJS_MEMORY_CACHE_MAX_ENTRIES\",\n      1000,\n    );\n\n    this.debug(`TTL: ${this.ttlMs / 1000}s, Max entries: ${this.maxEntries}`);\n  }\n\n  async get(cacheKey: string): Promise<CacheHandlerValue | null> {\n    // Check in-memory cache\n    const memoryEntry = this.inMemoryCache.get(cacheKey);\n    if (memoryEntry) {\n      // Check if expired\n      if (Date.now() > memoryEntry.expiresAt) {\n        this.debug(`MEMORY CACHE EXPIRED: ${cacheKey}`);\n        this.inMemoryCache.delete(cacheKey);\n        return null;\n      }\n\n      // Move to end (most recently used) by deleting and re-inserting\n      this.inMemoryCache.delete(cacheKey);\n      this.inMemoryCache.set(cacheKey, memoryEntry);\n\n      this.debug(`MEMORY CACHE HIT: ${cacheKey}`);\n      return memoryEntry.value;\n    }\n\n    this.debug(`MEMORY CACHE MISS: ${cacheKey}`);\n    return null;\n  }\n\n  /**\n   * `lastModified` is the time the entry was rendered, for an entry copied in\n   * from a slower layer; a fresh render leaves it out and is stamped now - on\n   * {@link markerClock}, like the S3 copy of the same render. A memory hit is\n   * checked against the tag markers, which are stamped on that clock, and\n   * `Date.now()` drifts from it for as long as the process lives: an entry\n   * stamped ahead of it looked newer than a `revalidateTag` run within the\n   * drift, and was served for the whole memory TTL.\n   */\n  async set(\n    cacheKey: string,\n    data: IncrementalCacheValue | null,\n    lastModified?: number,\n  ): Promise<void> {\n    if (!data) {\n      // Delete from memory cache\n      this.debug(`MEMORY CACHE DELETE: ${cacheKey}`);\n      this.inMemoryCache.delete(cacheKey);\n      return;\n    }\n\n    // Debug logging for memory cache set\n    this.debug(`MEMORY CACHE SET: ${cacheKey} (${data.kind})`);\n\n    // Store in memory cache with proper CacheHandlerValue structure\n    const cacheHandlerValue: CacheHandlerValue = {\n      lastModified: lastModified ?? markerClock(),\n      value: data,\n    };\n\n    const entry: MemoryCacheEntry = {\n      value: cacheHandlerValue,\n      expiresAt: Date.now() + this.ttlMs,\n    };\n\n    // Clean up expired entries before adding new one\n    this.cleanupExpired();\n\n    // If we're at max capacity, evict oldest entry\n    if (this.inMemoryCache.size >= this.maxEntries) {\n      this.evictOldest();\n    }\n\n    // Add new entry\n    this.inMemoryCache.set(cacheKey, entry);\n\n    this.debug(`Cache entries: ${this.inMemoryCache.size}/${this.maxEntries}`);\n  }\n\n  /**\n   * Remove all expired cache entries\n   */\n  private cleanupExpired(): void {\n    const now = Date.now();\n    let expiredCount = 0;\n\n    for (const [key, entry] of this.inMemoryCache.entries()) {\n      if (now > entry.expiresAt) {\n        this.inMemoryCache.delete(key);\n        expiredCount++;\n      }\n    }\n\n    if (expiredCount > 0) {\n      this.debug(`Cleaned up ${expiredCount} expired entries`);\n    }\n  }\n\n  /**\n   * Evict the oldest (least recently used) cache entry\n   * Map maintains insertion order, so first entry is oldest\n   */\n  private evictOldest(): void {\n    const firstKey = this.inMemoryCache.keys().next().value;\n    if (firstKey) {\n      this.debug(`MAX CAPACITY EVICT (LRU): ${firstKey}`);\n      this.inMemoryCache.delete(firstKey);\n    }\n  }\n\n  // Public methods for testing and monitoring\n  public getCacheSize(): number {\n    return this.inMemoryCache.size;\n  }\n\n  public clearCache(): void {\n    this.inMemoryCache.clear();\n  }\n}\n"]}

package/lib/adapter/memory-cache-handler.test.js

@@ -3,22 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const memory_cache_handler_1 = require("./memory-cache-handler");
 describe("MemoryCacheHandler", () => {
     let handler;
-    let mockContext;
     beforeEach(() => {
-        mockContext = { dev: false };
-        handler = new memory_cache_handler_1.MemoryCacheHandler({
-            context: mockContext,
-        });
+        handler = new memory_cache_handler_1.MemoryCacheHandler();
     });
     afterEach(() => {
         handler.clearCache();
     });
     describe("get", () => {
         it("should return null for non-existent cache key", async () => {
-            const result = await handler.get("non-existent", {
-                kind: "APP_PAGE" /* IncrementalCacheKind.APP_PAGE */,
-                isFallback: false,
-            });
+            const result = await handler.get("non-existent");
             expect(result).toBeNull();
         });
         it("should return cached value from memory", async () => {
@@ -31,13 +24,8 @@ describe("MemoryCacheHandler", () => {
                 segmentData: undefined,
                 status: undefined,
             };
-            await handler.set("test-key", testData, {
-                fetchCache: true,
-            });
-            const result = await handler.get("test-key", {
-                kind: "APP_PAGE" /* IncrementalCacheKind.APP_PAGE */,
-                isFallback: false,
-            });
+            await handler.set("test-key", testData);
+            const result = await handler.get("test-key");
             expect(result).not.toBeNull();
             expect(result?.value).toEqual(testData);
         });
@@ -53,91 +41,123 @@ describe("MemoryCacheHandler", () => {
                 segmentData: undefined,
                 status: undefined,
             };
-            await handler.set("set-key", testData, {
-                fetchCache: true,
-            });
+            await handler.set("set-key", testData);
             expect(handler.getCacheSize()).toBe(1);
-            const result = await handler.get("set-key", {
-                kind: "APP_PAGE" /* IncrementalCacheKind.APP_PAGE */,
-                isFallback: false,
-            });
+            const result = await handler.get("set-key");
             expect(result?.value).toEqual(testData);
         });
+        it("keeps the lastModified an entry copied from a slower layer was rendered at", async () => {
+            // Stamping the time of the copy made an entry due for regeneration, or
+            // one a soft `revalidateTag` had made stale, look freshly rendered.
+            const testData = {
+                kind: "APP_PAGE" /* CachedRouteKind.APP_PAGE */,
+                html: "<html>promoted</html>",
+                rscData: undefined,
+                headers: undefined,
+                postponed: undefined,
+                segmentData: undefined,
+                status: undefined,
+            };
+            const renderedAt = Date.now() - 60_000;
+            await handler.set("promoted", testData, renderedAt);
+            expect(await handler.get("promoted")).toEqual({
+                lastModified: renderedAt,
+                value: testData,
+            });
+        });
+        it("stamps a fresh render on the tag markers' clock, not Date.now()", async () => {
+            // A memory hit is judged against tag markers stamped with `markerClock`.
+            // With `Date.now()` running ahead of it, a `revalidateTag` inside the
+            // drift left the entry looking newer than the marker, and it was served
+            // for the whole memory TTL.
+            const markerNow = 1_000_000;
+            jest.spyOn(performance, "now").mockReturnValue(markerNow);
+            jest
+                .spyOn(Date, "now")
+                .mockReturnValue(performance.timeOrigin + 5 * 60_000 + markerNow);
+            try {
+                await handler.set("fresh", {
+                    kind: "APP_PAGE" /* CachedRouteKind.APP_PAGE */,
+                    html: "<html>fresh</html>",
+                    rscData: undefined,
+                    headers: undefined,
+                    postponed: undefined,
+                    segmentData: undefined,
+                    status: undefined,
+                });
+                const entry = await handler.get("fresh");
+                expect(entry?.lastModified).toBe(performance.timeOrigin + markerNow);
+            }
+            finally {
+                jest.restoreAllMocks();
+            }
+        });
     });
-    describe("revalidateTag", () => {
-        const testData = {
+    describe("bounds", () => {
+        const page = (html) => ({
             kind: "APP_PAGE" /* CachedRouteKind.APP_PAGE */,
-            html: "<html>tagged</html>",
+            html,
             rscData: undefined,
             headers: undefined,
             postponed: undefined,
             segmentData: undefined,
             status: undefined,
-        };
-        it("should remove entries tagged with the revalidated tag", async () => {
-            await handler.set("tagged-key", testData, {
-                fetchCache: true,
-                tags: ["collection"],
-            });
-            await handler.revalidateTag("collection");
-            const result = await handler.get("tagged-key", {
-                kind: "APP_PAGE" /* IncrementalCacheKind.APP_PAGE */,
-                isFallback: false,
-            });
-            expect(result).toBeNull();
-            expect(handler.getCacheSize()).toBe(0);
         });
-        it("should not remove entries with unrelated tags", async () => {
-            await handler.set("unrelated-key", testData, {
-                fetchCache: true,
-                tags: ["other-tag"],
-            });
-            await handler.revalidateTag("collection");
-            const result = await handler.get("unrelated-key", {
-                kind: "APP_PAGE" /* IncrementalCacheKind.APP_PAGE */,
-                isFallback: false,
-            });
-            expect(result).not.toBeNull();
-            expect(handler.getCacheSize()).toBe(1);
+        const env = process.env;
+        beforeEach(() => {
+            process.env = { ...env };
         });
-        it("should accept an array of tags and remove any matching entries", async () => {
-            await handler.set("key-a", testData, {
-                fetchCache: true,
-                tags: ["tag-a"],
-            });
-            await handler.set("key-b", testData, {
-                fetchCache: true,
-                tags: ["tag-b"],
-            });
-            await handler.revalidateTag(["tag-a", "tag-b"]);
+        afterEach(() => {
+            process.env = env;
+            jest.restoreAllMocks();
+        });
+        it("drops an entry past its TTL on read", async () => {
+            process.env.CDK_NEXTJS_MEMORY_CACHE_TTL_MS = "1000";
+            const clock = jest.spyOn(Date, "now").mockReturnValue(1_000_000);
+            handler = new memory_cache_handler_1.MemoryCacheHandler();
+            await handler.set("a", page("a"));
+            clock.mockReturnValue(1_001_000);
+            expect(await handler.get("a")).not.toBeNull();
+            clock.mockReturnValue(1_001_001);
+            expect(await handler.get("a")).toBeNull();
             expect(handler.getCacheSize()).toBe(0);
         });
-        it("should be a no-op when no entries match the tag", async () => {
-            await handler.set("untagged-key", testData, {
-                fetchCache: true,
-            });
-            await expect(handler.revalidateTag("nonexistent-tag")).resolves.not.toThrow();
+        it("clears every expired entry on the next write", async () => {
+            process.env.CDK_NEXTJS_MEMORY_CACHE_TTL_MS = "1000";
+            const clock = jest.spyOn(Date, "now").mockReturnValue(1_000_000);
+            handler = new memory_cache_handler_1.MemoryCacheHandler();
+            await handler.set("a", page("a"));
+            await handler.set("b", page("b"));
+            clock.mockReturnValue(1_002_000);
+            await handler.set("c", page("c"));
             expect(handler.getCacheSize()).toBe(1);
         });
-    });
-    describe("resetRequestCache", () => {
-        it("should clear all caches", async () => {
-            const testData = {
-                kind: "APP_PAGE" /* CachedRouteKind.APP_PAGE */,
-                html: "<html>reset test</html>",
-                rscData: undefined,
-                headers: undefined,
-                postponed: undefined,
-                segmentData: undefined,
-                status: undefined,
-            };
-            await handler.set("reset-key", testData, {
-                fetchCache: true,
-            });
-            expect(handler.getCacheSize()).toBe(1);
-            await handler.resetRequestCache();
-            expect(handler.getCacheSize()).toBe(0);
+        it("evicts the least recently used entry at the limit", async () => {
+            process.env.CDK_NEXTJS_MEMORY_CACHE_MAX_ENTRIES = "2";
+            handler = new memory_cache_handler_1.MemoryCacheHandler();
+            await handler.set("a", page("a"));
+            await handler.set("b", page("b"));
+            // A read makes `a` the most recently used.
+            await handler.get("a");
+            await handler.set("c", page("c"));
+            expect(handler.getCacheSize()).toBe(2);
+            expect(await handler.get("b")).toBeNull();
+            expect(await handler.get("a")).not.toBeNull();
+            expect(await handler.get("c")).not.toBeNull();
+        });
+        it("falls back to the defaults for values that are not numbers", async () => {
+            // As NaN, nothing expired and nothing was evicted: an unbounded map.
+            process.env.CDK_NEXTJS_MEMORY_CACHE_TTL_MS = "abc";
+            process.env.CDK_NEXTJS_MEMORY_CACHE_MAX_ENTRIES = "abc";
+            const clock = jest.spyOn(Date, "now").mockReturnValue(1_000_000);
+            handler = new memory_cache_handler_1.MemoryCacheHandler();
+            for (let i = 0; i <= 1000; i++) {
+                await handler.set(`k${i}`, page("x"));
+            }
+            expect(handler.getCacheSize()).toBe(1000);
+            clock.mockReturnValue(1_000_000 + 60 * 60 * 1000 + 1);
+            expect(await handler.get("k1000")).toBeNull();
         });
     });
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"memory-cache-handler.test.js","sourceRoot":"","sources":["../../src/adapter/memory-cache-handler.test.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\nimport { CacheHandlerContext } from \"next/dist/server/lib/incremental-cache\";\nimport {\n  IncrementalCacheValue,\n  CachedRouteKind,\n  IncrementalCacheKind,\n} from \"next/dist/server/response-cache\";\nimport { MemoryCacheHandler } from \"./memory-cache-handler\";\n\ndescribe(\"MemoryCacheHandler\", () => {\n  let handler: MemoryCacheHandler;\n  let mockContext: CacheHandlerContext;\n\n  beforeEach(() => {\n    mockContext = { dev: false } as CacheHandlerContext;\n\n    handler = new MemoryCacheHandler({\n      context: mockContext,\n    });\n  });\n\n  afterEach(() => {\n    handler.clearCache();\n  });\n\n  describe(\"get\", () => {\n    it(\"should return null for non-existent cache key\", async () => {\n      const result = await handler.get(\"non-existent\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n      expect(result).toBeNull();\n    });\n\n    it(\"should return cached value from memory\", async () => {\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>test</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n\n      await handler.set(\"test-key\", testData, {\n        fetchCache: true as const,\n      });\n      const result = await handler.get(\"test-key\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n\n      expect(result).not.toBeNull();\n      expect(result?.value).toEqual(testData);\n    });\n  });\n\n  describe(\"set\", () => {\n    it(\"should store value in memory cache\", async () => {\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>set test</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n\n      await handler.set(\"set-key\", testData, {\n        fetchCache: true as const,\n      });\n\n      expect(handler.getCacheSize()).toBe(1);\n\n      const result = await handler.get(\"set-key\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n      expect(result?.value).toEqual(testData);\n    });\n  });\n\n  describe(\"revalidateTag\", () => {\n    const testData: IncrementalCacheValue = {\n      kind: CachedRouteKind.APP_PAGE,\n      html: \"<html>tagged</html>\",\n      rscData: undefined,\n      headers: undefined,\n      postponed: undefined,\n      segmentData: undefined,\n      status: undefined,\n    };\n\n    it(\"should remove entries tagged with the revalidated tag\", async () => {\n      await handler.set(\"tagged-key\", testData, {\n        fetchCache: true as const,\n        tags: [\"collection\"],\n      });\n\n      await handler.revalidateTag(\"collection\");\n\n      const result = await handler.get(\"tagged-key\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n      expect(result).toBeNull();\n      expect(handler.getCacheSize()).toBe(0);\n    });\n\n    it(\"should not remove entries with unrelated tags\", async () => {\n      await handler.set(\"unrelated-key\", testData, {\n        fetchCache: true as const,\n        tags: [\"other-tag\"],\n      });\n\n      await handler.revalidateTag(\"collection\");\n\n      const result = await handler.get(\"unrelated-key\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n      expect(result).not.toBeNull();\n      expect(handler.getCacheSize()).toBe(1);\n    });\n\n    it(\"should accept an array of tags and remove any matching entries\", async () => {\n      await handler.set(\"key-a\", testData, {\n        fetchCache: true as const,\n        tags: [\"tag-a\"],\n      });\n      await handler.set(\"key-b\", testData, {\n        fetchCache: true as const,\n        tags: [\"tag-b\"],\n      });\n\n      await handler.revalidateTag([\"tag-a\", \"tag-b\"]);\n\n      expect(handler.getCacheSize()).toBe(0);\n    });\n\n    it(\"should be a no-op when no entries match the tag\", async () => {\n      await handler.set(\"untagged-key\", testData, {\n        fetchCache: true as const,\n      });\n\n      await expect(\n        handler.revalidateTag(\"nonexistent-tag\"),\n      ).resolves.not.toThrow();\n      expect(handler.getCacheSize()).toBe(1);\n    });\n  });\n\n  describe(\"resetRequestCache\", () => {\n    it(\"should clear all caches\", async () => {\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>reset test</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n\n      await handler.set(\"reset-key\", testData, {\n        fetchCache: true as const,\n      });\n\n      expect(handler.getCacheSize()).toBe(1);\n\n      await handler.resetRequestCache();\n\n      expect(handler.getCacheSize()).toBe(0);\n    });\n  });\n});\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"memory-cache-handler.test.js","sourceRoot":"","sources":["../../src/adapter/memory-cache-handler.test.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\nimport {\n  IncrementalCacheValue,\n  CachedRouteKind,\n} from \"next/dist/server/response-cache\";\nimport { MemoryCacheHandler } from \"./memory-cache-handler\";\n\ndescribe(\"MemoryCacheHandler\", () => {\n  let handler: MemoryCacheHandler;\n\n  beforeEach(() => {\n    handler = new MemoryCacheHandler();\n  });\n\n  afterEach(() => {\n    handler.clearCache();\n  });\n\n  describe(\"get\", () => {\n    it(\"should return null for non-existent cache key\", async () => {\n      const result = await handler.get(\"non-existent\");\n      expect(result).toBeNull();\n    });\n\n    it(\"should return cached value from memory\", async () => {\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>test</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n\n      await handler.set(\"test-key\", testData);\n      const result = await handler.get(\"test-key\");\n\n      expect(result).not.toBeNull();\n      expect(result?.value).toEqual(testData);\n    });\n  });\n\n  describe(\"set\", () => {\n    it(\"should store value in memory cache\", async () => {\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>set test</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n\n      await handler.set(\"set-key\", testData);\n\n      expect(handler.getCacheSize()).toBe(1);\n\n      const result = await handler.get(\"set-key\");\n      expect(result?.value).toEqual(testData);\n    });\n\n    it(\"keeps the lastModified an entry copied from a slower layer was rendered at\", async () => {\n      // Stamping the time of the copy made an entry due for regeneration, or\n      // one a soft `revalidateTag` had made stale, look freshly rendered.\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>promoted</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n      const renderedAt = Date.now() - 60_000;\n\n      await handler.set(\"promoted\", testData, renderedAt);\n\n      expect(await handler.get(\"promoted\")).toEqual({\n        lastModified: renderedAt,\n        value: testData,\n      });\n    });\n\n    it(\"stamps a fresh render on the tag markers' clock, not Date.now()\", async () => {\n      // A memory hit is judged against tag markers stamped with `markerClock`.\n      // With `Date.now()` running ahead of it, a `revalidateTag` inside the\n      // drift left the entry looking newer than the marker, and it was served\n      // for the whole memory TTL.\n      const markerNow = 1_000_000;\n      jest.spyOn(performance, \"now\").mockReturnValue(markerNow);\n      jest\n        .spyOn(Date, \"now\")\n        .mockReturnValue(performance.timeOrigin + 5 * 60_000 + markerNow);\n      try {\n        await handler.set(\"fresh\", {\n          kind: CachedRouteKind.APP_PAGE,\n          html: \"<html>fresh</html>\",\n          rscData: undefined,\n          headers: undefined,\n          postponed: undefined,\n          segmentData: undefined,\n          status: undefined,\n        });\n\n        const entry = await handler.get(\"fresh\");\n        expect(entry?.lastModified).toBe(performance.timeOrigin + markerNow);\n      } finally {\n        jest.restoreAllMocks();\n      }\n    });\n  });\n\n  describe(\"bounds\", () => {\n    const page = (html: string): IncrementalCacheValue => ({\n      kind: CachedRouteKind.APP_PAGE,\n      html,\n      rscData: undefined,\n      headers: undefined,\n      postponed: undefined,\n      segmentData: undefined,\n      status: undefined,\n    });\n    const env = process.env;\n\n    beforeEach(() => {\n      process.env = { ...env };\n    });\n    afterEach(() => {\n      process.env = env;\n      jest.restoreAllMocks();\n    });\n\n    it(\"drops an entry past its TTL on read\", async () => {\n      process.env.CDK_NEXTJS_MEMORY_CACHE_TTL_MS = \"1000\";\n      const clock = jest.spyOn(Date, \"now\").mockReturnValue(1_000_000);\n      handler = new MemoryCacheHandler();\n      await handler.set(\"a\", page(\"a\"));\n\n      clock.mockReturnValue(1_001_000);\n      expect(await handler.get(\"a\")).not.toBeNull();\n      clock.mockReturnValue(1_001_001);\n      expect(await handler.get(\"a\")).toBeNull();\n      expect(handler.getCacheSize()).toBe(0);\n    });\n\n    it(\"clears every expired entry on the next write\", async () => {\n      process.env.CDK_NEXTJS_MEMORY_CACHE_TTL_MS = \"1000\";\n      const clock = jest.spyOn(Date, \"now\").mockReturnValue(1_000_000);\n      handler = new MemoryCacheHandler();\n      await handler.set(\"a\", page(\"a\"));\n      await handler.set(\"b\", page(\"b\"));\n\n      clock.mockReturnValue(1_002_000);\n      await handler.set(\"c\", page(\"c\"));\n      expect(handler.getCacheSize()).toBe(1);\n    });\n\n    it(\"evicts the least recently used entry at the limit\", async () => {\n      process.env.CDK_NEXTJS_MEMORY_CACHE_MAX_ENTRIES = \"2\";\n      handler = new MemoryCacheHandler();\n      await handler.set(\"a\", page(\"a\"));\n      await handler.set(\"b\", page(\"b\"));\n      // A read makes `a` the most recently used.\n      await handler.get(\"a\");\n      await handler.set(\"c\", page(\"c\"));\n\n      expect(handler.getCacheSize()).toBe(2);\n      expect(await handler.get(\"b\")).toBeNull();\n      expect(await handler.get(\"a\")).not.toBeNull();\n      expect(await handler.get(\"c\")).not.toBeNull();\n    });\n\n    it(\"falls back to the defaults for values that are not numbers\", async () => {\n      // As NaN, nothing expired and nothing was evicted: an unbounded map.\n      process.env.CDK_NEXTJS_MEMORY_CACHE_TTL_MS = \"abc\";\n      process.env.CDK_NEXTJS_MEMORY_CACHE_MAX_ENTRIES = \"abc\";\n      const clock = jest.spyOn(Date, \"now\").mockReturnValue(1_000_000);\n      handler = new MemoryCacheHandler();\n      for (let i = 0; i <= 1000; i++) {\n        await handler.set(`k${i}`, page(\"x\"));\n      }\n      expect(handler.getCacheSize()).toBe(1000);\n\n      clock.mockReturnValue(1_000_000 + 60 * 60 * 1000 + 1);\n      expect(await handler.get(\"k1000\")).toBeNull();\n    });\n  });\n});\n"]}