cdk-nextjs 0.7.6 → 0.7.8

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

@@ -220,6 +220,49 @@ describe("CdkNextjsCacheHandler - Orchestrator Pattern", () => {
             });
             expect(s3.isRevalidated).toHaveBeenCalledWith({ lastModified: renderedAt, value }, getCtx, "isr/3");
         });
+        it("serves a memory hit with the lifetime it was rendered or stored with", async () => {
+            const value = {
+                kind: "APP_PAGE" /* CachedRouteKind.APP_PAGE */,
+                html: "<html>isr</html>",
+                rscData: undefined,
+                headers: undefined,
+                postponed: undefined,
+                segmentData: undefined,
+                status: undefined,
+            };
+            const getCtx = {
+                kind: "APP_PAGE" /* IncrementalCacheKind.APP_PAGE */,
+                isFallback: false,
+            };
+            const s3 = {
+                set: jest.fn().mockResolvedValue(undefined),
+                get: jest.fn().mockResolvedValue({
+                    lastModified: Date.now(),
+                    value,
+                    cacheControl: { revalidate: 30, expire: undefined },
+                }),
+                isRevalidated: jest.fn().mockResolvedValue(false),
+            };
+            cacheHandler.s3DynamoHandler = s3;
+            // Rendered here: the lifetime `ResponseCache.set` passed.
+            await cacheHandler.set("isr/4", value, {
+                cacheControl: { revalidate: 60, expire: 300 },
+                isRoutePPREnabled: false,
+                isFallback: false,
+            });
+            expect((await cacheHandler.get("isr/4", getCtx))?.cacheControl).toEqual({
+                revalidate: 60,
+                expire: 300,
+            });
+            // Copied in from S3: the lifetime S3 stored.
+            await cacheHandler.get("isr/5", getCtx);
+            s3.get.mockClear();
+            expect((await cacheHandler.get("isr/5", getCtx))?.cacheControl).toEqual({
+                revalidate: 30,
+                expire: undefined,
+            });
+            expect(s3.get).not.toHaveBeenCalled();
+        });
         it("does not serve a memory hit another instance's revalidateTag expired", async () => {
             // `revalidateTag` clears only the memory of the instance that ran it. Any
             // other instance holding the page in memory answered from it for the
@@ -377,4 +420,4 @@ describe("CdkNextjsCacheHandler - Orchestrator Pattern", () => {
         });
     });
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache-handler.test.js","sourceRoot":"","sources":["../../src/adapter/cache-handler.test.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\nimport { existsSync, mkdtempSync } from \"fs\";\nimport { tmpdir } from \"os\";\nimport { join } from \"path\";\nimport { CacheHandlerContext } from \"next/dist/server/lib/incremental-cache\";\nimport {\n  IncrementalCacheValue,\n  CachedRouteKind,\n  IncrementalCacheKind,\n} from \"next/dist/server/response-cache\";\nimport type { GetIncrementalFetchCacheContext } from \"next/dist/server/response-cache\";\nimport CdkNextjsCacheHandler from \"./cache-handler\";\nimport { cacheObjectName } from \"./cache-utils\";\n\n// Mock AWS SDK clients\njest.mock(\"@aws-sdk/client-s3\");\njest.mock(\"@aws-sdk/client-dynamodb\");\n\ndescribe(\"CdkNextjsCacheHandler - Orchestrator Pattern\", () => {\n  let cacheHandler: CdkNextjsCacheHandler;\n\n  const createMockContext = (): CacheHandlerContext => ({\n    dev: false,\n    revalidatedTags: [],\n    _requestHeaders: {},\n  });\n\n  beforeEach(() => {\n    // Suppress expected warnings when env vars are not set\n    jest.spyOn(console, \"warn\").mockImplementation(() => {});\n\n    const mockContext = createMockContext();\n    cacheHandler = new CdkNextjsCacheHandler(mockContext);\n  });\n\n  afterEach(() => {\n    jest.clearAllMocks();\n    jest.restoreAllMocks();\n    // Clean up env vars\n    delete process.env.CDK_NEXTJS_MEMORY_CACHE_TTL_MS;\n    // Reset singleton handlers by accessing the class's static properties\n    // This ensures each test gets fresh handlers\n    (CdkNextjsCacheHandler as any).sharedMemoryHandler = null;\n    (CdkNextjsCacheHandler as any).sharedS3DynamoHandler = null;\n  });\n\n  describe(\"Orchestrator: Memory + S3/DynamoDB\", () => {\n    it(\"should write to both memory and S3/DynamoDB on set\", 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      const s3 = {\n        set: jest.fn().mockResolvedValue(undefined),\n        get: jest.fn().mockResolvedValue(null),\n        isRevalidated: jest.fn().mockResolvedValue(false),\n      };\n      (cacheHandler as any).s3DynamoHandler = s3;\n      const setCtx = { fetchCache: true as const, tags: [] };\n\n      // Set cache entry\n      await cacheHandler.set(\"test-key\", testData, setCtx);\n\n      // S3/DynamoDB got the write, with the context it needs for tags.\n      expect(s3.set).toHaveBeenCalledWith(\"test-key\", testData, setCtx);\n\n      // Get should return from memory, without asking S3.\n      const result = await cacheHandler.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      expect(s3.get).not.toHaveBeenCalled();\n    });\n\n    it(\"deletes from both layers on set(key, null)\", async () => {\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>gone</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n      const s3 = {\n        set: jest.fn().mockResolvedValue(undefined),\n        get: jest.fn().mockResolvedValue(null),\n        isRevalidated: jest.fn().mockResolvedValue(false),\n      };\n      (cacheHandler as any).s3DynamoHandler = s3;\n      const setCtx = { fetchCache: true as const, tags: [] };\n      await cacheHandler.set(\"gone-key\", testData, setCtx);\n\n      await cacheHandler.set(\"gone-key\", null, setCtx);\n\n      // The S3 layer is told to delete, not skipped.\n      expect(s3.set).toHaveBeenLastCalledWith(\"gone-key\", null, setCtx);\n      // And memory no longer answers: the read falls through to S3.\n      expect(\n        await cacheHandler.get(\"gone-key\", {\n          kind: IncrementalCacheKind.APP_PAGE,\n          isFallback: false,\n        }),\n      ).toBeNull();\n      expect(s3.get).toHaveBeenCalledTimes(1);\n    });\n\n    it(\"revalidates a tag in S3/DynamoDB, passing the durations through\", async () => {\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>tagged</html>\",\n        rscData: undefined,\n        headers: { \"x-next-cache-tags\": \"posts\" },\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n      const s3 = {\n        set: jest.fn().mockResolvedValue(undefined),\n        get: jest.fn().mockResolvedValue(null),\n        isRevalidated: jest.fn().mockResolvedValue(false),\n        revalidateTag: jest.fn().mockResolvedValue(undefined),\n      };\n      (cacheHandler as any).s3DynamoHandler = s3;\n\n      await cacheHandler.set(\"tagged-key\", testData, {\n        fetchCache: true as const,\n        tags: [\"posts\"],\n      });\n      // `revalidateTag(tag, profile)`: the durations decide stale vs expired,\n      // so dropping them turns every soft revalidation into a hard one.\n      await cacheHandler.revalidateTag([\"posts\"], { expire: 60 });\n\n      expect(s3.revalidateTag).toHaveBeenCalledWith([\"posts\"], { expire: 60 });\n\n      await cacheHandler.revalidateTag(\"posts\");\n      expect(s3.revalidateTag).toHaveBeenLastCalledWith(\"posts\", undefined);\n    });\n\n    it(\"should handle cache misses gracefully\", async () => {\n      // Get non-existent key\n      const result = await cacheHandler.get(\"missing-key\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n\n      // Should return null (both memory and S3 miss)\n      expect(result).toBeNull();\n    });\n\n    it(\"does not copy a tag-expired S3 entry into memory\", async () => {\n      // `lastModified: -1` is the S3 layer saying \"a tag revalidation expired\n      // this, re-render before answering\". Copied into memory, the expired body\n      // would be answered from there instead of from the re-render.\n      const value: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>expired</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n      const getCtx = {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      } as const;\n\n      (cacheHandler as any).s3DynamoHandler = {\n        get: jest.fn().mockResolvedValue({ lastModified: -1, value }),\n      };\n      expect(await cacheHandler.get(\"isr/1\", getCtx)).toEqual({\n        lastModified: -1,\n        value,\n      });\n\n      // With the S3 layer now silent, a memory copy would answer this as a hit.\n      (cacheHandler as any).s3DynamoHandler = {\n        get: jest.fn().mockResolvedValue(null),\n      };\n      expect(await cacheHandler.get(\"isr/1\", getCtx)).toBeNull();\n    });\n\n    it(\"copies a live S3 entry into memory\", async () => {\n      const value: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>live</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n      const getCtx = {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      } as const;\n\n      (cacheHandler as any).s3DynamoHandler = {\n        get: jest.fn().mockResolvedValue({ lastModified: Date.now(), value }),\n      };\n      await cacheHandler.get(\"isr/2\", getCtx);\n\n      const s3 = {\n        get: jest.fn().mockResolvedValue(null),\n        isRevalidated: jest.fn().mockResolvedValue(false),\n      };\n      (cacheHandler as any).s3DynamoHandler = s3;\n      expect(await cacheHandler.get(\"isr/2\", getCtx)).toMatchObject({ value });\n      expect(s3.get).not.toHaveBeenCalled();\n    });\n\n    it(\"keeps the S3 entry's lastModified when copying it into memory\", async () => {\n      // Next.js ages the entry from `lastModified`, and the tag markers are\n      // compared against it. Stamping the time of the copy made a page a soft\n      // `revalidateTag` had made stale look newer than the stale mark.\n      const value: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>old</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n      const getCtx = {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      } as const;\n      const renderedAt = Date.now() - 60_000;\n\n      (cacheHandler as any).s3DynamoHandler = {\n        get: jest.fn().mockResolvedValue({ lastModified: renderedAt, value }),\n      };\n      await cacheHandler.get(\"isr/3\", getCtx);\n\n      const s3 = {\n        get: jest.fn().mockResolvedValue(null),\n        isRevalidated: jest.fn().mockResolvedValue(false),\n      };\n      (cacheHandler as any).s3DynamoHandler = s3;\n      expect(await cacheHandler.get(\"isr/3\", getCtx)).toEqual({\n        lastModified: renderedAt,\n        value,\n      });\n      expect(s3.isRevalidated).toHaveBeenCalledWith(\n        { lastModified: renderedAt, value },\n        getCtx,\n        \"isr/3\",\n      );\n    });\n\n    it(\"does not serve a memory hit another instance's revalidateTag expired\", async () => {\n      // `revalidateTag` clears only the memory of the instance that ran it. Any\n      // other instance holding the page in memory answered from it for the\n      // whole memory TTL, and CloudFront - just invalidated - cached the stale\n      // page again. So a memory hit is checked against the tag markers too.\n      const value: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>stale</html>\",\n        rscData: undefined,\n        headers: { \"x-next-cache-tags\": \"_N_T_/blog\" },\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n      const getCtx = {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      } as const;\n\n      (cacheHandler as any).s3DynamoHandler = {\n        get: jest.fn().mockResolvedValue({ lastModified: Date.now(), value }),\n      };\n      await cacheHandler.get(\"blog\", getCtx);\n\n      // Another instance revalidated `_N_T_/blog`: the marker is newer than the\n      // memory copy, and S3 now answers with the entry expired.\n      const s3 = {\n        get: jest.fn().mockResolvedValue({ lastModified: -1, value }),\n        isRevalidated: jest.fn().mockResolvedValue(true),\n      };\n      (cacheHandler as any).s3DynamoHandler = s3;\n      expect(await cacheHandler.get(\"blog\", getCtx)).toEqual({\n        lastModified: -1,\n        value,\n      });\n      expect(s3.isRevalidated).toHaveBeenCalledWith(\n        expect.objectContaining({ value }),\n        getCtx,\n        \"blog\",\n      );\n      expect(s3.get).toHaveBeenCalledTimes(1);\n\n      // And the memory copy is gone rather than checked again next time.\n      s3.get.mockResolvedValue(null);\n      expect(await cacheHandler.get(\"blog\", getCtx)).toBeNull();\n    });\n\n    it(\"keeps memory entries across resetRequestCache\", async () => {\n      // Next.js calls it at the start of every request; clearing the shared\n      // memory cache there sent every read to S3.\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>reset</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n\n      // Add entry\n      await cacheHandler.set(\"reset-key\", testData, {\n        fetchCache: true as const,\n        tags: [\"reset-tag\"],\n      });\n\n      // Reset\n      await cacheHandler.resetRequestCache();\n\n      // Still answered from memory, without asking S3.\n      const s3 = {\n        get: jest.fn().mockResolvedValue(null),\n        isRevalidated: jest.fn().mockResolvedValue(false),\n      };\n      (cacheHandler as any).s3DynamoHandler = s3;\n      const result = await cacheHandler.get(\"reset-key\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n      expect(result?.value).toEqual(testData);\n      expect(s3.get).not.toHaveBeenCalled();\n    });\n  });\n\n  describe(\"Build-time behavior\", () => {\n    it(\"reads back a fetch entry it wrote, from memory and from disk\", async () => {\n      // `cacheComponents` prerenders each page twice: the first pass runs the\n      // `fetch` and `set`s it, the second must find it already cached or Next.js\n      // fails the build with \"encountered uncached or runtime data during\n      // prerendering\". A write-only build-time handler therefore makes\n      // `cache: 'force-cache'` unbuildable - measured against next.js's\n      // `test/e2e/app-dir/resume-data-cache`.\n      process.env.NEXT_PHASE = \"phase-production-build\";\n      process.env.CDK_NEXTJS_INIT_CACHE_DIR = mkdtempSync(\n        join(tmpdir(), \"cdk-nextjs-init-cache-\"),\n      );\n      try {\n        const data: IncrementalCacheValue = {\n          kind: CachedRouteKind.FETCH,\n          data: {\n            headers: {},\n            body: \"eyJyYW5kb20iOjF9\",\n            status: 200,\n            url: \"https://example.test/api/random\",\n          },\n          revalidate: 31536000,\n        };\n        const fetchUrl = \"https://example.test/api/random\";\n        const setCtx = {\n          fetchCache: true as const,\n          tags: [\"test\"],\n          fetchUrl,\n          fetchIdx: 1,\n        };\n        const getCtx: GetIncrementalFetchCacheContext = {\n          kind: IncrementalCacheKind.FETCH,\n          revalidate: 31536000,\n          fetchUrl,\n          fetchIdx: 1,\n          tags: [\"test\"],\n        };\n        const buildHandler = new CdkNextjsCacheHandler(createMockContext());\n        await buildHandler.set(\"fetch-key\", data, setCtx);\n        expect(await buildHandler.get(\"fetch-key\", getCtx)).toMatchObject({\n          value: data,\n        });\n\n        // A second instance reads the file rather than the map: `next build`\n        // renders pages in worker processes, so the pass that writes and the\n        // pass that reads are not always the same process.\n        const otherWorker = new CdkNextjsCacheHandler(createMockContext());\n        expect(await otherWorker.get(\"fetch-key\", getCtx)).toMatchObject({\n          value: data,\n        });\n        expect(await otherWorker.get(\"never-written\", getCtx)).toBeNull();\n      } finally {\n        delete process.env.NEXT_PHASE;\n        delete process.env.CDK_NEXTJS_INIT_CACHE_DIR;\n      }\n    });\n\n    // The seed is uploaded as written, so it must be filed under the name the\n    // runtime's `get` reads: for a name too long for S3, `cacheObjectName`'s.\n    it(\"files an over-long key where the runtime reads it\", async () => {\n      process.env.NEXT_PHASE = \"phase-production-build\";\n      const cacheDir = mkdtempSync(join(tmpdir(), \"cdk-nextjs-init-cache-\"));\n      process.env.CDK_NEXTJS_INIT_CACHE_DIR = cacheDir;\n      try {\n        const key = `/route-cache/APP_PAGE/${\"a\".repeat(64)}/$/${\"x\".repeat(900)}`;\n        expect(cacheObjectName(key)).toMatch(/^_long-key\\//);\n        const data: IncrementalCacheValue = {\n          kind: CachedRouteKind.FETCH,\n          data: { headers: {}, body: \"e30=\", status: 200, url: \"\" },\n          revalidate: 60,\n        };\n        const setCtx = { fetchCache: true as const, tags: [] };\n        await new CdkNextjsCacheHandler(createMockContext()).set(\n          key,\n          data,\n          setCtx,\n        );\n        expect(existsSync(join(cacheDir, cacheObjectName(key)))).toBe(true);\n        const getCtx: GetIncrementalFetchCacheContext = {\n          kind: IncrementalCacheKind.FETCH,\n          revalidate: 60,\n          tags: [],\n        };\n        expect(\n          await new CdkNextjsCacheHandler(createMockContext()).get(key, getCtx),\n        ).toMatchObject({ value: data });\n      } finally {\n        delete process.env.NEXT_PHASE;\n        delete process.env.CDK_NEXTJS_INIT_CACHE_DIR;\n      }\n    });\n  });\n});\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache-handler.test.js","sourceRoot":"","sources":["../../src/adapter/cache-handler.test.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\nimport { existsSync, mkdtempSync } from \"fs\";\nimport { tmpdir } from \"os\";\nimport { join } from \"path\";\nimport { CacheHandlerContext } from \"next/dist/server/lib/incremental-cache\";\nimport {\n  IncrementalCacheValue,\n  CachedRouteKind,\n  IncrementalCacheKind,\n} from \"next/dist/server/response-cache\";\nimport type { GetIncrementalFetchCacheContext } from \"next/dist/server/response-cache\";\nimport CdkNextjsCacheHandler from \"./cache-handler\";\nimport { cacheObjectName } from \"./cache-utils\";\n\n// Mock AWS SDK clients\njest.mock(\"@aws-sdk/client-s3\");\njest.mock(\"@aws-sdk/client-dynamodb\");\n\ndescribe(\"CdkNextjsCacheHandler - Orchestrator Pattern\", () => {\n  let cacheHandler: CdkNextjsCacheHandler;\n\n  const createMockContext = (): CacheHandlerContext => ({\n    dev: false,\n    revalidatedTags: [],\n    _requestHeaders: {},\n  });\n\n  beforeEach(() => {\n    // Suppress expected warnings when env vars are not set\n    jest.spyOn(console, \"warn\").mockImplementation(() => {});\n\n    const mockContext = createMockContext();\n    cacheHandler = new CdkNextjsCacheHandler(mockContext);\n  });\n\n  afterEach(() => {\n    jest.clearAllMocks();\n    jest.restoreAllMocks();\n    // Clean up env vars\n    delete process.env.CDK_NEXTJS_MEMORY_CACHE_TTL_MS;\n    // Reset singleton handlers by accessing the class's static properties\n    // This ensures each test gets fresh handlers\n    (CdkNextjsCacheHandler as any).sharedMemoryHandler = null;\n    (CdkNextjsCacheHandler as any).sharedS3DynamoHandler = null;\n  });\n\n  describe(\"Orchestrator: Memory + S3/DynamoDB\", () => {\n    it(\"should write to both memory and S3/DynamoDB on set\", 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      const s3 = {\n        set: jest.fn().mockResolvedValue(undefined),\n        get: jest.fn().mockResolvedValue(null),\n        isRevalidated: jest.fn().mockResolvedValue(false),\n      };\n      (cacheHandler as any).s3DynamoHandler = s3;\n      const setCtx = { fetchCache: true as const, tags: [] };\n\n      // Set cache entry\n      await cacheHandler.set(\"test-key\", testData, setCtx);\n\n      // S3/DynamoDB got the write, with the context it needs for tags.\n      expect(s3.set).toHaveBeenCalledWith(\"test-key\", testData, setCtx);\n\n      // Get should return from memory, without asking S3.\n      const result = await cacheHandler.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      expect(s3.get).not.toHaveBeenCalled();\n    });\n\n    it(\"deletes from both layers on set(key, null)\", async () => {\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>gone</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n      const s3 = {\n        set: jest.fn().mockResolvedValue(undefined),\n        get: jest.fn().mockResolvedValue(null),\n        isRevalidated: jest.fn().mockResolvedValue(false),\n      };\n      (cacheHandler as any).s3DynamoHandler = s3;\n      const setCtx = { fetchCache: true as const, tags: [] };\n      await cacheHandler.set(\"gone-key\", testData, setCtx);\n\n      await cacheHandler.set(\"gone-key\", null, setCtx);\n\n      // The S3 layer is told to delete, not skipped.\n      expect(s3.set).toHaveBeenLastCalledWith(\"gone-key\", null, setCtx);\n      // And memory no longer answers: the read falls through to S3.\n      expect(\n        await cacheHandler.get(\"gone-key\", {\n          kind: IncrementalCacheKind.APP_PAGE,\n          isFallback: false,\n        }),\n      ).toBeNull();\n      expect(s3.get).toHaveBeenCalledTimes(1);\n    });\n\n    it(\"revalidates a tag in S3/DynamoDB, passing the durations through\", async () => {\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>tagged</html>\",\n        rscData: undefined,\n        headers: { \"x-next-cache-tags\": \"posts\" },\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n      const s3 = {\n        set: jest.fn().mockResolvedValue(undefined),\n        get: jest.fn().mockResolvedValue(null),\n        isRevalidated: jest.fn().mockResolvedValue(false),\n        revalidateTag: jest.fn().mockResolvedValue(undefined),\n      };\n      (cacheHandler as any).s3DynamoHandler = s3;\n\n      await cacheHandler.set(\"tagged-key\", testData, {\n        fetchCache: true as const,\n        tags: [\"posts\"],\n      });\n      // `revalidateTag(tag, profile)`: the durations decide stale vs expired,\n      // so dropping them turns every soft revalidation into a hard one.\n      await cacheHandler.revalidateTag([\"posts\"], { expire: 60 });\n\n      expect(s3.revalidateTag).toHaveBeenCalledWith([\"posts\"], { expire: 60 });\n\n      await cacheHandler.revalidateTag(\"posts\");\n      expect(s3.revalidateTag).toHaveBeenLastCalledWith(\"posts\", undefined);\n    });\n\n    it(\"should handle cache misses gracefully\", async () => {\n      // Get non-existent key\n      const result = await cacheHandler.get(\"missing-key\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n\n      // Should return null (both memory and S3 miss)\n      expect(result).toBeNull();\n    });\n\n    it(\"does not copy a tag-expired S3 entry into memory\", async () => {\n      // `lastModified: -1` is the S3 layer saying \"a tag revalidation expired\n      // this, re-render before answering\". Copied into memory, the expired body\n      // would be answered from there instead of from the re-render.\n      const value: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>expired</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n      const getCtx = {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      } as const;\n\n      (cacheHandler as any).s3DynamoHandler = {\n        get: jest.fn().mockResolvedValue({ lastModified: -1, value }),\n      };\n      expect(await cacheHandler.get(\"isr/1\", getCtx)).toEqual({\n        lastModified: -1,\n        value,\n      });\n\n      // With the S3 layer now silent, a memory copy would answer this as a hit.\n      (cacheHandler as any).s3DynamoHandler = {\n        get: jest.fn().mockResolvedValue(null),\n      };\n      expect(await cacheHandler.get(\"isr/1\", getCtx)).toBeNull();\n    });\n\n    it(\"copies a live S3 entry into memory\", async () => {\n      const value: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>live</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n      const getCtx = {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      } as const;\n\n      (cacheHandler as any).s3DynamoHandler = {\n        get: jest.fn().mockResolvedValue({ lastModified: Date.now(), value }),\n      };\n      await cacheHandler.get(\"isr/2\", getCtx);\n\n      const s3 = {\n        get: jest.fn().mockResolvedValue(null),\n        isRevalidated: jest.fn().mockResolvedValue(false),\n      };\n      (cacheHandler as any).s3DynamoHandler = s3;\n      expect(await cacheHandler.get(\"isr/2\", getCtx)).toMatchObject({ value });\n      expect(s3.get).not.toHaveBeenCalled();\n    });\n\n    it(\"keeps the S3 entry's lastModified when copying it into memory\", async () => {\n      // Next.js ages the entry from `lastModified`, and the tag markers are\n      // compared against it. Stamping the time of the copy made a page a soft\n      // `revalidateTag` had made stale look newer than the stale mark.\n      const value: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>old</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n      const getCtx = {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      } as const;\n      const renderedAt = Date.now() - 60_000;\n\n      (cacheHandler as any).s3DynamoHandler = {\n        get: jest.fn().mockResolvedValue({ lastModified: renderedAt, value }),\n      };\n      await cacheHandler.get(\"isr/3\", getCtx);\n\n      const s3 = {\n        get: jest.fn().mockResolvedValue(null),\n        isRevalidated: jest.fn().mockResolvedValue(false),\n      };\n      (cacheHandler as any).s3DynamoHandler = s3;\n      expect(await cacheHandler.get(\"isr/3\", getCtx)).toEqual({\n        lastModified: renderedAt,\n        value,\n      });\n      expect(s3.isRevalidated).toHaveBeenCalledWith(\n        { lastModified: renderedAt, value },\n        getCtx,\n        \"isr/3\",\n      );\n    });\n\n    it(\"serves a memory hit with the lifetime it was rendered or stored with\", async () => {\n      const value: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>isr</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n      const getCtx = {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      } as const;\n      const s3 = {\n        set: jest.fn().mockResolvedValue(undefined),\n        get: jest.fn().mockResolvedValue({\n          lastModified: Date.now(),\n          value,\n          cacheControl: { revalidate: 30, expire: undefined },\n        }),\n        isRevalidated: jest.fn().mockResolvedValue(false),\n      };\n      (cacheHandler as any).s3DynamoHandler = s3;\n\n      // Rendered here: the lifetime `ResponseCache.set` passed.\n      await cacheHandler.set(\"isr/4\", value, {\n        cacheControl: { revalidate: 60, expire: 300 },\n        isRoutePPREnabled: false,\n        isFallback: false,\n      });\n      expect((await cacheHandler.get(\"isr/4\", getCtx))?.cacheControl).toEqual({\n        revalidate: 60,\n        expire: 300,\n      });\n\n      // Copied in from S3: the lifetime S3 stored.\n      await cacheHandler.get(\"isr/5\", getCtx);\n      s3.get.mockClear();\n      expect((await cacheHandler.get(\"isr/5\", getCtx))?.cacheControl).toEqual({\n        revalidate: 30,\n        expire: undefined,\n      });\n      expect(s3.get).not.toHaveBeenCalled();\n    });\n\n    it(\"does not serve a memory hit another instance's revalidateTag expired\", async () => {\n      // `revalidateTag` clears only the memory of the instance that ran it. Any\n      // other instance holding the page in memory answered from it for the\n      // whole memory TTL, and CloudFront - just invalidated - cached the stale\n      // page again. So a memory hit is checked against the tag markers too.\n      const value: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>stale</html>\",\n        rscData: undefined,\n        headers: { \"x-next-cache-tags\": \"_N_T_/blog\" },\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n      const getCtx = {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      } as const;\n\n      (cacheHandler as any).s3DynamoHandler = {\n        get: jest.fn().mockResolvedValue({ lastModified: Date.now(), value }),\n      };\n      await cacheHandler.get(\"blog\", getCtx);\n\n      // Another instance revalidated `_N_T_/blog`: the marker is newer than the\n      // memory copy, and S3 now answers with the entry expired.\n      const s3 = {\n        get: jest.fn().mockResolvedValue({ lastModified: -1, value }),\n        isRevalidated: jest.fn().mockResolvedValue(true),\n      };\n      (cacheHandler as any).s3DynamoHandler = s3;\n      expect(await cacheHandler.get(\"blog\", getCtx)).toEqual({\n        lastModified: -1,\n        value,\n      });\n      expect(s3.isRevalidated).toHaveBeenCalledWith(\n        expect.objectContaining({ value }),\n        getCtx,\n        \"blog\",\n      );\n      expect(s3.get).toHaveBeenCalledTimes(1);\n\n      // And the memory copy is gone rather than checked again next time.\n      s3.get.mockResolvedValue(null);\n      expect(await cacheHandler.get(\"blog\", getCtx)).toBeNull();\n    });\n\n    it(\"keeps memory entries across resetRequestCache\", async () => {\n      // Next.js calls it at the start of every request; clearing the shared\n      // memory cache there sent every read to S3.\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>reset</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n\n      // Add entry\n      await cacheHandler.set(\"reset-key\", testData, {\n        fetchCache: true as const,\n        tags: [\"reset-tag\"],\n      });\n\n      // Reset\n      await cacheHandler.resetRequestCache();\n\n      // Still answered from memory, without asking S3.\n      const s3 = {\n        get: jest.fn().mockResolvedValue(null),\n        isRevalidated: jest.fn().mockResolvedValue(false),\n      };\n      (cacheHandler as any).s3DynamoHandler = s3;\n      const result = await cacheHandler.get(\"reset-key\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n      expect(result?.value).toEqual(testData);\n      expect(s3.get).not.toHaveBeenCalled();\n    });\n  });\n\n  describe(\"Build-time behavior\", () => {\n    it(\"reads back a fetch entry it wrote, from memory and from disk\", async () => {\n      // `cacheComponents` prerenders each page twice: the first pass runs the\n      // `fetch` and `set`s it, the second must find it already cached or Next.js\n      // fails the build with \"encountered uncached or runtime data during\n      // prerendering\". A write-only build-time handler therefore makes\n      // `cache: 'force-cache'` unbuildable - measured against next.js's\n      // `test/e2e/app-dir/resume-data-cache`.\n      process.env.NEXT_PHASE = \"phase-production-build\";\n      process.env.CDK_NEXTJS_INIT_CACHE_DIR = mkdtempSync(\n        join(tmpdir(), \"cdk-nextjs-init-cache-\"),\n      );\n      try {\n        const data: IncrementalCacheValue = {\n          kind: CachedRouteKind.FETCH,\n          data: {\n            headers: {},\n            body: \"eyJyYW5kb20iOjF9\",\n            status: 200,\n            url: \"https://example.test/api/random\",\n          },\n          revalidate: 31536000,\n        };\n        const fetchUrl = \"https://example.test/api/random\";\n        const setCtx = {\n          fetchCache: true as const,\n          tags: [\"test\"],\n          fetchUrl,\n          fetchIdx: 1,\n        };\n        const getCtx: GetIncrementalFetchCacheContext = {\n          kind: IncrementalCacheKind.FETCH,\n          revalidate: 31536000,\n          fetchUrl,\n          fetchIdx: 1,\n          tags: [\"test\"],\n        };\n        const buildHandler = new CdkNextjsCacheHandler(createMockContext());\n        await buildHandler.set(\"fetch-key\", data, setCtx);\n        expect(await buildHandler.get(\"fetch-key\", getCtx)).toMatchObject({\n          value: data,\n        });\n\n        // A second instance reads the file rather than the map: `next build`\n        // renders pages in worker processes, so the pass that writes and the\n        // pass that reads are not always the same process.\n        const otherWorker = new CdkNextjsCacheHandler(createMockContext());\n        expect(await otherWorker.get(\"fetch-key\", getCtx)).toMatchObject({\n          value: data,\n        });\n        expect(await otherWorker.get(\"never-written\", getCtx)).toBeNull();\n      } finally {\n        delete process.env.NEXT_PHASE;\n        delete process.env.CDK_NEXTJS_INIT_CACHE_DIR;\n      }\n    });\n\n    // The seed is uploaded as written, so it must be filed under the name the\n    // runtime's `get` reads: for a name too long for S3, `cacheObjectName`'s.\n    it(\"files an over-long key where the runtime reads it\", async () => {\n      process.env.NEXT_PHASE = \"phase-production-build\";\n      const cacheDir = mkdtempSync(join(tmpdir(), \"cdk-nextjs-init-cache-\"));\n      process.env.CDK_NEXTJS_INIT_CACHE_DIR = cacheDir;\n      try {\n        const key = `/route-cache/APP_PAGE/${\"a\".repeat(64)}/$/${\"x\".repeat(900)}`;\n        expect(cacheObjectName(key)).toMatch(/^_long-key\\//);\n        const data: IncrementalCacheValue = {\n          kind: CachedRouteKind.FETCH,\n          data: { headers: {}, body: \"e30=\", status: 200, url: \"\" },\n          revalidate: 60,\n        };\n        const setCtx = { fetchCache: true as const, tags: [] };\n        await new CdkNextjsCacheHandler(createMockContext()).set(\n          key,\n          data,\n          setCtx,\n        );\n        expect(existsSync(join(cacheDir, cacheObjectName(key)))).toBe(true);\n        const getCtx: GetIncrementalFetchCacheContext = {\n          kind: IncrementalCacheKind.FETCH,\n          revalidate: 60,\n          tags: [],\n        };\n        expect(\n          await new CdkNextjsCacheHandler(createMockContext()).get(key, getCtx),\n        ).toMatchObject({ value: data });\n      } finally {\n        delete process.env.NEXT_PHASE;\n        delete process.env.CDK_NEXTJS_INIT_CACHE_DIR;\n      }\n    });\n  });\n});\n"]}

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

