cdk-nextjs 0.7.7 → 0.7.9

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

@@ -26,19 +26,21 @@ export default class CdkNextjsCacheHandler implements CacheHandler {
     /**
      * Get cache entry
      * - Build time: Not implemented (build doesn't read cache)
-     * - Runtime: Try memory first, then S3/DynamoDB
+     * - Runtime: Try memory first, then S3/DynamoDB, {@link outsideRender}
      */
     get(cacheKey: string, ctx: GetCacheHandlerContext): Promise<CacheHandlerValue | null>;
+    private getAtRuntime;
     /**
      * Set cache entry
      * - Build time: Write to local file cache only (or delete if data is null)
-     * - Runtime: Write to both memory and S3/DynamoDB (or delete if data is null)
+     * - Runtime: Write to both memory and S3/DynamoDB (or delete if data is null),
+     *   {@link outsideRender}
      */
     set(cacheKey: string, data: IncrementalCacheValue | null, ctx: SetCacheHandlerContext): Promise<void>;
     /**
      * Revalidate tags
      * - Build time: Not implemented
-     * - Runtime: Delegate to S3/DynamoDB handler
+     * - Runtime: Delegate to S3/DynamoDB handler, {@link outsideRender}
      */
     revalidateTag(tag: string | string[], durations?: {
         expire?: number;

package/lib/adapter/cache-handler.js

@@ -47,7 +47,7 @@ class CdkNextjsCacheHandler {
         }
         else {
             this.s3DynamoHandler = CdkNextjsCacheHandler.sharedS3DynamoHandler ??=
-                new s3_cache_handler_1.S3CacheHandler({ context: options });
+                (0, use_cache_common_1.outsideRender)(() => new s3_cache_handler_1.S3CacheHandler({ context: options }));
             this.memoryHandler = CdkNextjsCacheHandler.sharedMemoryHandler ??=
                 new memory_cache_handler_1.MemoryCacheHandler();
         }
@@ -55,7 +55,7 @@ class CdkNextjsCacheHandler {
     /**
      * Get cache entry
      * - Build time: Not implemented (build doesn't read cache)
-     * - Runtime: Try memory first, then S3/DynamoDB
+     * - Runtime: Try memory first, then S3/DynamoDB, {@link outsideRender}
      */
     async get(cacheKey, ctx) {
         if (this.isBuildTime) {
@@ -63,6 +63,9 @@ class CdkNextjsCacheHandler {
             // requires; see {@link LocalFileCacheHandler.get}.
             return this.localFileHandler.get(cacheKey);
         }
+        return (0, use_cache_common_1.outsideRender)(() => this.getAtRuntime(cacheKey, ctx));
+    }
+    async getAtRuntime(cacheKey, ctx) {
         // Runtime: try memory first
         const memoryResult = await this.memoryHandler.get(cacheKey);
         // A memory hit is checked against the same tag markers an S3 read is.
@@ -99,7 +102,7 @@ class CdkNextjsCacheHandler {
             // copied at all: the re-render it asks for writes the fresh entry to
             // both layers.
             if (s3Result.lastModified !== -1) {
-                await this.memoryHandler.set(cacheKey, s3Result.value, s3Result.lastModified);
+                await this.memoryHandler.set(cacheKey, s3Result.value, s3Result.lastModified, s3Result.cacheControl);
             }
             return s3Result;
         }
@@ -109,7 +112,8 @@ class CdkNextjsCacheHandler {
     /**
      * Set cache entry
      * - Build time: Write to local file cache only (or delete if data is null)
-     * - Runtime: Write to both memory and S3/DynamoDB (or delete if data is null)
+     * - Runtime: Write to both memory and S3/DynamoDB (or delete if data is null),
+     *   {@link outsideRender}
      */
     async set(cacheKey, data, ctx) {
         if (this.isBuildTime) {
@@ -124,14 +128,16 @@ class CdkNextjsCacheHandler {
             return;
         }
         // Runtime: both layers, where `null` is a delete.
-        this.debug(`Cache ${data ? "write" : "delete"}: ${cacheKey}`);
-        await this.memoryHandler.set(cacheKey, data);
-        await this.s3DynamoHandler.set(cacheKey, data, ctx);
+        await (0, use_cache_common_1.outsideRender)(async () => {
+            this.debug(`Cache ${data ? "write" : "delete"}: ${cacheKey}`);
+            await this.memoryHandler.set(cacheKey, data, undefined, (0, cache_utils_1.getCacheControl)(ctx));
+            await this.s3DynamoHandler.set(cacheKey, data, ctx);
+        });
     }
     /**
      * Revalidate tags
      * - Build time: Not implemented
-     * - Runtime: Delegate to S3/DynamoDB handler
+     * - Runtime: Delegate to S3/DynamoDB handler, {@link outsideRender}
      */
     async revalidateTag(tag, durations) {
         if (this.isBuildTime) {
@@ -139,7 +145,7 @@ class CdkNextjsCacheHandler {
         }
         // Memory hits are checked against the same markers (see `get`), so only
         // the S3/DynamoDB handler has anything to record.
-        await this.s3DynamoHandler.revalidateTag(tag, durations);
+        await (0, use_cache_common_1.outsideRender)(() => this.s3DynamoHandler.revalidateTag(tag, durations));
     }
     /**
      * Deliberately a no-op. Next.js calls `resetRequestCache` at the start of
@@ -152,4 +158,4 @@ class CdkNextjsCacheHandler {
     async resetRequestCache() { }
 }
 exports.default = CdkNextjsCacheHandler;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache-handler.js","sourceRoot":"","sources":["../../src/adapter/cache-handler.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n  Next.js Custom Cache Handler. See: https://nextjs.org/docs/app/api-reference/next-config-js/incrementalCacheHandlerPath\n  \n  Orchestrator cache handler that conditionally uses different caching strategies:\n  - Build time: LocalFileCacheHandler for pre-caching\n  - Runtime: MemoryCacheHandler (fast) + S3DynamoCacheHandler (persistent)\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 type { IncrementalCacheValue } from \"next/dist/server/response-cache\";\nimport {\n  GetCacheHandlerContext,\n  getTags,\n  SetCacheHandlerContext,\n} from \"./cache-utils\";\nimport { LocalFileCacheHandler } from \"./local-file-cache-handler\";\nimport { MemoryCacheHandler } from \"./memory-cache-handler\";\nimport { S3CacheHandler } from \"./s3-cache-handler\";\nimport { isBuildPhase } from \"./use-cache-common\";\n\n/**\n * Orchestrator cache handler that conditionally instantiates handlers based on environment\n */\nexport default class CdkNextjsCacheHandler implements CacheHandler {\n  /**\n   * Shared singleton handlers for runtime.\n   *\n   * Next.js creates multiple cache handler instances (one each for APP_PAGE, APP_ROUTE, FETCH, etc).\n   * Using singleton pattern provides:\n   * - Single S3 client connection pool shared across all cache types\n   * - Unified memory cache accessible by all instances (cache hits benefit all)\n   * - Lower memory footprint and faster initialization\n   * - Same CacheHandlerContext for all instances, so no configuration loss\n   */\n  private static sharedMemoryHandler: MemoryCacheHandler | null = null;\n  private static sharedS3DynamoHandler: S3CacheHandler | null = null;\n\n  private readonly isBuildTime = isBuildPhase();\n  private readonly debug = getDebug(\"cdk-nextjs:cache-handler:orchestrator\");\n\n  // Set only at build time.\n  private localFileHandler!: LocalFileCacheHandler;\n\n  // Set only at runtime, shared across all instances.\n  private memoryHandler!: MemoryCacheHandler;\n  private s3DynamoHandler!: S3CacheHandler;\n\n  constructor(options: CacheHandlerContext) {\n    if (this.isBuildTime) {\n      this.localFileHandler = new LocalFileCacheHandler();\n      this.debug(\n        `Build-time cache directory: ${this.localFileHandler.getCacheDir()}`,\n      );\n    } else {\n      this.s3DynamoHandler = CdkNextjsCacheHandler.sharedS3DynamoHandler ??=\n        new S3CacheHandler({ context: options });\n      this.memoryHandler = CdkNextjsCacheHandler.sharedMemoryHandler ??=\n        new MemoryCacheHandler();\n    }\n  }\n\n  /**\n   * Get cache entry\n   * - Build time: Not implemented (build doesn't read cache)\n   * - Runtime: Try memory first, then S3/DynamoDB\n   */\n  async get(\n    cacheKey: string,\n    ctx: GetCacheHandlerContext,\n  ): Promise<CacheHandlerValue | null> {\n    if (this.isBuildTime) {\n      // Reads back what this build wrote, which `cacheComponents` prerendering\n      // requires; see {@link LocalFileCacheHandler.get}.\n      return this.localFileHandler.get(cacheKey);\n    }\n\n    // Runtime: try memory first\n    const memoryResult = await this.memoryHandler.get(cacheKey);\n    // A memory hit is checked against the same tag markers an S3 read is.\n    // `revalidateTag` can only clear the memory of the instance that ran it,\n    // so skipping the check left every other instance answering from memory\n    // for the whole memory TTL - and CloudFront, whose copy that\n    // `revalidateTag` had just invalidated, cached the stale page again.\n    // The check is one DynamoDB `BatchGetItem`; what the memory layer still\n    // saves is the S3 read and the parse of the body. A revalidated entry is\n    // dropped and read from S3, which hands it back expired or as a miss.\n    if (\n      memoryResult &&\n      (await this.s3DynamoHandler.isRevalidated(\n        {\n          lastModified: memoryResult.lastModified,\n          value: memoryResult.value,\n        },\n        ctx,\n        cacheKey,\n      ))\n    ) {\n      this.debug(`Memory cache REVALIDATED: ${cacheKey}`);\n      await this.memoryHandler.set(cacheKey, null);\n    } else if (memoryResult) {\n      this.debug(`Memory cache HIT: ${cacheKey}`);\n      return memoryResult;\n    }\n\n    // Memory miss - try S3/DynamoDB\n    const s3Result = await this.s3DynamoHandler.get(cacheKey, ctx);\n    if (s3Result) {\n      this.debug(`S3 cache HIT: ${cacheKey}`);\n      // Promoted with the S3 entry's own `lastModified`, not the time of the\n      // copy: Next.js ages the entry from it for time-based revalidation, and\n      // the tag markers are compared against it too. Stamping `Date.now()`\n      // made an entry that was due for regeneration look freshly rendered,\n      // and one a soft `revalidateTag` had made stale look newer than the\n      // stale mark, so memory hits served it as fresh for the whole memory\n      // TTL. An entry a tag revalidation expired (`lastModified: -1`) is not\n      // copied at all: the re-render it asks for writes the fresh entry to\n      // both layers.\n      if (s3Result.lastModified !== -1) {\n        await this.memoryHandler.set(\n          cacheKey,\n          s3Result.value,\n          s3Result.lastModified,\n        );\n      }\n      return s3Result;\n    }\n\n    this.debug(`Cache MISS: ${cacheKey}`);\n    return null;\n  }\n\n  /**\n   * Set cache entry\n   * - Build time: Write to local file cache only (or delete if data is null)\n   * - Runtime: Write to both memory and S3/DynamoDB (or delete if data is null)\n   */\n  async set(\n    cacheKey: string,\n    data: IncrementalCacheValue | null,\n    ctx: SetCacheHandlerContext,\n  ): Promise<void> {\n    if (this.isBuildTime) {\n      if (data) {\n        await this.localFileHandler.set(cacheKey, data, getTags(ctx));\n        this.debug(`Build cache write: ${cacheKey}`);\n      } else {\n        // Delete not implemented for local file cache (build-time only creates files)\n        this.debug(`Build cache delete ignored: ${cacheKey}`);\n      }\n      return;\n    }\n    // Runtime: both layers, where `null` is a delete.\n    this.debug(`Cache ${data ? \"write\" : \"delete\"}: ${cacheKey}`);\n    await this.memoryHandler.set(cacheKey, data);\n    await this.s3DynamoHandler.set(cacheKey, data, ctx);\n  }\n\n  /**\n   * Revalidate tags\n   * - Build time: Not implemented\n   * - Runtime: Delegate to S3/DynamoDB handler\n   */\n  async revalidateTag(\n    tag: string | string[],\n    durations?: { expire?: number },\n  ): Promise<void> {\n    if (this.isBuildTime) {\n      return;\n    }\n\n    // Memory hits are checked against the same markers (see `get`), so only\n    // the S3/DynamoDB handler has anything to record.\n    await this.s3DynamoHandler.revalidateTag(tag, durations);\n  }\n\n  /**\n   * Deliberately a no-op. Next.js calls `resetRequestCache` at the start of\n   * every request (`base-server`, `app-page`, `app-route`), and its own\n   * `FileSystemCache` - whose LRU is shared across requests the same way the\n   * memory layer is - leaves it empty: the hook is for state scoped to one\n   * request, and nothing here is. Clearing the memory layer in it meant no\n   * entry ever survived to a second request, so every read went to S3.\n   */\n  async resetRequestCache(): Promise<void> {}\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache-handler.js","sourceRoot":"","sources":["../../src/adapter/cache-handler.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n  Next.js Custom Cache Handler. See: https://nextjs.org/docs/app/api-reference/next-config-js/incrementalCacheHandlerPath\n  \n  Orchestrator cache handler that conditionally uses different caching strategies:\n  - Build time: LocalFileCacheHandler for pre-caching\n  - Runtime: MemoryCacheHandler (fast) + S3DynamoCacheHandler (persistent)\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 type { IncrementalCacheValue } from \"next/dist/server/response-cache\";\nimport {\n  GetCacheHandlerContext,\n  getCacheControl,\n  getTags,\n  SetCacheHandlerContext,\n} from \"./cache-utils\";\nimport { LocalFileCacheHandler } from \"./local-file-cache-handler\";\nimport { MemoryCacheHandler } from \"./memory-cache-handler\";\nimport { S3CacheHandler } from \"./s3-cache-handler\";\nimport { isBuildPhase, outsideRender } from \"./use-cache-common\";\n\n/**\n * Orchestrator cache handler that conditionally instantiates handlers based on environment\n */\nexport default class CdkNextjsCacheHandler implements CacheHandler {\n  /**\n   * Shared singleton handlers for runtime.\n   *\n   * Next.js creates multiple cache handler instances (one each for APP_PAGE, APP_ROUTE, FETCH, etc).\n   * Using singleton pattern provides:\n   * - Single S3 client connection pool shared across all cache types\n   * - Unified memory cache accessible by all instances (cache hits benefit all)\n   * - Lower memory footprint and faster initialization\n   * - Same CacheHandlerContext for all instances, so no configuration loss\n   */\n  private static sharedMemoryHandler: MemoryCacheHandler | null = null;\n  private static sharedS3DynamoHandler: S3CacheHandler | null = null;\n\n  private readonly isBuildTime = isBuildPhase();\n  private readonly debug = getDebug(\"cdk-nextjs:cache-handler:orchestrator\");\n\n  // Set only at build time.\n  private localFileHandler!: LocalFileCacheHandler;\n\n  // Set only at runtime, shared across all instances.\n  private memoryHandler!: MemoryCacheHandler;\n  private s3DynamoHandler!: S3CacheHandler;\n\n  constructor(options: CacheHandlerContext) {\n    if (this.isBuildTime) {\n      this.localFileHandler = new LocalFileCacheHandler();\n      this.debug(\n        `Build-time cache directory: ${this.localFileHandler.getCacheDir()}`,\n      );\n    } else {\n      this.s3DynamoHandler = CdkNextjsCacheHandler.sharedS3DynamoHandler ??=\n        outsideRender(() => new S3CacheHandler({ context: options }));\n      this.memoryHandler = CdkNextjsCacheHandler.sharedMemoryHandler ??=\n        new MemoryCacheHandler();\n    }\n  }\n\n  /**\n   * Get cache entry\n   * - Build time: Not implemented (build doesn't read cache)\n   * - Runtime: Try memory first, then S3/DynamoDB, {@link outsideRender}\n   */\n  async get(\n    cacheKey: string,\n    ctx: GetCacheHandlerContext,\n  ): Promise<CacheHandlerValue | null> {\n    if (this.isBuildTime) {\n      // Reads back what this build wrote, which `cacheComponents` prerendering\n      // requires; see {@link LocalFileCacheHandler.get}.\n      return this.localFileHandler.get(cacheKey);\n    }\n    return outsideRender(() => this.getAtRuntime(cacheKey, ctx));\n  }\n\n  private async getAtRuntime(\n    cacheKey: string,\n    ctx: GetCacheHandlerContext,\n  ): Promise<CacheHandlerValue | null> {\n    // Runtime: try memory first\n    const memoryResult = await this.memoryHandler.get(cacheKey);\n    // A memory hit is checked against the same tag markers an S3 read is.\n    // `revalidateTag` can only clear the memory of the instance that ran it,\n    // so skipping the check left every other instance answering from memory\n    // for the whole memory TTL - and CloudFront, whose copy that\n    // `revalidateTag` had just invalidated, cached the stale page again.\n    // The check is one DynamoDB `BatchGetItem`; what the memory layer still\n    // saves is the S3 read and the parse of the body. A revalidated entry is\n    // dropped and read from S3, which hands it back expired or as a miss.\n    if (\n      memoryResult &&\n      (await this.s3DynamoHandler.isRevalidated(\n        {\n          lastModified: memoryResult.lastModified,\n          value: memoryResult.value,\n        },\n        ctx,\n        cacheKey,\n      ))\n    ) {\n      this.debug(`Memory cache REVALIDATED: ${cacheKey}`);\n      await this.memoryHandler.set(cacheKey, null);\n    } else if (memoryResult) {\n      this.debug(`Memory cache HIT: ${cacheKey}`);\n      return memoryResult;\n    }\n\n    // Memory miss - try S3/DynamoDB\n    const s3Result = await this.s3DynamoHandler.get(cacheKey, ctx);\n    if (s3Result) {\n      this.debug(`S3 cache HIT: ${cacheKey}`);\n      // Promoted with the S3 entry's own `lastModified`, not the time of the\n      // copy: Next.js ages the entry from it for time-based revalidation, and\n      // the tag markers are compared against it too. Stamping `Date.now()`\n      // made an entry that was due for regeneration look freshly rendered,\n      // and one a soft `revalidateTag` had made stale look newer than the\n      // stale mark, so memory hits served it as fresh for the whole memory\n      // TTL. An entry a tag revalidation expired (`lastModified: -1`) is not\n      // copied at all: the re-render it asks for writes the fresh entry to\n      // both layers.\n      if (s3Result.lastModified !== -1) {\n        await this.memoryHandler.set(\n          cacheKey,\n          s3Result.value,\n          s3Result.lastModified,\n          s3Result.cacheControl,\n        );\n      }\n      return s3Result;\n    }\n\n    this.debug(`Cache MISS: ${cacheKey}`);\n    return null;\n  }\n\n  /**\n   * Set cache entry\n   * - Build time: Write to local file cache only (or delete if data is null)\n   * - Runtime: Write to both memory and S3/DynamoDB (or delete if data is null),\n   *   {@link outsideRender}\n   */\n  async set(\n    cacheKey: string,\n    data: IncrementalCacheValue | null,\n    ctx: SetCacheHandlerContext,\n  ): Promise<void> {\n    if (this.isBuildTime) {\n      if (data) {\n        await this.localFileHandler.set(cacheKey, data, getTags(ctx));\n        this.debug(`Build cache write: ${cacheKey}`);\n      } else {\n        // Delete not implemented for local file cache (build-time only creates files)\n        this.debug(`Build cache delete ignored: ${cacheKey}`);\n      }\n      return;\n    }\n    // Runtime: both layers, where `null` is a delete.\n    await outsideRender(async () => {\n      this.debug(`Cache ${data ? \"write\" : \"delete\"}: ${cacheKey}`);\n      await this.memoryHandler.set(\n        cacheKey,\n        data,\n        undefined,\n        getCacheControl(ctx),\n      );\n      await this.s3DynamoHandler.set(cacheKey, data, ctx);\n    });\n  }\n\n  /**\n   * Revalidate tags\n   * - Build time: Not implemented\n   * - Runtime: Delegate to S3/DynamoDB handler, {@link outsideRender}\n   */\n  async revalidateTag(\n    tag: string | string[],\n    durations?: { expire?: number },\n  ): Promise<void> {\n    if (this.isBuildTime) {\n      return;\n    }\n\n    // Memory hits are checked against the same markers (see `get`), so only\n    // the S3/DynamoDB handler has anything to record.\n    await outsideRender(() =>\n      this.s3DynamoHandler.revalidateTag(tag, durations),\n    );\n  }\n\n  /**\n   * Deliberately a no-op. Next.js calls `resetRequestCache` at the start of\n   * every request (`base-server`, `app-page`, `app-route`), and its own\n   * `FileSystemCache` - whose LRU is shared across requests the same way the\n   * memory layer is - leaves it empty: the hook is for state scoped to one\n   * request, and nothing here is. Clearing the memory layer in it meant no\n   * entry ever survived to a second request, so every read went to S3.\n   */\n  async resetRequestCache(): Promise<void> {}\n}\n"]}

package/lib/adapter/cache-handler.mjs

@@ -74119,6 +74119,22 @@ var INIT_CACHE_TAG_MANIFEST = "_cdk-nextjs-tag-manifest.json";
 function getTags(ctx) {
   return "tags" in ctx ? ctx.tags : void 0;
 }
+function getCacheControl(ctx) {
+  return "cacheControl" in ctx ? storedCacheControl(ctx.cacheControl) : void 0;
+}
+function storedCacheControl(value) {
+  if (typeof value !== "object" || value === null) {
+    return void 0;
+  }
+  const { revalidate, expire } = value;
+  if (revalidate !== false && !(typeof revalidate === "number" && Number.isFinite(revalidate) && revalidate > 0)) {
+    return void 0;
+  }
+  if (expire !== void 0 && !Number.isFinite(expire)) {
+    return void 0;
+  }
+  return { revalidate, expire };
+}
 
 // src/adapter/local-file-cache-handler.ts
 var import_debug = __toESM(require_src());
@@ -74228,6 +74244,21 @@ var import_client_dynamodb = __toESM(require_dist_cjs19());
 var import_client_s3 = __toESM(require_dist_cjs20());
 import { AsyncLocalStorage } from "node:async_hooks";
 import { join as join6 } from "node:path";
+
+// src/runtime/tag-manifest.ts
+var OUTSIDE_REQUEST_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "cdk-nextjs.outside-request-context"
+);
+function outsideRequest(fn) {
+  const global = globalThis;
+  const run = global[OUTSIDE_REQUEST_SYMBOL];
+  return run ? run(fn) : fn();
+}
+var TAG_MANIFEST_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "cdk-nextjs.use-cache.tag-manifest"
+);
+
+// src/adapter/aws-cache-store.ts
 function resolveAwsCacheConfig() {
   return {
     bucketName: process.env.CDK_NEXTJS_CACHE_BUCKET_NAME || "",
@@ -74797,6 +74828,18 @@ var TrackedTagMarkers = class {
     }
     return this.caughtUpRender.run(true, render);
   }
+  /**
+   * Run `fn` outside the request's context (`outsideRequest`), keeping only
+   * whether the render was {@link catchUp caught up}: a cache handler method
+   * called from inside a staged render, whose clock reads and AWS SDK calls
+   * would otherwise end its static stage.
+   */
+  outsideRender(fn) {
+    const caughtUp = this.caughtUpRender.getStore();
+    return outsideRequest(
+      () => caughtUp ? this.caughtUpRender.run(caughtUp, fn) : fn()
+    );
+  }
   /** Whether `at` is more than the interval and the grace ago. */
   overdue(at) {
     return this.clock() - at > this.refreshIntervalMs + TAG_REFRESH_GRACE_MS;
@@ -75389,13 +75432,6 @@ var CacheBucket = class {
 // src/adapter/use-cache-common.ts
 var import_client_dynamodb2 = __toESM(require_dist_cjs19());
 var import_debug6 = __toESM(require_src());
-
-// src/runtime/tag-manifest.ts
-var TAG_MANIFEST_SYMBOL = /* @__PURE__ */ Symbol.for(
-  "cdk-nextjs.use-cache.tag-manifest"
-);
-
-// src/adapter/use-cache-common.ts
 function isBuildPhase() {
   return process.env.NEXT_PHASE === "phase-production-build";
 }
@@ -75406,6 +75442,9 @@ function numberFromEnv(name, fallback2) {
 }
 var DEFAULT_MEMORY_BYTES = 50 * 1024 * 1024;
 var TAG_TABLE_REQUEST_TIMEOUT_MS = 3e3;
+function outsideRender(fn) {
+  return outsideRequest(sharedTagManifest).outsideRender(fn);
+}
 function sharedTagManifest() {
   const global = globalThis;
   if (!global[TAG_MANIFEST_SYMBOL]) {
@@ -75543,8 +75582,11 @@ var MemoryCacheHandler = class {
    * `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.
+   *
+   * `cacheControl` is the lifetime the entry was rendered with, handed back
+   * from {@link get} as the S3 layer does; see `getCacheControl`.
    */
-  async set(cacheKey, data, lastModified) {
+  async set(cacheKey, data, lastModified, cacheControl) {
     if (!data) {
       this.debug(`MEMORY CACHE DELETE: ${cacheKey}`);
       this.inMemoryCache.delete(cacheKey);
@@ -75553,7 +75595,8 @@ var MemoryCacheHandler = class {
     this.debug(`MEMORY CACHE SET: ${cacheKey} (${data.kind})`);
     const cacheHandlerValue = {
       lastModified: lastModified ?? markerClock(),
-      value: data
+      value: data,
+      cacheControl
     };
     const entry = {
       value: cacheHandlerValue,
@@ -75729,15 +75772,26 @@ var S3CacheHandler = class {
    * request is answered from the stale entry - stale-while-revalidate - and that
    * response carries the entry's original `s-maxage`, so the edge caches the
    * stale body again. The background render that replaces it runs in this same
-   * process, so `set` checks this set and invalidates the key's paths a second
+   * process, so `set` checks for the key here and invalidates the key's paths a second
    * time once the fresh entry is in S3. Without that, the edge kept serving the
    * pre-revalidation page for the whole `s-maxage`.
    *
    * Expiring soft-revalidated entries outright instead would also keep the edge
    * right, but it turns every `revalidateTag(tag, "max")` into a blocking render
    * at the origin, which is the thing a profile asks not to happen.
+   *
+   * When the re-render fails, next 16.4's `retainPreviousCacheEntry` writes the
+   * stale value back with a short lifetime: that is no regeneration, so the key
+   * keeps waiting rather than invalidating the edge for a page that has not
+   * changed. {@link servedStale} is how `set` recognises it.
    */
   softRevalidatedKeys = /* @__PURE__ */ new Set();
+  /**
+   * Every value handed out stale, by identity: the object `get` returned is the
+   * one `retainPreviousCacheEntry` writes back. Weak, so a page body is held no
+   * longer than the memory layer or the request holds it.
+   */
+  servedStale = /* @__PURE__ */ new WeakSet();
   /** @see buildTagManifest */
   buildTags;
   constructor(options) {
@@ -75797,12 +75851,17 @@ var S3CacheHandler = class {
       const parsedValue = parseCacheValue(response);
       if (await this.isRevalidated(parsedValue, ctx, cacheKey)) {
         this.debug(`S3 CACHE INVALIDATED BY TAG: ${cacheKey}`);
-        return isFetchCacheGet(ctx) ? null : { lastModified: EXPIRED_LAST_MODIFIED, value: parsedValue.value };
+        return isFetchCacheGet(ctx) ? null : {
+          lastModified: EXPIRED_LAST_MODIFIED,
+          value: parsedValue.value,
+          cacheControl: storedCacheControl(parsedValue.cacheControl)
+        };
       }
       this.debug(`S3 CACHE HIT: ${cacheKey} (${objectKey})`);
       return {
         lastModified: parsedValue.lastModified,
-        value: parsedValue.value
+        value: parsedValue.value,
+        cacheControl: storedCacheControl(parsedValue.cacheControl)
       };
     } catch (error2) {
       console.error(`Error retrieving cache from S3:`, error2);
@@ -75848,7 +75907,7 @@ var S3CacheHandler = class {
       checkTags
     );
     if (state2 === "stale" && !isFetchCacheGet(ctx)) {
-      this.noteSoftRevalidated(cacheKey);
+      this.noteSoftRevalidated(cacheKey, entry.value);
     }
     return state2 === "expired";
   }
@@ -75857,13 +75916,16 @@ var S3CacheHandler = class {
    * whose copy of it will need invalidating again. See
    * {@link softRevalidatedKeys}.
    */
-  noteSoftRevalidated(cacheKey) {
+  noteSoftRevalidated(cacheKey, value) {
     if (!this.invalidatesCdn) {
       return;
     }
+    if (typeof value === "object" && value !== null) {
+      this.servedStale.add(value);
+    }
     this.softRevalidatedKeys.delete(cacheKey);
     if (this.softRevalidatedKeys.size >= MAX_SOFT_REVALIDATED_KEYS) {
-      const oldest = this.softRevalidatedKeys.values().next().value;
+      const oldest = this.softRevalidatedKeys.keys().next().value;
       if (oldest !== void 0) {
         this.softRevalidatedKeys.delete(oldest);
       }
@@ -75901,7 +75963,8 @@ var S3CacheHandler = class {
       const cacheHandlerValue = {
         // On the marker clock, since that is what it is compared with.
         lastModified: markerClock(),
-        value: data
+        value: data,
+        cacheControl: getCacheControl(ctx)
       };
       const cacheEntryWithTags = {
         ...cacheHandlerValue,
@@ -75910,7 +75973,7 @@ var S3CacheHandler = class {
       const body = serializeCacheValue(cacheEntryWithTags);
       await this.bucket.putJson(objectKey, body);
       this.debug(`S3 CACHE STORED: ${cacheKey} (${data.kind})`);
-      if (this.softRevalidatedKeys.delete(cacheKey)) {
+      if (!this.servedStale.has(data) && this.softRevalidatedKeys.delete(cacheKey)) {
         const route = this.s3KeyToInvalidationPath(s3Key);
         if (route !== void 0) {
           this.debug(`SOFT REVALIDATION REGENERATED: ${cacheKey}`);
@@ -76378,19 +76441,22 @@ var CdkNextjsCacheHandler = class _CdkNextjsCacheHandler {
         `Build-time cache directory: ${this.localFileHandler.getCacheDir()}`
       );
     } else {
-      this.s3DynamoHandler = _CdkNextjsCacheHandler.sharedS3DynamoHandler ??= new S3CacheHandler({ context: options });
+      this.s3DynamoHandler = _CdkNextjsCacheHandler.sharedS3DynamoHandler ??= outsideRender(() => new S3CacheHandler({ context: options }));
       this.memoryHandler = _CdkNextjsCacheHandler.sharedMemoryHandler ??= new MemoryCacheHandler();
     }
   }
   /**
    * Get cache entry
    * - Build time: Not implemented (build doesn't read cache)
-   * - Runtime: Try memory first, then S3/DynamoDB
+   * - Runtime: Try memory first, then S3/DynamoDB, {@link outsideRender}
    */
   async get(cacheKey, ctx) {
     if (this.isBuildTime) {
       return this.localFileHandler.get(cacheKey);
     }
+    return outsideRender(() => this.getAtRuntime(cacheKey, ctx));
+  }
+  async getAtRuntime(cacheKey, ctx) {
     const memoryResult = await this.memoryHandler.get(cacheKey);
     if (memoryResult && await this.s3DynamoHandler.isRevalidated(
       {
@@ -76413,7 +76479,8 @@ var CdkNextjsCacheHandler = class _CdkNextjsCacheHandler {
         await this.memoryHandler.set(
           cacheKey,
           s3Result.value,
-          s3Result.lastModified
+          s3Result.lastModified,
+          s3Result.cacheControl
         );
       }
       return s3Result;
@@ -76424,7 +76491,8 @@ var CdkNextjsCacheHandler = class _CdkNextjsCacheHandler {
   /**
    * Set cache entry
    * - Build time: Write to local file cache only (or delete if data is null)
-   * - Runtime: Write to both memory and S3/DynamoDB (or delete if data is null)
+   * - Runtime: Write to both memory and S3/DynamoDB (or delete if data is null),
+   *   {@link outsideRender}
    */
   async set(cacheKey, data, ctx) {
     if (this.isBuildTime) {
@@ -76436,20 +76504,29 @@ var CdkNextjsCacheHandler = class _CdkNextjsCacheHandler {
       }
       return;
     }
-    this.debug(`Cache ${data ? "write" : "delete"}: ${cacheKey}`);
-    await this.memoryHandler.set(cacheKey, data);
-    await this.s3DynamoHandler.set(cacheKey, data, ctx);
+    await outsideRender(async () => {
+      this.debug(`Cache ${data ? "write" : "delete"}: ${cacheKey}`);
+      await this.memoryHandler.set(
+        cacheKey,
+        data,
+        void 0,
+        getCacheControl(ctx)
+      );
+      await this.s3DynamoHandler.set(cacheKey, data, ctx);
+    });
   }
   /**
    * Revalidate tags
    * - Build time: Not implemented
-   * - Runtime: Delegate to S3/DynamoDB handler
+   * - Runtime: Delegate to S3/DynamoDB handler, {@link outsideRender}
    */
   async revalidateTag(tag, durations) {
     if (this.isBuildTime) {
       return;
     }
-    await this.s3DynamoHandler.revalidateTag(tag, durations);
+    await outsideRender(
+      () => this.s3DynamoHandler.revalidateTag(tag, durations)
+    );
   }
   /**
    * Deliberately a no-op. Next.js calls `resetRequestCache` at the start of