@@ -1,3 +1,4 @@
+import type { CacheControl } from "next/dist/server/lib/cache-control";
 import type { CacheHandler } from "next/dist/server/lib/incremental-cache";
 /**
  * Serialize cache value with custom handling for Map and Buffer objects
@@ -167,3 +168,24 @@ export type SetCacheHandlerContext = Parameters<CacheHandler["set"]>[2];
  * Helper to safely extract tags from context
  */
 export declare function getTags(ctx: SetCacheHandlerContext): string[] | undefined;
+/**
+ * The lifetime a response entry was rendered with: `ctx.cacheControl`, which
+ * `ResponseCache.set` passes and a `fetch` entry's `set` does not (its
+ * `revalidate` is inside the value).
+ *
+ * Stored with the entry and handed back from `get`, because next 16.4 prefers
+ * it there over its own per-process `SharedCacheControls`. Without it a fresh
+ * instance only knows what the prerender manifest recorded at build time, so a
+ * page whose lifetime was decided at render (`cacheLife`, a `fetch`'s
+ * `revalidate`, `getStaticProps` returning another `revalidate`) was aged by
+ * the build-time value until that instance rendered it itself, and a path the
+ * manifest does not cover by Next.js's default of 1 second: every cold Lambda
+ * served it stale and regenerated it. Older `next` ignores the field.
+ */
+export declare function getCacheControl(ctx: SetCacheHandlerContext): CacheControl | undefined;
+/**
+ * `value` if it is a {@link CacheControl}, as read back off a stored entry.
+ * Anything else is dropped rather than handed to Next.js, which ages the entry
+ * by it: Next.js then falls back to the lifetime it knows, as before 16.4.
+ */
+export declare function storedCacheControl(value: unknown): CacheControl | undefined;

package/lib/adapter/cache-utils.js

@@ -13,6 +13,8 @@ exports.groupPrerenders = groupPrerenders;
 exports.appPageCacheHeaders = appPageCacheHeaders;
 exports.headerTags = headerTags;
 exports.getTags = getTags;
+exports.getCacheControl = getCacheControl;
+exports.storedCacheControl = storedCacheControl;
 /*
   Shared cache utility functions
 */
@@ -385,4 +387,45 @@ exports.INIT_CACHE_TAG_MANIFEST = "_cdk-nextjs-tag-manifest.json";
 function getTags(ctx) {
     return "tags" in ctx ? ctx.tags : undefined;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache-utils.js","sourceRoot":"","sources":["../../src/adapter/cache-utils.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n  Shared cache utility functions\n*/\nimport { createHash } from \"node:crypto\";\nimport { sep } from \"node:path\";\nimport type { CacheHandler } from \"next/dist/server/lib/incremental-cache\";\nimport { hasPathPrefix } from \"../utils/base-path\";\n\n/**\n * Pre-process value to convert Buffers and Maps before JSON.stringify\n * This is necessary because Buffer.toJSON() is called before replacer functions\n */\nfunction preprocessValue(value: any): any {\n  // Handle null/undefined\n  if (value == null) {\n    return value;\n  }\n\n  // Convert Buffer to our custom format. base64, not the array of per-byte\n  // integers this used to write (and that `Buffer.toJSON()` writes) — see\n  // {@link parseCacheValue} for why that mattered so much.\n  if (Buffer.isBuffer(value)) {\n    return {\n      __type: \"Buffer\",\n      base64: value.toString(\"base64\"),\n    };\n  }\n\n  // Convert Map to our custom format\n  if (value instanceof Map) {\n    const entries: Record<string, any> = {};\n    for (const [key, val] of value.entries()) {\n      entries[key] = preprocessValue(val);\n    }\n    return {\n      __type: \"Map\",\n      data: entries,\n    };\n  }\n\n  // Recursively process arrays\n  if (Array.isArray(value)) {\n    return value.map((item) => preprocessValue(item));\n  }\n\n  // Recursively process objects\n  if (typeof value === \"object\") {\n    const processed: Record<string, any> = {};\n    for (const [key, val] of Object.entries(value)) {\n      processed[key] = preprocessValue(val);\n    }\n    return processed;\n  }\n\n  // Return primitives as-is\n  return value;\n}\n\n/**\n * Serialize cache value with custom handling for Map and Buffer objects\n */\nexport function serializeCacheValue(value: any): string {\n  // Pre-process to convert Buffers and Maps before JSON.stringify\n  // This ensures Buffer.toJSON() doesn't interfere\n  const processed = preprocessValue(value);\n  return JSON.stringify(processed);\n}\n\n/**\n * Parse cache value with custom handling for Map and Buffer objects\n *\n * Buffers are read back from base64 when that is how they were written, and from\n * an array of per-byte integers when they were not. That array is the format\n * `Buffer.toJSON()` produces and the one this code used to write, and it is\n * ruinous for a page with a large payload: a 1 MiB prerender became ~3 MiB of\n * JSON text, an 11.6 MiB cache entry once html and the per-segment copies are\n * counted, and — because `JSON.parse`'s reviver runs for *every array element* —\n * upwards of three million reviver calls to read one page. Measured against a\n * deployment: 4.8s of Lambda time to answer a 1 MiB segment prefetch, against\n * 45ms for a small one from the same cache. base64 is 4/3 the bytes rather than\n * ~3x, and `Buffer.from(str, \"base64\")` is one native call.\n */\nexport function parseCacheValue(jsonString: string): any {\n  return JSON.parse(jsonString, (_key, val) => {\n    // Restore Map objects that were serialized with __type marker\n    if (val && typeof val === \"object\" && val.__type === \"Map\") {\n      return new Map(Object.entries(val.data));\n    }\n    // Restore Buffer objects that were serialized with __type marker (our custom format)\n    if (val && typeof val === \"object\" && val.__type === \"Buffer\") {\n      return typeof val.base64 === \"string\"\n        ? Buffer.from(val.base64, \"base64\")\n        : Buffer.from(val.data);\n    }\n    // Restore Buffer objects that were serialized with Node.js default Buffer.toJSON() format\n    // This handles legacy cache entries or runtime-generated entries\n    if (\n      val &&\n      typeof val === \"object\" &&\n      val.type === \"Buffer\" &&\n      Array.isArray(val.data)\n    ) {\n      return Buffer.from(val.data);\n    }\n    return val;\n  });\n}\n\n/**\n * The cache key a prerendered route's seeded entry has to be written under.\n *\n * `ctx.outputs.prerenders[].pathname` is the *URL* the page is served at, so it\n * carries the app's `basePath`. The key the server later looks entries up under\n * is the route, which does not — Next.js strips `basePath` before routing, so the\n * cache handler never sees it at request time. Seeding `/prod/ssg/1` verbatim\n * therefore writes `<buildId>/prod/ssg/1.json` while the server asks for\n * `<buildId>/ssg/1.json`: every build-time prerender is a MISS that re-renders on\n * first request, and the page is only \"static\" from the second visit onwards.\n */\nexport function prerenderPathToCacheKey(\n  pathname: string,\n  basePath: string,\n): string {\n  // Matching on a path boundary so a sibling route like `/production` is not\n  // read as basePath `/prod` plus `uction`.\n  const route = (\n    hasPathPrefix(pathname, basePath)\n      ? pathname.slice(basePath.length)\n      : pathname\n  )\n    // Leading slashes would make an S3 key with an empty first segment.\n    .replace(/^\\/+/, \"\");\n  return route === \"\" ? \"index\" : route;\n}\n\n/** `buildS3Key` under the build prefix: `{cacheKey}.json`. */\nexport function cacheKeyFileName(cacheKey: string): string {\n  let cleanCacheKey = cacheKey;\n  if (cacheKey === \"/\" || cacheKey === \"\") {\n    cleanCacheKey = \"index\";\n  } else if (cacheKey.startsWith(\"/\")) {\n    cleanCacheKey = cacheKey.slice(1);\n  }\n  return `${cleanCacheKey}.json`;\n}\n\n/** `value`'s SHA-256 digest, in hex: 64 characters. */\nexport function sha256Hex(value: string): string {\n  return createHash(\"sha256\").update(value).digest(\"hex\");\n}\n\n/** S3's limit on an object key, in UTF-8 bytes. */\nconst MAX_S3_KEY_BYTES = 1024;\n\n/**\n * The longest build ID cache entries are stored under, which\n * {@link cacheObjectName} leaves room for in front of it with its `/`: a\n * Next.js build ID is 21 characters, and the `-<deploymentId>` cdk-nextjs\n * appends is the app's own, so the adapter fails a build whose ID is longer\n * (see `assertBuildIdFits`) rather than leave long names unwritable.\n */\nexport const MAX_BUILD_ID_BYTES = 127;\n\n/**\n * The folder under the build prefix that entries with an over-long key are\n * stored in. @see cacheObjectName\n */\nexport const LONG_KEY_PREFIX = \"_long-key\";\n\n/**\n * Where the entry `buildS3Key` names is stored, under the build prefix:\n * its own name, or `_long-key/{sha256}.long` for a name that would leave the\n * whole object key past S3's 1024 bytes. next 16.3.8's route-scoped keys are\n * ~88 bytes longer than a pathname, enough to push a long one over, and a\n * rejected `PutObject` meant the page was never cached.\n *\n * Only the object is moved: `buildS3Key` stays the entry's name for tag\n * mappings and CloudFront paths, since a hash names no route. Decided on the\n * name alone rather than the whole key so the init cache, which is written\n * without the build ID it is deployed under, files a seed where the runtime\n * reads it. The `.long` suffix keeps these disjoint from every `.json` name.\n */\nexport function cacheObjectName(cacheKey: string): string {\n  const name = cacheKeyFileName(cacheKey);\n  if (Buffer.byteLength(name) <= MAX_S3_KEY_BYTES - (MAX_BUILD_ID_BYTES + 1)) {\n    return name;\n  }\n  return `${LONG_KEY_PREFIX}/${sha256Hex(name)}.long`;\n}\n\n/**\n * The response-cache key next >= 16.3.8 stores a prerender under, read back off\n * the file `next build` wrote it to, or `undefined` before 16.3.8.\n *\n * From 16.3.8 Next.js scopes every page's cache key by its source route -\n * `/route-cache/<kind>/<sha256(sourceRoute)>/$<pathname>` (`getRouteCacheKey`\n * in `next/dist/server/lib/route-cache-key.js`) - and, with an adapter, writes\n * each prerender to `<distDir>/server/<key><ext>`. The file path is the only\n * place an adapter is handed that key, and re-deriving it would mean re-picking\n * the source route the way `build-complete.js` does.\n */\nexport function routeCacheKeyFromFilePath(\n  filePath: string | undefined,\n): string | undefined {\n  // The first `/server/route-cache/`: a route's own pathname can contain one\n  // after it. Before 16.3.8 a route of that name is all there is, which the\n  // prefix check below rejects.\n  const path = filePath?.split(sep).join(\"/\");\n  const at = path?.indexOf(ROUTE_CACHE_DIR) ?? -1;\n  if (at < 0) {\n    return undefined;\n  }\n  const key = path!.slice(at + \"/server/\".length).replace(/\\.[^./]+$/, \"\");\n  return ROUTE_CACHE_KEY_PREFIX.test(key) ? key : undefined;\n}\n\nconst ROUTE_CACHE_DIR = \"/server/route-cache/\";\n\n/**\n * The start of a next >= 16.3.8 response-cache key, leading slash dropped:\n * `route-cache/<kind>/<sha256(sourceRoute)>/$` (`getRouteCacheKey`), followed\n * by the pathname. Matched whole, so an older app's route that happens to be\n * named `/route-cache/...` is not read as one.\n */\nexport const ROUTE_CACHE_KEY_PREFIX =\n  /^route-cache\\/[A-Z_]+\\/[0-9a-f]{64}\\/\\$(?=\\/)/;\n\n/**\n * `denormalizePagePath` (`next/dist/shared/lib/page-path/denormalize-page-path.js`),\n * the inverse of the `normalizePagePath` a route-cache key's pathname goes\n * through: `/index` back to `/`, and `/index/...` - how `/index` itself and\n * every path under it are spelled - back to `/...`. Restated without its\n * dynamic-route check: `s3KeyToInvalidationPath` has dropped those already.\n */\nexport function denormalizePagePath(pagePath: string): string {\n  if (pagePath === \"/index\") {\n    return \"/\";\n  }\n  return pagePath.startsWith(\"/index/\")\n    ? pagePath.slice(\"/index\".length)\n    : pagePath;\n}\n\n/** The outputs one route contributes to `ctx.outputs.prerenders`. */\nexport interface PrerenderVariants<T> {\n  /** The HTML render. Its pathname is the route, with no suffix. */\n  html?: T;\n  /** The flight payload, built as `<route>.rsc` — but see {@link groupPrerenders}. */\n  rsc?: T;\n  /** Per-segment flight payloads, under `<route>.segments/`. */\n  segments: T[];\n  /** A Pages Router route's `pageData`, built as its `/_next/data/` route. */\n  data?: T;\n}\n\nconst INDEX_SUFFIX = \"/index\";\n\n/**\n * A Pages Router data route: `/_next/data/<buildId>/<page>.json`, optionally\n * behind a `basePath` (`normalizePathname` in Next.js's `build-complete` prefixes\n * every output pathname, this one included).\n *\n * Capture 1 is that prefix and capture 2 the page path without its `.json`, so\n * `/prod/_next/data/abc123/blog/hello.json` recomposes to `/prod/blog/hello`.\n */\nconst PAGES_DATA_PATHNAME = /^(.*)\\/_next\\/data\\/[^/]+\\/(.+)\\.json$/;\n\n/**\n * Collect `ctx.outputs.prerenders` into one entry per route.\n *\n * Next.js emits up to three shapes per prerendered App Router route — `/blog/hello`,\n * `/blog/hello.rsc`, and `/blog/hello.segments/*.segment.rsc` — and a cache entry\n * needs all of them together, so they have to be grouped by route before anything\n * can be seeded. A Pages Router route emits two: the HTML, and its `pageData` at\n * the route's `/_next/data/<buildId>/<page>.json` pathname\n * ({@link PAGES_DATA_PATHNAME}). That one is not a suffix of the page's own\n * pathname, so it is matched rather than stripped.\n *\n * The one case that is not a suffix strip is the **root route**, which cannot be\n * named `/.rsc`: its payloads are emitted under `/index.rsc` and\n * `/index.segments/` while its HTML stays at `/` (or at the `basePath`, e.g.\n * `/prod` and `/prod/index.rsc`). Reconstructing names by concatenation therefore\n * silently loses the home page's `rscData` — and with a `basePath` also its\n * `segmentData`, because `/prod` and `/prod/index` group apart. That is not a\n * cosmetic gap: `app-page-runtime.js` answers an RSC request for an entry with no\n * `rscData` by checking `cachedData.html.contentType`, and under `cacheComponents`\n * sends an empty `404`. Every client-side navigation to `/` breaks.\n *\n * The remap is conditional rather than unconditional so that an app with a real\n * page at `app/index/page.tsx` — whose HTML prerender genuinely is `/index` — keeps\n * its own group.\n */\nexport function groupPrerenders<T extends { pathname: string }>(\n  prerenders: T[],\n): Map<string, PrerenderVariants<T>> {\n  const htmlPathnames = new Set(\n    prerenders\n      .map((p) => p.pathname)\n      .filter(\n        (p) =>\n          !p.endsWith(\".rsc\") &&\n          !p.includes(\".segments/\") &&\n          !PAGES_DATA_PATHNAME.test(p),\n      ),\n  );\n  const groups = new Map<string, PrerenderVariants<T>>();\n\n  const variantsFor = (base: string): PrerenderVariants<T> => {\n    let variants = groups.get(base);\n    if (!variants) {\n      variants = { segments: [] };\n      groups.set(base, variants);\n    }\n    return variants;\n  };\n\n  /** `/index.rsc` belongs to `/`, `/prod/index.rsc` to `/prod`. */\n  const routeOf = (base: string): string => {\n    if (base.endsWith(INDEX_SUFFIX) && !htmlPathnames.has(base)) {\n      const parent = base.slice(0, -INDEX_SUFFIX.length) || \"/\";\n      if (htmlPathnames.has(parent)) {\n        return parent;\n      }\n    }\n    return base;\n  };\n\n  for (const prerender of prerenders) {\n    const { pathname } = prerender;\n    const dataRoute = PAGES_DATA_PATHNAME.exec(pathname);\n    if (dataRoute) {\n      variantsFor(routeOf(`${dataRoute[1]}/${dataRoute[2]}`)).data = prerender;\n    } else if (pathname.includes(\".segments/\")) {\n      variantsFor(routeOf(pathname.split(\".segments/\")[0])).segments.push(\n        prerender,\n      );\n    } else if (pathname.endsWith(\".rsc\")) {\n      variantsFor(routeOf(pathname.slice(0, -\".rsc\".length))).rsc = prerender;\n    } else {\n      variantsFor(pathname).html = prerender;\n    }\n  }\n\n  return groups;\n}\n\n/**\n * Headers that must not be seeded into an `APP_PAGE` cache entry, even though the\n * adapter output lists them in `fallback.initialHeaders`.\n *\n * `initialHeaders` describes how a platform should serve the prerendered *file*\n * straight off a CDN. A cache entry is a different thing: `app-page-runtime.js`\n * `appendHeader`s `cachedData.headers` onto the response and *then* serves the\n * variant the request actually asked for, so anything presentational in there is\n * either wrong or doubled. At request time Next.js stores only what the render\n * put in `metadata.headers` — `x-nextjs-stale-time`, `x-next-cache-tags`, and\n * whatever the app set through `headers()`/`cookies()` — and never these four.\n *\n * `content-type` is the one that actually breaks. `send-payload.js` sets the type\n * only when the response does not already have one\n * (`if (!res.getHeader('Content-Type') && result.contentType)`), so a seeded\n * `text/html; charset=utf-8` makes every RSC request to a prerendered page answer\n * the flight payload labeled as HTML. The client router rejects that, and so does\n * Next.js itself: `createRedirectRenderResult` checks the content type of the\n * sub-response it fetches to stream an action `redirect()`, and on a mismatch\n * cancels the body and returns an empty result.\n *\n * `vary`, `x-nextjs-prerender`, and `x-nextjs-postponed` are all set by the\n * entrypoint itself, so seeding them only produces two of each.\n *\n * `APP_ROUTE` entries are deliberately *not* filtered: a route handler's\n * `content-type` is part of its cached response, and `app-route.js` replays those\n * headers verbatim.\n */\nconst NON_CACHEABLE_APP_PAGE_HEADERS = new Set([\n  \"content-type\",\n  \"vary\",\n  \"x-nextjs-prerender\",\n  \"x-nextjs-postponed\",\n]);\n\n/** See {@link NON_CACHEABLE_APP_PAGE_HEADERS}. */\nexport function appPageCacheHeaders<T>(\n  initialHeaders: Record<string, T>,\n): Record<string, T> {\n  const headers: Record<string, T> = {};\n  for (const [name, value] of Object.entries(initialHeaders)) {\n    if (!NON_CACHEABLE_APP_PAGE_HEADERS.has(name.toLowerCase())) {\n      headers[name] = value;\n    }\n  }\n  return headers;\n}\n\n/** `NEXT_CACHE_TAGS_HEADER`, inlined so this file imports no Next.js internals. */\nconst NEXT_CACHE_TAGS_HEADER = \"x-next-cache-tags\";\n\n/**\n * The tags a cache value's render was tagged with, as Next.js records them: in\n * its `x-next-cache-tags` header, comma separated, including the implicit\n * `_N_T_/…` path chain `revalidatePath` uses. One parser for the build's tag\n * manifest and the runtime's mapping rows, which have to agree.\n *\n * `value` is `unknown` because it arrives both as a stored entry read back from\n * S3 and as the `IncrementalCacheValue` union; only some members have headers.\n */\nexport function headerTags(value: unknown): string[] {\n  const headers = (value as { headers?: Record<string, unknown> } | null)\n    ?.headers;\n  const header = headers?.[NEXT_CACHE_TAGS_HEADER];\n  return typeof header === \"string\" ? header.split(\",\").filter(Boolean) : [];\n}\n\n/**\n * Name of the file the adapter writes into the init cache directory mapping each\n * cache tag to the cache keys of the build-time prerenders carrying it.\n *\n * It rides to S3 with the rest of the init cache, and `S3CacheHandler`'s\n * `revalidateTag` reads it alongside the `tag#cacheKey` rows a runtime `set`\n * writes. Without it `revalidateTag` knows a prerender is stale (see\n * `checkIfRevalidated`) but not which CloudFront paths to invalidate, so the CDN\n * keeps serving the old response until its TTL expires - a year, for a\n * prerender.\n *\n * The leading underscore keeps it clear of cache keys, which are route paths.\n */\nexport const INIT_CACHE_TAG_MANIFEST = \"_cdk-nextjs-tag-manifest.json\";\n\n/** Contents of {@link INIT_CACHE_TAG_MANIFEST}: tag -> init cache keys. */\nexport type InitCacheTagManifest = Record<string, string[]>;\n\n/**\n * The `ctx` Next.js passes a `CacheHandler`'s `get`, taken off its interface:\n * the fetch cache's, a route response's, or - since this handler is also\n * `ImageOptimizerCache`'s - an optimized image's.\n */\nexport type GetCacheHandlerContext = Parameters<CacheHandler[\"get\"]>[1];\n\n/** The `ctx` Next.js passes a `CacheHandler`'s `set`. See {@link GetCacheHandlerContext}. */\nexport type SetCacheHandlerContext = Parameters<CacheHandler[\"set\"]>[2];\n\n/**\n * Helper to safely extract tags from context\n */\nexport function getTags(ctx: SetCacheHandlerContext): string[] | undefined {\n  return \"tags\" in ctx ? ctx.tags : undefined;\n}\n"]}
+/**
+ * The lifetime a response entry was rendered with: `ctx.cacheControl`, which
+ * `ResponseCache.set` passes and a `fetch` entry's `set` does not (its
+ * `revalidate` is inside the value).
+ *
+ * Stored with the entry and handed back from `get`, because next 16.4 prefers
+ * it there over its own per-process `SharedCacheControls`. Without it a fresh
+ * instance only knows what the prerender manifest recorded at build time, so a
+ * page whose lifetime was decided at render (`cacheLife`, a `fetch`'s
+ * `revalidate`, `getStaticProps` returning another `revalidate`) was aged by
+ * the build-time value until that instance rendered it itself, and a path the
+ * manifest does not cover by Next.js's default of 1 second: every cold Lambda
+ * served it stale and regenerated it. Older `next` ignores the field.
+ */
+function getCacheControl(ctx) {
+    return "cacheControl" in ctx
+        ? storedCacheControl(ctx.cacheControl)
+        : undefined;
+}
+/**
+ * `value` if it is a {@link CacheControl}, as read back off a stored entry.
+ * Anything else is dropped rather than handed to Next.js, which ages the entry
+ * by it: Next.js then falls back to the lifetime it knows, as before 16.4.
+ */
+function storedCacheControl(value) {
+    if (typeof value !== "object" || value === null) {
+        return undefined;
+    }
+    const { revalidate, expire } = value;
+    if (revalidate !== false &&
+        !(typeof revalidate === "number" &&
+            Number.isFinite(revalidate) &&
+            revalidate > 0)) {
+        return undefined;
+    }
+    // Finite: JSON writes `Infinity` and `NaN` as `null`.
+    if (expire !== undefined && !Number.isFinite(expire)) {
+        return undefined;
+    }
+    return { revalidate, expire };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache-utils.js","sourceRoot":"","sources":["../../src/adapter/cache-utils.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n  Shared cache utility functions\n*/\nimport { createHash } from \"node:crypto\";\nimport { sep } from \"node:path\";\nimport type { CacheControl } from \"next/dist/server/lib/cache-control\";\nimport type { CacheHandler } from \"next/dist/server/lib/incremental-cache\";\nimport { hasPathPrefix } from \"../utils/base-path\";\n\n/**\n * Pre-process value to convert Buffers and Maps before JSON.stringify\n * This is necessary because Buffer.toJSON() is called before replacer functions\n */\nfunction preprocessValue(value: any): any {\n  // Handle null/undefined\n  if (value == null) {\n    return value;\n  }\n\n  // Convert Buffer to our custom format. base64, not the array of per-byte\n  // integers this used to write (and that `Buffer.toJSON()` writes) — see\n  // {@link parseCacheValue} for why that mattered so much.\n  if (Buffer.isBuffer(value)) {\n    return {\n      __type: \"Buffer\",\n      base64: value.toString(\"base64\"),\n    };\n  }\n\n  // Convert Map to our custom format\n  if (value instanceof Map) {\n    const entries: Record<string, any> = {};\n    for (const [key, val] of value.entries()) {\n      entries[key] = preprocessValue(val);\n    }\n    return {\n      __type: \"Map\",\n      data: entries,\n    };\n  }\n\n  // Recursively process arrays\n  if (Array.isArray(value)) {\n    return value.map((item) => preprocessValue(item));\n  }\n\n  // Recursively process objects\n  if (typeof value === \"object\") {\n    const processed: Record<string, any> = {};\n    for (const [key, val] of Object.entries(value)) {\n      processed[key] = preprocessValue(val);\n    }\n    return processed;\n  }\n\n  // Return primitives as-is\n  return value;\n}\n\n/**\n * Serialize cache value with custom handling for Map and Buffer objects\n */\nexport function serializeCacheValue(value: any): string {\n  // Pre-process to convert Buffers and Maps before JSON.stringify\n  // This ensures Buffer.toJSON() doesn't interfere\n  const processed = preprocessValue(value);\n  return JSON.stringify(processed);\n}\n\n/**\n * Parse cache value with custom handling for Map and Buffer objects\n *\n * Buffers are read back from base64 when that is how they were written, and from\n * an array of per-byte integers when they were not. That array is the format\n * `Buffer.toJSON()` produces and the one this code used to write, and it is\n * ruinous for a page with a large payload: a 1 MiB prerender became ~3 MiB of\n * JSON text, an 11.6 MiB cache entry once html and the per-segment copies are\n * counted, and — because `JSON.parse`'s reviver runs for *every array element* —\n * upwards of three million reviver calls to read one page. Measured against a\n * deployment: 4.8s of Lambda time to answer a 1 MiB segment prefetch, against\n * 45ms for a small one from the same cache. base64 is 4/3 the bytes rather than\n * ~3x, and `Buffer.from(str, \"base64\")` is one native call.\n */\nexport function parseCacheValue(jsonString: string): any {\n  return JSON.parse(jsonString, (_key, val) => {\n    // Restore Map objects that were serialized with __type marker\n    if (val && typeof val === \"object\" && val.__type === \"Map\") {\n      return new Map(Object.entries(val.data));\n    }\n    // Restore Buffer objects that were serialized with __type marker (our custom format)\n    if (val && typeof val === \"object\" && val.__type === \"Buffer\") {\n      return typeof val.base64 === \"string\"\n        ? Buffer.from(val.base64, \"base64\")\n        : Buffer.from(val.data);\n    }\n    // Restore Buffer objects that were serialized with Node.js default Buffer.toJSON() format\n    // This handles legacy cache entries or runtime-generated entries\n    if (\n      val &&\n      typeof val === \"object\" &&\n      val.type === \"Buffer\" &&\n      Array.isArray(val.data)\n    ) {\n      return Buffer.from(val.data);\n    }\n    return val;\n  });\n}\n\n/**\n * The cache key a prerendered route's seeded entry has to be written under.\n *\n * `ctx.outputs.prerenders[].pathname` is the *URL* the page is served at, so it\n * carries the app's `basePath`. The key the server later looks entries up under\n * is the route, which does not — Next.js strips `basePath` before routing, so the\n * cache handler never sees it at request time. Seeding `/prod/ssg/1` verbatim\n * therefore writes `<buildId>/prod/ssg/1.json` while the server asks for\n * `<buildId>/ssg/1.json`: every build-time prerender is a MISS that re-renders on\n * first request, and the page is only \"static\" from the second visit onwards.\n */\nexport function prerenderPathToCacheKey(\n  pathname: string,\n  basePath: string,\n): string {\n  // Matching on a path boundary so a sibling route like `/production` is not\n  // read as basePath `/prod` plus `uction`.\n  const route = (\n    hasPathPrefix(pathname, basePath)\n      ? pathname.slice(basePath.length)\n      : pathname\n  )\n    // Leading slashes would make an S3 key with an empty first segment.\n    .replace(/^\\/+/, \"\");\n  return route === \"\" ? \"index\" : route;\n}\n\n/** `buildS3Key` under the build prefix: `{cacheKey}.json`. */\nexport function cacheKeyFileName(cacheKey: string): string {\n  let cleanCacheKey = cacheKey;\n  if (cacheKey === \"/\" || cacheKey === \"\") {\n    cleanCacheKey = \"index\";\n  } else if (cacheKey.startsWith(\"/\")) {\n    cleanCacheKey = cacheKey.slice(1);\n  }\n  return `${cleanCacheKey}.json`;\n}\n\n/** `value`'s SHA-256 digest, in hex: 64 characters. */\nexport function sha256Hex(value: string): string {\n  return createHash(\"sha256\").update(value).digest(\"hex\");\n}\n\n/** S3's limit on an object key, in UTF-8 bytes. */\nconst MAX_S3_KEY_BYTES = 1024;\n\n/**\n * The longest build ID cache entries are stored under, which\n * {@link cacheObjectName} leaves room for in front of it with its `/`: a\n * Next.js build ID is 21 characters, and the `-<deploymentId>` cdk-nextjs\n * appends is the app's own, so the adapter fails a build whose ID is longer\n * (see `assertBuildIdFits`) rather than leave long names unwritable.\n */\nexport const MAX_BUILD_ID_BYTES = 127;\n\n/**\n * The folder under the build prefix that entries with an over-long key are\n * stored in. @see cacheObjectName\n */\nexport const LONG_KEY_PREFIX = \"_long-key\";\n\n/**\n * Where the entry `buildS3Key` names is stored, under the build prefix:\n * its own name, or `_long-key/{sha256}.long` for a name that would leave the\n * whole object key past S3's 1024 bytes. next 16.3.8's route-scoped keys are\n * ~88 bytes longer than a pathname, enough to push a long one over, and a\n * rejected `PutObject` meant the page was never cached.\n *\n * Only the object is moved: `buildS3Key` stays the entry's name for tag\n * mappings and CloudFront paths, since a hash names no route. Decided on the\n * name alone rather than the whole key so the init cache, which is written\n * without the build ID it is deployed under, files a seed where the runtime\n * reads it. The `.long` suffix keeps these disjoint from every `.json` name.\n */\nexport function cacheObjectName(cacheKey: string): string {\n  const name = cacheKeyFileName(cacheKey);\n  if (Buffer.byteLength(name) <= MAX_S3_KEY_BYTES - (MAX_BUILD_ID_BYTES + 1)) {\n    return name;\n  }\n  return `${LONG_KEY_PREFIX}/${sha256Hex(name)}.long`;\n}\n\n/**\n * The response-cache key next >= 16.3.8 stores a prerender under, read back off\n * the file `next build` wrote it to, or `undefined` before 16.3.8.\n *\n * From 16.3.8 Next.js scopes every page's cache key by its source route -\n * `/route-cache/<kind>/<sha256(sourceRoute)>/$<pathname>` (`getRouteCacheKey`\n * in `next/dist/server/lib/route-cache-key.js`) - and, with an adapter, writes\n * each prerender to `<distDir>/server/<key><ext>`. The file path is the only\n * place an adapter is handed that key, and re-deriving it would mean re-picking\n * the source route the way `build-complete.js` does.\n */\nexport function routeCacheKeyFromFilePath(\n  filePath: string | undefined,\n): string | undefined {\n  // The first `/server/route-cache/`: a route's own pathname can contain one\n  // after it. Before 16.3.8 a route of that name is all there is, which the\n  // prefix check below rejects.\n  const path = filePath?.split(sep).join(\"/\");\n  const at = path?.indexOf(ROUTE_CACHE_DIR) ?? -1;\n  if (at < 0) {\n    return undefined;\n  }\n  const key = path!.slice(at + \"/server/\".length).replace(/\\.[^./]+$/, \"\");\n  return ROUTE_CACHE_KEY_PREFIX.test(key) ? key : undefined;\n}\n\nconst ROUTE_CACHE_DIR = \"/server/route-cache/\";\n\n/**\n * The start of a next >= 16.3.8 response-cache key, leading slash dropped:\n * `route-cache/<kind>/<sha256(sourceRoute)>/$` (`getRouteCacheKey`), followed\n * by the pathname. Matched whole, so an older app's route that happens to be\n * named `/route-cache/...` is not read as one.\n */\nexport const ROUTE_CACHE_KEY_PREFIX =\n  /^route-cache\\/[A-Z_]+\\/[0-9a-f]{64}\\/\\$(?=\\/)/;\n\n/**\n * `denormalizePagePath` (`next/dist/shared/lib/page-path/denormalize-page-path.js`),\n * the inverse of the `normalizePagePath` a route-cache key's pathname goes\n * through: `/index` back to `/`, and `/index/...` - how `/index` itself and\n * every path under it are spelled - back to `/...`. Restated without its\n * dynamic-route check: `s3KeyToInvalidationPath` has dropped those already.\n */\nexport function denormalizePagePath(pagePath: string): string {\n  if (pagePath === \"/index\") {\n    return \"/\";\n  }\n  return pagePath.startsWith(\"/index/\")\n    ? pagePath.slice(\"/index\".length)\n    : pagePath;\n}\n\n/** The outputs one route contributes to `ctx.outputs.prerenders`. */\nexport interface PrerenderVariants<T> {\n  /** The HTML render. Its pathname is the route, with no suffix. */\n  html?: T;\n  /** The flight payload, built as `<route>.rsc` — but see {@link groupPrerenders}. */\n  rsc?: T;\n  /** Per-segment flight payloads, under `<route>.segments/`. */\n  segments: T[];\n  /** A Pages Router route's `pageData`, built as its `/_next/data/` route. */\n  data?: T;\n}\n\nconst INDEX_SUFFIX = \"/index\";\n\n/**\n * A Pages Router data route: `/_next/data/<buildId>/<page>.json`, optionally\n * behind a `basePath` (`normalizePathname` in Next.js's `build-complete` prefixes\n * every output pathname, this one included).\n *\n * Capture 1 is that prefix and capture 2 the page path without its `.json`, so\n * `/prod/_next/data/abc123/blog/hello.json` recomposes to `/prod/blog/hello`.\n */\nconst PAGES_DATA_PATHNAME = /^(.*)\\/_next\\/data\\/[^/]+\\/(.+)\\.json$/;\n\n/**\n * Collect `ctx.outputs.prerenders` into one entry per route.\n *\n * Next.js emits up to three shapes per prerendered App Router route — `/blog/hello`,\n * `/blog/hello.rsc`, and `/blog/hello.segments/*.segment.rsc` — and a cache entry\n * needs all of them together, so they have to be grouped by route before anything\n * can be seeded. A Pages Router route emits two: the HTML, and its `pageData` at\n * the route's `/_next/data/<buildId>/<page>.json` pathname\n * ({@link PAGES_DATA_PATHNAME}). That one is not a suffix of the page's own\n * pathname, so it is matched rather than stripped.\n *\n * The one case that is not a suffix strip is the **root route**, which cannot be\n * named `/.rsc`: its payloads are emitted under `/index.rsc` and\n * `/index.segments/` while its HTML stays at `/` (or at the `basePath`, e.g.\n * `/prod` and `/prod/index.rsc`). Reconstructing names by concatenation therefore\n * silently loses the home page's `rscData` — and with a `basePath` also its\n * `segmentData`, because `/prod` and `/prod/index` group apart. That is not a\n * cosmetic gap: `app-page-runtime.js` answers an RSC request for an entry with no\n * `rscData` by checking `cachedData.html.contentType`, and under `cacheComponents`\n * sends an empty `404`. Every client-side navigation to `/` breaks.\n *\n * The remap is conditional rather than unconditional so that an app with a real\n * page at `app/index/page.tsx` — whose HTML prerender genuinely is `/index` — keeps\n * its own group.\n */\nexport function groupPrerenders<T extends { pathname: string }>(\n  prerenders: T[],\n): Map<string, PrerenderVariants<T>> {\n  const htmlPathnames = new Set(\n    prerenders\n      .map((p) => p.pathname)\n      .filter(\n        (p) =>\n          !p.endsWith(\".rsc\") &&\n          !p.includes(\".segments/\") &&\n          !PAGES_DATA_PATHNAME.test(p),\n      ),\n  );\n  const groups = new Map<string, PrerenderVariants<T>>();\n\n  const variantsFor = (base: string): PrerenderVariants<T> => {\n    let variants = groups.get(base);\n    if (!variants) {\n      variants = { segments: [] };\n      groups.set(base, variants);\n    }\n    return variants;\n  };\n\n  /** `/index.rsc` belongs to `/`, `/prod/index.rsc` to `/prod`. */\n  const routeOf = (base: string): string => {\n    if (base.endsWith(INDEX_SUFFIX) && !htmlPathnames.has(base)) {\n      const parent = base.slice(0, -INDEX_SUFFIX.length) || \"/\";\n      if (htmlPathnames.has(parent)) {\n        return parent;\n      }\n    }\n    return base;\n  };\n\n  for (const prerender of prerenders) {\n    const { pathname } = prerender;\n    const dataRoute = PAGES_DATA_PATHNAME.exec(pathname);\n    if (dataRoute) {\n      variantsFor(routeOf(`${dataRoute[1]}/${dataRoute[2]}`)).data = prerender;\n    } else if (pathname.includes(\".segments/\")) {\n      variantsFor(routeOf(pathname.split(\".segments/\")[0])).segments.push(\n        prerender,\n      );\n    } else if (pathname.endsWith(\".rsc\")) {\n      variantsFor(routeOf(pathname.slice(0, -\".rsc\".length))).rsc = prerender;\n    } else {\n      variantsFor(pathname).html = prerender;\n    }\n  }\n\n  return groups;\n}\n\n/**\n * Headers that must not be seeded into an `APP_PAGE` cache entry, even though the\n * adapter output lists them in `fallback.initialHeaders`.\n *\n * `initialHeaders` describes how a platform should serve the prerendered *file*\n * straight off a CDN. A cache entry is a different thing: `app-page-runtime.js`\n * `appendHeader`s `cachedData.headers` onto the response and *then* serves the\n * variant the request actually asked for, so anything presentational in there is\n * either wrong or doubled. At request time Next.js stores only what the render\n * put in `metadata.headers` — `x-nextjs-stale-time`, `x-next-cache-tags`, and\n * whatever the app set through `headers()`/`cookies()` — and never these four.\n *\n * `content-type` is the one that actually breaks. `send-payload.js` sets the type\n * only when the response does not already have one\n * (`if (!res.getHeader('Content-Type') && result.contentType)`), so a seeded\n * `text/html; charset=utf-8` makes every RSC request to a prerendered page answer\n * the flight payload labeled as HTML. The client router rejects that, and so does\n * Next.js itself: `createRedirectRenderResult` checks the content type of the\n * sub-response it fetches to stream an action `redirect()`, and on a mismatch\n * cancels the body and returns an empty result.\n *\n * `vary`, `x-nextjs-prerender`, and `x-nextjs-postponed` are all set by the\n * entrypoint itself, so seeding them only produces two of each.\n *\n * `APP_ROUTE` entries are deliberately *not* filtered: a route handler's\n * `content-type` is part of its cached response, and `app-route.js` replays those\n * headers verbatim.\n */\nconst NON_CACHEABLE_APP_PAGE_HEADERS = new Set([\n  \"content-type\",\n  \"vary\",\n  \"x-nextjs-prerender\",\n  \"x-nextjs-postponed\",\n]);\n\n/** See {@link NON_CACHEABLE_APP_PAGE_HEADERS}. */\nexport function appPageCacheHeaders<T>(\n  initialHeaders: Record<string, T>,\n): Record<string, T> {\n  const headers: Record<string, T> = {};\n  for (const [name, value] of Object.entries(initialHeaders)) {\n    if (!NON_CACHEABLE_APP_PAGE_HEADERS.has(name.toLowerCase())) {\n      headers[name] = value;\n    }\n  }\n  return headers;\n}\n\n/** `NEXT_CACHE_TAGS_HEADER`, inlined so this file imports no Next.js internals. */\nconst NEXT_CACHE_TAGS_HEADER = \"x-next-cache-tags\";\n\n/**\n * The tags a cache value's render was tagged with, as Next.js records them: in\n * its `x-next-cache-tags` header, comma separated, including the implicit\n * `_N_T_/…` path chain `revalidatePath` uses. One parser for the build's tag\n * manifest and the runtime's mapping rows, which have to agree.\n *\n * `value` is `unknown` because it arrives both as a stored entry read back from\n * S3 and as the `IncrementalCacheValue` union; only some members have headers.\n */\nexport function headerTags(value: unknown): string[] {\n  const headers = (value as { headers?: Record<string, unknown> } | null)\n    ?.headers;\n  const header = headers?.[NEXT_CACHE_TAGS_HEADER];\n  return typeof header === \"string\" ? header.split(\",\").filter(Boolean) : [];\n}\n\n/**\n * Name of the file the adapter writes into the init cache directory mapping each\n * cache tag to the cache keys of the build-time prerenders carrying it.\n *\n * It rides to S3 with the rest of the init cache, and `S3CacheHandler`'s\n * `revalidateTag` reads it alongside the `tag#cacheKey` rows a runtime `set`\n * writes. Without it `revalidateTag` knows a prerender is stale (see\n * `checkIfRevalidated`) but not which CloudFront paths to invalidate, so the CDN\n * keeps serving the old response until its TTL expires - a year, for a\n * prerender.\n *\n * The leading underscore keeps it clear of cache keys, which are route paths.\n */\nexport const INIT_CACHE_TAG_MANIFEST = \"_cdk-nextjs-tag-manifest.json\";\n\n/** Contents of {@link INIT_CACHE_TAG_MANIFEST}: tag -> init cache keys. */\nexport type InitCacheTagManifest = Record<string, string[]>;\n\n/**\n * The `ctx` Next.js passes a `CacheHandler`'s `get`, taken off its interface:\n * the fetch cache's, a route response's, or - since this handler is also\n * `ImageOptimizerCache`'s - an optimized image's.\n */\nexport type GetCacheHandlerContext = Parameters<CacheHandler[\"get\"]>[1];\n\n/** The `ctx` Next.js passes a `CacheHandler`'s `set`. See {@link GetCacheHandlerContext}. */\nexport type SetCacheHandlerContext = Parameters<CacheHandler[\"set\"]>[2];\n\n/**\n * Helper to safely extract tags from context\n */\nexport function getTags(ctx: SetCacheHandlerContext): string[] | undefined {\n  return \"tags\" in ctx ? ctx.tags : undefined;\n}\n\n/**\n * The lifetime a response entry was rendered with: `ctx.cacheControl`, which\n * `ResponseCache.set` passes and a `fetch` entry's `set` does not (its\n * `revalidate` is inside the value).\n *\n * Stored with the entry and handed back from `get`, because next 16.4 prefers\n * it there over its own per-process `SharedCacheControls`. Without it a fresh\n * instance only knows what the prerender manifest recorded at build time, so a\n * page whose lifetime was decided at render (`cacheLife`, a `fetch`'s\n * `revalidate`, `getStaticProps` returning another `revalidate`) was aged by\n * the build-time value until that instance rendered it itself, and a path the\n * manifest does not cover by Next.js's default of 1 second: every cold Lambda\n * served it stale and regenerated it. Older `next` ignores the field.\n */\nexport function getCacheControl(\n  ctx: SetCacheHandlerContext,\n): CacheControl | undefined {\n  return \"cacheControl\" in ctx\n    ? storedCacheControl(ctx.cacheControl)\n    : undefined;\n}\n\n/**\n * `value` if it is a {@link CacheControl}, as read back off a stored entry.\n * Anything else is dropped rather than handed to Next.js, which ages the entry\n * by it: Next.js then falls back to the lifetime it knows, as before 16.4.\n */\nexport function storedCacheControl(value: unknown): CacheControl | undefined {\n  if (typeof value !== \"object\" || value === null) {\n    return undefined;\n  }\n  const { revalidate, expire } = value as Partial<CacheControl>;\n  if (\n    revalidate !== false &&\n    !(\n      typeof revalidate === \"number\" &&\n      Number.isFinite(revalidate) &&\n      revalidate > 0\n    )\n  ) {\n    return undefined;\n  }\n  // Finite: JSON writes `Infinity` and `NaN` as `null`.\n  if (expire !== undefined && !Number.isFinite(expire)) {\n    return undefined;\n  }\n  return { revalidate, expire };\n}\n"]}