cdk-nextjs 0.6.2 → 0.7.0

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

@@ -1,6 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable import/no-extraneous-dependencies */
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+// What `require.cache` holds in a running server. Jest's `createRequire` hands
+// out a cache of its own that nothing is ever loaded into, so the handler's
+// lookup of Next.js's tag manifest reads this stand-in instead.
+const mockModuleCache = {};
+jest.mock("node:module", () => ({
+    ...jest.requireActual("node:module"),
+    createRequire: () => ({ cache: mockModuleCache }),
+}));
 // Mock AWS SDK
 jest.mock("@aws-sdk/client-s3");
 jest.mock("@aws-sdk/client-dynamodb");
@@ -11,6 +22,8 @@ const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
 const client_s3_1 = require("@aws-sdk/client-s3");
 const client_ssm_1 = require("@aws-sdk/client-ssm");
 const s3_cache_handler_1 = require("./s3-cache-handler");
+const use_cache_common_1 = require("./use-cache-common");
+const manifest_1 = require("../runtime/manifest");
 const mockS3Send = jest.fn();
 const mockDynamoSend = jest.fn();
 const mockCloudFrontSend = jest.fn();
@@ -30,13 +43,60 @@ client_ssm_1.SSMClient.mockImplementation(() => ({
 describe("S3DynamoCacheHandler", () => {
     let handler;
     let mockContext;
+    let distDir;
+    /** Stage `required-server-files.json` for an app with `basePath: "/base"`. */
+    const useBasePath = () => {
+        distDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "s3-cache-handler-"));
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(distDir, "required-server-files.json"), JSON.stringify({ config: { basePath: "/base" } }));
+        mockContext.serverDistDir = (0, node_path_1.join)(distDir, "server");
+    };
     // Helper to create set context with tags
     const createSetContext = (tags) => ({
         fetchCache: true,
         tags,
     });
+    /**
+     * The input a mocked command was constructed with. The SDK's command classes
+     * are automocked, so an instance carries nothing of its own.
+     */
+    const commandInput = (command, type) => {
+        const mock = type;
+        return mock.mock.calls[mock.mock.instances.indexOf(command)][0];
+    };
+    /**
+     * Answer DynamoDB by command type rather than by call order: `revalidateTag`
+     * writes its tag marker before querying the tag's mapping rows, and which of
+     * those comes first is an implementation detail. `get` is the marker row every
+     * requested tag has, as a `GetItem` would have returned it.
+     */
+    const dynamoResponses = (responses) => {
+        mockDynamoSend.mockImplementation((command) => {
+            if (command instanceof client_dynamodb_1.QueryCommand) {
+                return Promise.resolve(responses.query ?? {});
+            }
+            if (command instanceof client_dynamodb_1.BatchGetItemCommand) {
+                const { RequestItems } = commandInput(command, client_dynamodb_1.BatchGetItemCommand);
+                const [[table, { Keys }]] = Object.entries(RequestItems);
+                const item = responses.get?.Item;
+                return Promise.resolve({
+                    Responses: {
+                        [table]: item ? Keys.map(({ sk }) => ({ ...item, sk })) : [],
+                    },
+                });
+            }
+            return Promise.resolve({});
+        });
+    };
+    /**
+     * Drop the process's tag manifest, so the next handler starts with one of
+     * its own, as a new instance does.
+     */
+    const resetTagManifest = () => {
+        delete globalThis[Symbol.for("cdk-nextjs.use-cache.tag-manifest")];
+    };
     beforeEach(() => {
         mockContext = { dev: false };
+        resetTagManifest();
         // Set up environment variables
         process.env.CDK_NEXTJS_CACHE_BUCKET_NAME = "test-bucket";
         process.env.CDK_NEXTJS_REVALIDATION_TABLE_NAME = "test-table";
@@ -49,6 +109,8 @@ describe("S3DynamoCacheHandler", () => {
         });
         // Reset mocks
         mockS3Send.mockReset();
+        // An empty bucket: no object, such as no build tag manifest.
+        mockS3Send.mockResolvedValue({});
         mockDynamoSend.mockReset();
         mockCloudFrontSend.mockReset();
         mockSsmSend.mockReset();
@@ -60,6 +122,11 @@ describe("S3DynamoCacheHandler", () => {
         delete process.env.CDK_NEXTJS_BUILD_ID;
         delete process.env.AWS_REGION;
         delete process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME;
+        delete process.env.CDK_NEXTJS_DISTRIBUTION_ID;
+        if (distDir) {
+            (0, node_fs_1.rmSync)(distDir, { recursive: true, force: true });
+            distDir = undefined;
+        }
         // Restore console.warn
         jest.restoreAllMocks();
     });
@@ -114,6 +181,346 @@ describe("S3DynamoCacheHandler", () => {
             });
             expect(result).toBeNull();
         });
+        it("invalidates a seeded prerender only when its tag marker is newer", async () => {
+            // A build-time prerender is written as a file by the adapter's
+            // `onBuildComplete`, never through `set`, so it has no `tags` array and no
+            // DynamoDB mapping rows - its tags live in the render's
+            // `x-next-cache-tags` header. Two bugs met here: those header tags were
+            // ignored, so `revalidateTag` could not reach any static page; and the
+            // mapping rows `set` writes were stamped `revalidatedAt = now`, which is
+            // *after* the entry's own `lastModified`, so a tagged entry looked
+            // revalidated the moment it was stored and every request re-rendered.
+            // Measured against next.js's `test/e2e/app-dir/resume-data-cache`.
+            const lastModified = Date.now();
+            const seeded = {
+                lastModified,
+                value: {
+                    kind: "APP_PAGE" /* CachedRouteKind.APP_PAGE */,
+                    html: "<html>seeded</html>",
+                    headers: { "x-next-cache-tags": "_N_T_/,_N_T_/page,test" },
+                },
+            };
+            const s3Body = () => ({
+                Body: {
+                    transformToString: jest
+                        .fn()
+                        .mockResolvedValue(JSON.stringify(seeded)),
+                },
+                ContentType: "application/json",
+            });
+            mockS3Send.mockImplementation((command) => Promise.resolve(command instanceof client_s3_1.GetObjectCommand ? s3Body() : {}));
+            const getCtx = {
+                kind: "APP_PAGE" /* IncrementalCacheKind.APP_PAGE */,
+                isFallback: false,
+            };
+            // Each step below changes the markers DynamoDB holds; a new instance
+            // reads them afresh.
+            const freshHandler = () => {
+                resetTagManifest();
+                return new s3_cache_handler_1.S3CacheHandler({ context: mockContext });
+            };
+            // No marker at all: the tag was never revalidated.
+            dynamoResponses({});
+            expect(await freshHandler().get("index", getCtx)).toMatchObject({
+                lastModified,
+            });
+            // A marker older than the entry means the entry already reflects it.
+            dynamoResponses({
+                get: { Item: { revalidatedAt: { N: String(lastModified - 1000) } } },
+            });
+            expect(await freshHandler().get("index", getCtx)).toMatchObject({
+                lastModified,
+            });
+            expect(mockS3Send).not.toHaveBeenCalledWith(expect.any(client_s3_1.DeleteObjectCommand));
+            // A newer marker: the entry comes back marked expired, and stays in S3.
+            dynamoResponses({
+                get: { Item: { revalidatedAt: { N: String(lastModified + 1000) } } },
+            });
+            expect(await freshHandler().get("index", getCtx)).toMatchObject({
+                lastModified: -1,
+                value: seeded.value,
+            });
+            expect(mockS3Send).not.toHaveBeenCalledWith(expect.any(client_s3_1.DeleteObjectCommand));
+        });
+        it("reports a revalidated response entry as expired rather than as a miss", async () => {
+            // `lastModified: -1` is how a cache handler says "expired, re-render
+            // before answering": `IncrementalCache.get` turns it into `isStale: -1`,
+            // which `app-page-runtime` reads as an on-demand revalidation and answers
+            // with a blocking render of this route, then stores it. Returning `null`
+            // is not equivalent. A miss on a PPR route whose `prerender-manifest.json`
+            // entry has a `fallback` (`compute: "resuming"`) is answered from the
+            // route's fallback shell - `cache-control: private, no-store`, no
+            // `x-nextjs-cache` - and without `partialPrefetching` nothing ever
+            // upgrades that back into a concrete entry. So the first `revalidateTag`
+            // to reach a page left it uncacheable and dynamically resumed per request
+            // for the rest of the deployment's life, which is what the isr e2e's
+            // missing `x-nextjs-cache` header was.
+            const lastModified = Date.now();
+            const stored = {
+                lastModified,
+                tags: ["collection"],
+                value: {
+                    kind: "APP_PAGE" /* CachedRouteKind.APP_PAGE */,
+                    html: "<html>isr</html>",
+                    headers: { "x-next-cache-tags": "collection" },
+                },
+            };
+            mockS3Send.mockImplementation((command) => Promise.resolve(command instanceof client_s3_1.GetObjectCommand
+                ? {
+                    Body: {
+                        transformToString: jest
+                            .fn()
+                            .mockResolvedValue(JSON.stringify(stored)),
+                    },
+                    ContentType: "application/json",
+                }
+                : {}));
+            dynamoResponses({
+                get: { Item: { revalidatedAt: { N: String(lastModified + 1000) } } },
+            });
+            const result = await handler.get("isr/1", {
+                kind: "APP_PAGE" /* IncrementalCacheKind.APP_PAGE */,
+                isFallback: false,
+            });
+            expect(result).toEqual({ lastModified: -1, value: stored.value });
+            // The body is still there for the render that fails, and `set` overwrites
+            // it with a `lastModified` past the marker.
+            expect(mockS3Send).not.toHaveBeenCalledWith(expect.any(client_s3_1.DeleteObjectCommand));
+        });
+        it("reports a revalidated fetch entry as a miss so the request refetches", async () => {
+            // The opposite of a response entry: reusing a revalidated `fetch` body is
+            // serving stale data, so this reads as a miss, like Next.js's own
+            // `FileSystemCache` does for its `revalidatedTags`.
+            const lastModified = Date.now();
+            const stored = {
+                lastModified,
+                tags: ["collection"],
+                value: {
+                    kind: "FETCH" /* CachedRouteKind.FETCH */,
+                    data: { headers: {}, body: "stale", status: 200, url: "/api" },
+                    revalidate: 10,
+                },
+            };
+            mockS3Send.mockImplementation((command) => Promise.resolve(command instanceof client_s3_1.GetObjectCommand
+                ? {
+                    Body: {
+                        transformToString: jest
+                            .fn()
+                            .mockResolvedValue(JSON.stringify(stored)),
+                    },
+                    ContentType: "application/json",
+                }
+                : {}));
+            dynamoResponses({
+                get: { Item: { revalidatedAt: { N: String(lastModified + 1000) } } },
+            });
+            const result = await handler.get("fetch-key", {
+                kind: "FETCH" /* IncrementalCacheKind.FETCH */,
+                revalidate: 10,
+                fetchUrl: "https://example.test/api",
+                fetchIdx: 1,
+                tags: ["collection"],
+                softTags: [],
+            });
+            expect(result).toBeNull();
+            // Not deleted: the refetch this provokes overwrites it through `set`.
+            // Deleting it here raced that write, so a concurrent request's fresh
+            // entry could be the one removed.
+            expect(mockS3Send).not.toHaveBeenCalledWith(expect.any(client_s3_1.DeleteObjectCommand));
+            expect(client_dynamodb_1.DeleteItemCommand).not.toHaveBeenCalled();
+        });
+        it("checks a fetch entry against the request's implicit tags, not its own", async () => {
+            // An untagged `cache: "force-cache"` fetch is stored with no tags at all -
+            // the implicit `_N_T_/<path>` chain reaches the handler only as
+            // `ctx.softTags`, which is the source Next.js's own `FileSystemCache` reads
+            // for a `FETCH` get. Checking the stored tags instead left this entry with
+            // nothing to check and no `revalidatePath` could ever evict it.
+            const lastModified = Date.now();
+            const stored = {
+                lastModified,
+                tags: [],
+                value: {
+                    kind: "FETCH" /* CachedRouteKind.FETCH */,
+                    data: { headers: {}, body: "stale", status: 200, url: "/api" },
+                    revalidate: 10,
+                },
+            };
+            mockS3Send.mockImplementation((command) => Promise.resolve(command instanceof client_s3_1.GetObjectCommand
+                ? {
+                    Body: {
+                        transformToString: jest
+                            .fn()
+                            .mockResolvedValue(JSON.stringify(stored)),
+                    },
+                    ContentType: "application/json",
+                }
+                : {}));
+            dynamoResponses({
+                get: { Item: { revalidatedAt: { N: String(lastModified + 1000) } } },
+            });
+            const result = await handler.get("fetch-key", {
+                kind: "FETCH" /* IncrementalCacheKind.FETCH */,
+                revalidate: 10,
+                fetchUrl: "https://next-data-api-endpoint.test/api/random",
+                fetchIdx: 1,
+                tags: [],
+                softTags: ["_N_T_/layout", "_N_T_/dynamic"],
+            });
+            expect(result).toBeNull();
+            const [{ RequestItems }] = client_dynamodb_1.BatchGetItemCommand
+                .mock.calls[0];
+            expect(RequestItems["test-table"].Keys.map((key) => key.sk.S)).toEqual(["_N_T_/layout", "_N_T_/dynamic"]);
+        });
+        describe("a tag revalidated with a profile", () => {
+            // `revalidateTag("posts", "max")` is stale-while-revalidate: the entry is
+            // served once more while a background render replaces it, and expires
+            // outright only after the profile's `expire`. Treating it as `updateTag`
+            // made every such call a blocking re-render.
+            const lastModified = Date.now() - 1000;
+            const stored = {
+                lastModified,
+                value: {
+                    kind: "APP_PAGE" /* CachedRouteKind.APP_PAGE */,
+                    html: "<html>posts</html>",
+                    headers: { "x-next-cache-tags": "posts" },
+                },
+            };
+            const getCtx = {
+                kind: "APP_PAGE" /* IncrementalCacheKind.APP_PAGE */,
+                isFallback: false,
+            };
+            const manifestPath = (0, node_path_1.join)("/deployment/node_modules/next/dist/server/lib/incremental-cache", "tags-manifest.external.js");
+            // The module the server loads, resolved for real, so a Next.js upgrade
+            // that moves or reshapes it fails here rather than silently turning
+            // stale-while-revalidate into blocking renders.
+            const realManifestPath = require.resolve("next/dist/server/lib/incremental-cache/tags-manifest.external.js");
+            beforeEach(() => {
+                mockS3Send.mockImplementation((command) => Promise.resolve(command instanceof client_s3_1.GetObjectCommand
+                    ? {
+                        Body: {
+                            transformToString: jest
+                                .fn()
+                                .mockResolvedValue(JSON.stringify(stored)),
+                        },
+                        ContentType: "application/json",
+                    }
+                    : {}));
+            });
+            afterEach(() => {
+                delete mockModuleCache[manifestPath];
+                delete mockModuleCache[realManifestPath];
+            });
+            it("serves the entry and marks the tag stale in Next.js's manifest", async () => {
+                const next = jest.requireActual(realManifestPath);
+                mockModuleCache[realManifestPath] = { exports: next };
+                const staleAt = lastModified + 500;
+                dynamoResponses({
+                    get: {
+                        Item: {
+                            staleAt: { N: String(staleAt) },
+                            expiredAt: { N: String(Date.now() + 60_000) },
+                        },
+                    },
+                });
+                expect(await handler.get("posts", getCtx)).toEqual({
+                    lastModified,
+                    value: stored.value,
+                });
+                // Where `IncrementalCache.get` reads it, to answer `isStale: true`.
+                expect(next.tagsManifest.get("posts")).toEqual({ stale: staleAt });
+                expect(next.areTagsStale(["posts"], lastModified)).toBe(true);
+            });
+            it("expires the entry when Next.js's manifest cannot be found", async () => {
+                // A stale mark nothing reads would serve the entry as fresh; a blocking
+                // render is the safe side of that.
+                dynamoResponses({
+                    get: { Item: { staleAt: { N: String(lastModified + 500) } } },
+                });
+                expect(await handler.get("posts", getCtx)).toMatchObject({
+                    lastModified: -1,
+                });
+            });
+            it("expires the entry once the profile's expire has passed", async () => {
+                dynamoResponses({
+                    get: {
+                        Item: {
+                            staleAt: { N: String(lastModified + 100) },
+                            expiredAt: { N: String(lastModified + 500) },
+                        },
+                    },
+                });
+                expect(await handler.get("posts", getCtx)).toMatchObject({
+                    lastModified: -1,
+                });
+            });
+            describe("behind a distribution", () => {
+                // `revalidateTag`'s invalidation goes out before the stale entry is
+                // served, and the stale response carries the entry's original
+                // `s-maxage`: CloudFront caches it again. Only the regeneration's `set`
+                // knows when the fresh entry exists to be fetched instead.
+                let cdnHandler;
+                const regenerated = stored.value;
+                const invalidatedPaths = () => client_cloudfront_1.CreateInvalidationCommand.mock.calls.map(([input]) => input.InvalidationBatch.Paths.Items);
+                beforeEach(() => {
+                    process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = "test-param-name";
+                    cdnHandler = new s3_cache_handler_1.S3CacheHandler({ context: mockContext });
+                    mockModuleCache[manifestPath] = {
+                        exports: { tagsManifest: new Map() },
+                    };
+                    dynamoResponses({
+                        get: { Item: { staleAt: { N: String(lastModified + 500) } } },
+                    });
+                    mockSsmSend.mockResolvedValue({
+                        Parameter: { Value: "test-distribution-id" },
+                    });
+                    mockCloudFrontSend.mockResolvedValue({});
+                });
+                it("invalidates the page again once its regeneration is stored", async () => {
+                    await cdnHandler.get("posts", getCtx);
+                    expect(invalidatedPaths()).toEqual([]);
+                    await cdnHandler.set("posts", regenerated, {
+                        cacheControl: { revalidate: false, expire: undefined },
+                        isRoutePPREnabled: false,
+                        isFallback: false,
+                    });
+                    expect(invalidatedPaths()).toEqual([["/posts*"]]);
+                    // Once: a later write of the same page is an ordinary one.
+                    await cdnHandler.set("posts", regenerated, {
+                        cacheControl: { revalidate: false, expire: undefined },
+                        isRoutePPREnabled: false,
+                        isFallback: false,
+                    });
+                    expect(invalidatedPaths()).toHaveLength(1);
+                });
+                it("remembers a stale memory hit by the key it was read under", async () => {
+                    await cdnHandler.isRevalidated(stored, getCtx, "posts");
+                    await cdnHandler.set("posts", regenerated, {
+                        isRoutePPREnabled: false,
+                        isFallback: false,
+                    });
+                    expect(invalidatedPaths()).toEqual([["/posts*"]]);
+                });
+                it("does not invalidate after an ordinary write", async () => {
+                    await cdnHandler.set("posts", regenerated, {
+                        isRoutePPREnabled: false,
+                        isFallback: false,
+                    });
+                    expect(invalidatedPaths()).toEqual([]);
+                });
+                it("forgets a stale page that is deleted instead of regenerated", async () => {
+                    await cdnHandler.get("posts", getCtx);
+                    await cdnHandler.set("posts", null, {
+                        isRoutePPREnabled: false,
+                        isFallback: false,
+                    });
+                    await cdnHandler.set("posts", regenerated, {
+                        isRoutePPREnabled: false,
+                        isFallback: false,
+                    });
+                    expect(invalidatedPaths()).toEqual([]);
+                });
+            });
+        });
         it("should handle S3 errors and return null", async () => {
             mockS3Send.mockRejectedValueOnce(new Error("S3 Error"));
             const result = await handler.get("error-key", {
@@ -123,7 +530,109 @@ describe("S3DynamoCacheHandler", () => {
             expect(result).toBeNull();
         });
     });
+    describe("tag marker cache", () => {
+        // Every cache hit checks its tags' markers, and all of a deployment's
+        // markers share one partition key: read per request, they capped a route's
+        // cache hits at ~1,900 req/s. Each instance holds them for a second.
+        const lastModified = Date.now() - 60_000;
+        const stored = {
+            lastModified,
+            value: {
+                kind: "APP_PAGE" /* CachedRouteKind.APP_PAGE */,
+                html: "<html>cached</html>",
+                headers: { "x-next-cache-tags": "_N_T_/page,posts" },
+            },
+        };
+        const getCtx = {
+            kind: "APP_PAGE" /* IncrementalCacheKind.APP_PAGE */,
+            isFallback: false,
+        };
+        const markerReads = () => mockDynamoSend.mock.calls.filter(([command]) => command instanceof client_dynamodb_1.BatchGetItemCommand).length;
+        // What `get` answers for a revalidated page: expired, not a miss.
+        const expired = { lastModified: -1 };
+        const revalidatedAfterStore = {
+            get: { Item: { revalidatedAt: { N: String(lastModified + 1000) } } },
+        };
+        beforeEach(() => {
+            mockS3Send.mockImplementation((command) => Promise.resolve(command instanceof client_s3_1.GetObjectCommand
+                ? {
+                    Body: {
+                        transformToString: jest
+                            .fn()
+                            .mockResolvedValue(JSON.stringify(stored)),
+                    },
+                    ContentType: "application/json",
+                }
+                : {}));
+            dynamoResponses({});
+        });
+        it("answers checks within the TTL from the markers it already read", async () => {
+            await handler.get("page", getCtx);
+            await handler.get("page", getCtx);
+            expect(markerReads()).toBe(1);
+        });
+        it("shares one read between concurrent checks", async () => {
+            await Promise.all([
+                handler.get("page", getCtx),
+                handler.get("page", getCtx),
+                handler.get("page", getCtx),
+            ]);
+            expect(markerReads()).toBe(1);
+        });
+        it("sees its own revalidateTag at once, and logs it for the others", async () => {
+            expect(await handler.get("page", getCtx)).toMatchObject({ lastModified });
+            dynamoResponses(revalidatedAfterStore);
+            await handler.revalidateTag("posts");
+            expect(await handler.get("page", getCtx)).toMatchObject(expired);
+            const puts = mockDynamoSend.mock.calls.filter(([command]) => command instanceof client_dynamodb_1.PutItemCommand);
+            expect(puts).toHaveLength(1);
+            expect(commandInput(puts[0][0], client_dynamodb_1.PutItemCommand).Item).toMatchObject({
+                pk: { S: "test-build-id#log" },
+                sk: { S: expect.stringMatching(/^\d{15}#posts$/) },
+                revalidatedAt: { N: expect.any(String) },
+                ttl: { N: expect.any(String) },
+            });
+        });
+        it("writes each tag once when the 'use cache' handlers get the same call", async () => {
+            // Next.js calls `revalidateTag` here and `updateTags` on every
+            // `cacheHandlers` entry, and all of them share one manifest.
+            await Promise.all([
+                handler.revalidateTag(["posts"]),
+                (0, use_cache_common_1.sharedTagManifest)().update(["posts"], undefined),
+            ]);
+            const writes = mockDynamoSend.mock.calls.filter(([command]) => command instanceof client_dynamodb_1.UpdateItemCommand ||
+                command instanceof client_dynamodb_1.PutItemCommand);
+            expect(writes).toHaveLength(2);
+        });
+    });
     describe("set", () => {
+        // Mapping rows exist only to name CloudFront paths, so only a deployment
+        // with a distribution keeps them.
+        beforeEach(() => {
+            process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = "test-param-name";
+            handler = new s3_cache_handler_1.S3CacheHandler({ context: mockContext });
+        });
+        it("keeps no mapping rows without a distribution to invalidate", async () => {
+            // The Regional constructs have no CloudFront. A row per tag per `set`,
+            // and the S3 read before a delete to name them, bought nothing there.
+            delete process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME;
+            const regional = new s3_cache_handler_1.S3CacheHandler({ context: mockContext });
+            mockS3Send.mockResolvedValue({});
+            mockDynamoSend.mockResolvedValue({});
+            await regional.set("/isr/1", {
+                kind: "APP_PAGE" /* CachedRouteKind.APP_PAGE */,
+                html: "<p/>",
+                rscData: undefined,
+                headers: { "x-next-cache-tags": "tag" },
+                postponed: undefined,
+                segmentData: undefined,
+                status: undefined,
+            }, createSetContext([]));
+            await regional.set("/isr/1", null, { isFallback: false });
+            expect(mockDynamoSend).not.toHaveBeenCalled();
+            expect(mockS3Send).not.toHaveBeenCalledWith(expect.any(client_s3_1.GetObjectCommand));
+            expect(mockS3Send).toHaveBeenCalledWith(expect.any(client_s3_1.DeleteObjectCommand));
+        });
         it("should store cache value in S3", async () => {
             const testData = {
                 kind: "APP_PAGE" /* CachedRouteKind.APP_PAGE */,
@@ -157,6 +666,124 @@ describe("S3DynamoCacheHandler", () => {
             await handlerWithoutBucket.set("no-bucket-key", testData, createSetContext([]));
             expect(mockS3Send).not.toHaveBeenCalled();
         });
+        it("maps the tags a page carries only in its x-next-cache-tags header", async () => {
+            // `ResponseCache.set` builds a page's `ctx` without tags, so the render's
+            // header is the only place they exist. No mapping row meant `revalidateTag`
+            // found nothing to invalidate and CloudFront kept the stale HTML.
+            const testData = {
+                kind: "APP_PAGE" /* CachedRouteKind.APP_PAGE */,
+                html: "<html>tagged</html>",
+                rscData: undefined,
+                headers: { "x-next-cache-tags": "header-tag,other-tag" },
+                postponed: undefined,
+                segmentData: undefined,
+                status: undefined,
+            };
+            mockS3Send.mockResolvedValue({});
+            mockDynamoSend.mockResolvedValue({});
+            await handler.set("/isr/1", testData, createSetContext([]));
+            const mappingKeys = client_dynamodb_1.UpdateItemCommand.mock.calls
+                .map(([input]) => input.Key.sk.S)
+                .sort();
+            expect(mappingKeys).toEqual([
+                "header-tag#test-build-id/isr/1.json",
+                "other-tag#test-build-id/isr/1.json",
+            ]);
+        });
+        it("prefers the context's tags over the header when both are present", async () => {
+            const testData = {
+                kind: "APP_PAGE" /* CachedRouteKind.APP_PAGE */,
+                html: "<html>tagged</html>",
+                rscData: undefined,
+                headers: { "x-next-cache-tags": "header-tag" },
+                postponed: undefined,
+                segmentData: undefined,
+                status: undefined,
+            };
+            mockS3Send.mockResolvedValue({});
+            mockDynamoSend.mockResolvedValue({});
+            await handler.set("/isr/1", testData, createSetContext(["ctx-tag"]));
+            const mappingKeys = client_dynamodb_1.UpdateItemCommand.mock.calls
+                .map(([input]) => input.Key.sk.S)
+                .sort();
+            expect(mappingKeys).toEqual(["ctx-tag#test-build-id/isr/1.json"]);
+        });
+        it("removes a deleted page's mapping rows, reading its tags from S3", async () => {
+            // A response delete - a cached route that starts answering `notFound()` -
+            // arrives as `set(key, null, { cacheControl, ... })` with no tags at all,
+            // so the entry itself is the only place its mapping rows can be named
+            // from. Left behind, they resolve on the next `revalidateTag` to a cache
+            // key whose object is gone and spend a CloudFront wildcard path on it.
+            const stored = {
+                lastModified: Date.now(),
+                tags: ["collection", "_N_T_/isr/1"],
+                value: {
+                    kind: "APP_PAGE" /* CachedRouteKind.APP_PAGE */,
+                    html: "<html>gone</html>",
+                },
+            };
+            mockS3Send.mockImplementation((command) => Promise.resolve(command instanceof client_s3_1.GetObjectCommand
+                ? {
+                    Body: {
+                        transformToString: jest
+                            .fn()
+                            .mockResolvedValue(JSON.stringify(stored)),
+                    },
+                    ContentType: "application/json",
+                }
+                : {}));
+            mockDynamoSend.mockResolvedValue({});
+            await handler.set("/isr/1", null, {
+                cacheControl: { revalidate: 60, expire: undefined },
+                isRoutePPREnabled: false,
+                isFallback: false,
+            });
+            expect(mockS3Send).toHaveBeenCalledWith(expect.any(client_s3_1.DeleteObjectCommand));
+            const deletedKeys = client_dynamodb_1.DeleteItemCommand.mock.calls
+                .map(([input]) => input.Key.sk.S)
+                .sort();
+            // Mapping rows only. The bare-tag marker row belongs to the tag, and
+            // `checkIfRevalidated` reads it for every other entry carrying it.
+            expect(deletedKeys).toEqual([
+                "_N_T_/isr/1#test-build-id/isr/1.json",
+                "collection#test-build-id/isr/1.json",
+            ]);
+        });
+        it("deletes a fetch entry's mapping rows from the context's tags alone", async () => {
+            // `ctx` carries them here, so the pre-delete read is skipped: only the
+            // DeleteObject reaches S3.
+            mockS3Send.mockResolvedValue({});
+            mockDynamoSend.mockResolvedValue({});
+            await handler.set("fetch-key", null, createSetContext(["ctx-tag"]));
+            expect(mockS3Send).not.toHaveBeenCalledWith(expect.any(client_s3_1.GetObjectCommand));
+            const deletedKeys = client_dynamodb_1.DeleteItemCommand.mock.calls.map(([input]) => input.Key.sk.S);
+            expect(deletedKeys).toEqual(["ctx-tag#test-build-id/fetch-key.json"]);
+        });
+        it("deletes no mapping rows for an untagged entry", async () => {
+            mockS3Send.mockImplementation((command) => Promise.resolve(command instanceof client_s3_1.GetObjectCommand
+                ? {
+                    Body: {
+                        transformToString: jest.fn().mockResolvedValue(JSON.stringify({
+                            lastModified: Date.now(),
+                            value: { kind: "APP_PAGE" /* CachedRouteKind.APP_PAGE */, html: "<p/>" },
+                        })),
+                    },
+                    ContentType: "application/json",
+                }
+                : {}));
+            mockDynamoSend.mockResolvedValue({});
+            await handler.set("/untagged", null, { isFallback: false });
+            expect(mockS3Send).toHaveBeenCalledWith(expect.any(client_s3_1.DeleteObjectCommand));
+            expect(client_dynamodb_1.DeleteItemCommand).not.toHaveBeenCalled();
+        });
+        it("still deletes the object when its tags cannot be read", async () => {
+            mockS3Send.mockImplementation((command) => command instanceof client_s3_1.GetObjectCommand
+                ? Promise.reject(new Error("S3 Get Error"))
+                : Promise.resolve({}));
+            mockDynamoSend.mockResolvedValue({});
+            await expect(handler.set("/isr/1", null, { isFallback: false })).resolves.not.toThrow();
+            expect(mockS3Send).toHaveBeenCalledWith(expect.any(client_s3_1.DeleteObjectCommand));
+        });
         it("should handle S3 errors gracefully", async () => {
             const testData = {
                 kind: "APP_PAGE" /* CachedRouteKind.APP_PAGE */,
@@ -173,20 +800,32 @@ describe("S3DynamoCacheHandler", () => {
         });
     });
     describe("revalidateTag", () => {
-        it("should query DynamoDB and delete S3 entries", async () => {
+        it("should record the revalidation without deleting the tag's S3 entries", async () => {
             const mockQueryResponse = {
                 Items: [
                     { sk: { S: "test-tag#cache-key-1" } },
                     { sk: { S: "test-tag#cache-key-2" } },
                 ],
             };
-            mockDynamoSend.mockResolvedValueOnce(mockQueryResponse);
-            mockDynamoSend.mockResolvedValue({}); // For update commands
-            mockS3Send.mockResolvedValue({}); // For delete commands
+            dynamoResponses({ query: mockQueryResponse });
+            mockS3Send.mockResolvedValue({});
             await handler.revalidateTag("test-tag");
-            expect(mockDynamoSend).toHaveBeenCalledWith(expect.any(client_dynamodb_1.QueryCommand));
+            // No distribution, so no mapping rows to read: the marker is all of it.
+            expect(mockDynamoSend).not.toHaveBeenCalledWith(expect.any(client_dynamodb_1.QueryCommand));
             expect(mockDynamoSend).toHaveBeenCalledWith(expect.any(client_dynamodb_1.UpdateItemCommand));
-            expect(mockS3Send).toHaveBeenCalledWith(expect.any(client_s3_1.DeleteObjectCommand));
+            // The marker row is the invalidation; `get` reads it and hands the entry
+            // back expired so Next.js re-renders the route and replaces the object.
+            // Deleting the objects here made the next request a hard miss, which on a
+            // PPR route is answered from the uncacheable fallback shell for good.
+            expect(mockS3Send).not.toHaveBeenCalledWith(expect.any(client_s3_1.DeleteObjectCommand));
+            // The tag marker `checkIfRevalidated` reads: keyed by the bare tag, so
+            // entries with no mapping row of their own still see the revalidation.
+            const markerWrite = client_dynamodb_1.UpdateItemCommand.mock.calls
+                .map(([input]) => input)
+                .find((input) => input.Key.sk.S === "test-tag");
+            expect(markerWrite).toMatchObject({
+                UpdateExpression: "SET revalidatedAt = :revalidatedAt",
+            });
         });
         it("should not revalidate when DynamoDB table is not configured", async () => {
             delete process.env.CDK_NEXTJS_REVALIDATION_TABLE_NAME;
@@ -212,8 +851,7 @@ describe("S3DynamoCacheHandler", () => {
                     { sk: { S: "test-tag#test-build-id/isr/2.json" } },
                 ],
             };
-            mockDynamoSend.mockResolvedValueOnce(mockQueryResponse);
-            mockDynamoSend.mockResolvedValue({}); // For update commands
+            dynamoResponses({ query: mockQueryResponse });
             mockS3Send.mockResolvedValue({}); // For delete commands
             mockSsmSend.mockResolvedValue({
                 Parameter: { Value: "test-distribution-id" },
@@ -224,14 +862,146 @@ describe("S3DynamoCacheHandler", () => {
             expect(mockCloudFrontSend).toHaveBeenCalledWith(expect.any(client_cloudfront_1.CreateInvalidationCommand));
             const [invalidationInput] = client_cloudfront_1.CreateInvalidationCommand.mock.calls[0];
             expect(invalidationInput.DistributionId).toBe("test-distribution-id");
-            expect(invalidationInput.InvalidationBatch.Paths.Items).toEqual(expect.arrayContaining(["/isr/1", "/isr/2"]));
+            // One trailing wildcard per page: an invalidation path matches only the
+            // query string it spells out, and a page's RSC payload is cached under
+            // `?_rsc=<hash>` - `/isr/1*` covers it, and the slash variant, for one
+            // of the fifteen wildcards instead of two.
+            expect(invalidationInput.InvalidationBatch.Paths.Items).toEqual([
+                "/isr/1*",
+                "/isr/2*",
+            ]);
+        });
+        it("invalidates a distribution whose ID is in the environment without SSM", async () => {
+            // NextjsGlobalContainers: the task can name the distribution directly.
+            process.env.CDK_NEXTJS_DISTRIBUTION_ID = "direct-distribution-id";
+            const handlerWithDistribution = new s3_cache_handler_1.S3CacheHandler({
+                context: mockContext,
+            });
+            dynamoResponses({
+                query: { Items: [{ sk: { S: "test-tag#test-build-id/isr/1.json" } }] },
+            });
+            mockS3Send.mockResolvedValue({});
+            mockCloudFrontSend.mockResolvedValue({});
+            await handlerWithDistribution.revalidateTag("test-tag");
+            expect(mockSsmSend).not.toHaveBeenCalled();
+            const [invalidationInput] = client_cloudfront_1.CreateInvalidationCommand.mock.calls[0];
+            expect(invalidationInput.DistributionId).toBe("direct-distribution-id");
+        });
+        it("splits a mapping row at the tag's length, so a tag containing # still resolves", async () => {
+            // A tag is app-defined: `revalidateTag("user#42")` is legal. Splitting at
+            // the first "#" left "42#test-build-id/account.json" as the S3 key, whose
+            // invalidation path names nothing CloudFront cached, so the page stayed
+            // stale while the row was stamped revalidated and never retried.
+            process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = "test-param-name";
+            const handlerWithDistribution = new s3_cache_handler_1.S3CacheHandler({
+                context: mockContext,
+            });
+            dynamoResponses({
+                query: { Items: [{ sk: { S: "user#42#test-build-id/account.json" } }] },
+            });
+            mockSsmSend.mockResolvedValue({
+                Parameter: { Value: "test-distribution-id" },
+            });
+            mockCloudFrontSend.mockResolvedValue({});
+            await handlerWithDistribution.revalidateTag("user#42");
+            const [invalidationInput] = client_cloudfront_1.CreateInvalidationCommand.mock.calls[0];
+            expect(invalidationInput.InvalidationBatch.Paths.Items).toEqual([
+                "/account*",
+            ]);
+        });
+        it("invalidates the path a revalidatePath tag names even with no mapping rows", async () => {
+            // A build-time prerender has no mapping rows, so the query comes back
+            // empty and there is nothing to derive a CloudFront path from - except the
+            // tag, which for `revalidatePath` is `_N_T_<path>`. Without this the CDN
+            // answers with the pre-revalidation page until `s-maxage=31536000`
+            // expires. Measured against next.js's `test/e2e/app-dir/trailingslash`.
+            process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = "test-param-name";
+            const handlerWithDistribution = new s3_cache_handler_1.S3CacheHandler({
+                context: mockContext,
+            });
+            dynamoResponses({ query: { Items: [] } });
+            mockSsmSend.mockResolvedValue({
+                Parameter: { Value: "test-distribution-id" },
+            });
+            mockCloudFrontSend.mockResolvedValue({});
+            await handlerWithDistribution.revalidateTag("_N_T_/en/legacy/");
+            const [invalidationInput] = client_cloudfront_1.CreateInvalidationCommand.mock.calls[0];
+            // Both slash variants, which the trailing wildcard covers: a
+            // `trailingSlash` app's cached URI is the redirect target, not the route.
+            expect(invalidationInput.InvalidationBatch.Paths.Items).toEqual([
+                "/en/legacy*",
+            ]);
+        });
+        it("invalidates the URI under the app's basePath, not the bare route", async () => {
+            // CloudFront cached `/base/isr/1`; the cache key and the `revalidatePath`
+            // tag both name `/isr/1`, because Next.js strips `basePath` before routing
+            // and never shows it to the cache handler. Invalidating the bare route
+            // matches nothing at the edge, so the stale page survives until
+            // `s-maxage` expires.
+            process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = "test-param-name";
+            useBasePath();
+            const handlerWithBasePath = new s3_cache_handler_1.S3CacheHandler({
+                context: mockContext,
+            });
+            dynamoResponses({
+                query: {
+                    Items: [
+                        { sk: { S: "test-tag#test-build-id/isr/1.json" } },
+                        { sk: { S: "test-tag#test-build-id/index.json" } },
+                    ],
+                },
+            });
+            mockS3Send.mockResolvedValue({});
+            mockSsmSend.mockResolvedValue({
+                Parameter: { Value: "test-distribution-id" },
+            });
+            mockCloudFrontSend.mockResolvedValue({});
+            await handlerWithBasePath.revalidateTag("test-tag");
+            const [invalidationInput] = client_cloudfront_1.CreateInvalidationCommand.mock.calls[0];
+            expect(invalidationInput.InvalidationBatch.Paths.Items).toEqual(expect.arrayContaining([
+                "/base/isr/1*",
+                // The app's root under a `basePath` is `/base`, not `/base/`, and
+                // spelled out: `/base*` would be the whole app.
+                "/base",
+                "/base?*",
+                "/base/",
+                "/base/?*",
+            ]));
+            expect(invalidationInput.InvalidationBatch.Paths.Items).not.toContain("/isr/1");
+        });
+        it("adds the basePath to a revalidatePath tag's path too", async () => {
+            process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = "test-param-name";
+            useBasePath();
+            const handlerWithBasePath = new s3_cache_handler_1.S3CacheHandler({
+                context: mockContext,
+            });
+            dynamoResponses({ query: { Items: [] } });
+            mockSsmSend.mockResolvedValue({
+                Parameter: { Value: "test-distribution-id" },
+            });
+            mockCloudFrontSend.mockResolvedValue({});
+            await handlerWithBasePath.revalidateTag("_N_T_/blog");
+            const [invalidationInput] = client_cloudfront_1.CreateInvalidationCommand.mock.calls[0];
+            expect(invalidationInput.InvalidationBatch.Paths.Items).toEqual([
+                "/base/blog*",
+            ]);
+        });
+        it("does not invalidate a CloudFront path for an app tag", async () => {
+            process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = "test-param-name";
+            const handlerWithDistribution = new s3_cache_handler_1.S3CacheHandler({
+                context: mockContext,
+            });
+            dynamoResponses({ query: { Items: [] } });
+            await handlerWithDistribution.revalidateTag("posts");
+            // Nothing to invalidate: an app tag names no path, and no entry is mapped
+            // to it.
+            expect(mockCloudFrontSend).not.toHaveBeenCalled();
         });
         it("should not call SSM or CloudFront when no distribution parameter is configured", async () => {
             const mockQueryResponse = {
                 Items: [{ sk: { S: "test-tag#test-build-id/isr/1.json" } }],
             };
-            mockDynamoSend.mockResolvedValueOnce(mockQueryResponse);
-            mockDynamoSend.mockResolvedValue({});
+            dynamoResponses({ query: mockQueryResponse });
             mockS3Send.mockResolvedValue({});
             await handler.revalidateTag("test-tag");
             expect(mockSsmSend).not.toHaveBeenCalled();
@@ -245,35 +1015,420 @@ describe("S3DynamoCacheHandler", () => {
             const mockQueryResponse = {
                 Items: [{ sk: { S: "test-tag#test-build-id/isr/1.json" } }],
             };
-            mockDynamoSend.mockResolvedValueOnce(mockQueryResponse);
-            mockDynamoSend.mockResolvedValue({});
+            dynamoResponses({ query: mockQueryResponse });
             mockS3Send.mockResolvedValue({});
             mockSsmSend.mockRejectedValueOnce(new Error("SSM Error"));
             await expect(handlerWithDistribution.revalidateTag("test-tag")).resolves.not.toThrow();
         });
-    });
-    describe("resetRequestCache", () => {
-        it("should complete without errors", async () => {
-            await expect(handler.resetRequestCache()).resolves.not.toThrow();
+        it("invalidates the page itself for a revalidatePath(path, 'page') tag", async () => {
+            // `revalidatePath(path, type)` appends the type to the implicit tag, so the
+            // tag reads `_N_T_/pricing/page` - a path no URL has. Taking it literally
+            // invalidated nothing that existed, which is the whole of the bug: the
+            // second argument silently turned CDN invalidation off.
+            process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = "test-param-name";
+            const handlerWithDistribution = new s3_cache_handler_1.S3CacheHandler({
+                context: mockContext,
+            });
+            dynamoResponses({ query: { Items: [] } });
+            mockSsmSend.mockResolvedValue({
+                Parameter: { Value: "test-distribution-id" },
+            });
+            mockCloudFrontSend.mockResolvedValue({});
+            await handlerWithDistribution.revalidateTag("_N_T_/pricing/page");
+            const [invalidationInput] = client_cloudfront_1.CreateInvalidationCommand.mock.calls[0];
+            expect(invalidationInput.InvalidationBatch.Paths.Items).toEqual(expect.arrayContaining(["/pricing*"]));
         });
-    });
-    describe("custom configuration", () => {
-        it("should accept custom configuration options", () => {
-            const customHandler = new s3_cache_handler_1.S3CacheHandler({
+        it("skips mapping rows that name no cached URI", async () => {
+            // A dynamic template and a fetch-cache entry are both rows a real tag
+            // carries, and neither is a URL: `/blog/[slug]` matches nothing at the edge
+            // (CloudFront has no such URI), and a fetch key is a hash of the request.
+            process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = "test-param-name";
+            const handlerWithDistribution = new s3_cache_handler_1.S3CacheHandler({
                 context: mockContext,
-                s3Config: {
-                    bucketName: "custom-bucket",
-                    region: "eu-west-1",
-                    buildId: "custom-build",
+            });
+            dynamoResponses({
+                query: {
+                    Items: [
+                        { sk: { S: "test-tag#test-build-id/blog/[slug].json" } },
+                        {
+                            sk: {
+                                S: "test-tag#test-build-id/0123456789abcdef0123456789abcdef.json",
+                            },
+                        },
+                        { sk: { S: "test-tag#test-build-id/blog/hello.json" } },
+                    ],
                 },
-                dynamoConfig: {
-                    tableName: "custom-table",
-                    region: "eu-west-1",
-                    buildId: "custom-build",
+            });
+            mockS3Send.mockResolvedValue({});
+            mockSsmSend.mockResolvedValue({
+                Parameter: { Value: "test-distribution-id" },
+            });
+            mockCloudFrontSend.mockResolvedValue({});
+            await handlerWithDistribution.revalidateTag("test-tag");
+            const [invalidationInput] = client_cloudfront_1.CreateInvalidationCommand.mock.calls[0];
+            const items = invalidationInput.InvalidationBatch.Paths.Items;
+            expect(items).toEqual(["/blog/hello*"]);
+            expect(items.some((path) => path.includes("["))).toBe(false);
+            expect(items.some((path) => path.includes("0123456789abcdef"))).toBe(false);
+        });
+        it("walks every Query page of a tag's mapping rows", async () => {
+            // One `Query` answers with at most 1 MB. A tag on a large app runs past
+            // that, and taking only the first page deleted some of the tag's entries
+            // and invalidated only some of its paths - a partial revalidation that
+            // looks like a cache bug.
+            process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = "test-param-name";
+            const handlerWithDistribution = new s3_cache_handler_1.S3CacheHandler({
+                context: mockContext,
+            });
+            let queries = 0;
+            mockDynamoSend.mockImplementation((command) => {
+                if (command instanceof client_dynamodb_1.QueryCommand) {
+                    queries++;
+                    return Promise.resolve(queries === 1
+                        ? {
+                            Items: [{ sk: { S: "test-tag#test-build-id/isr/1.json" } }],
+                            LastEvaluatedKey: { pk: { S: "test-build-id" } },
+                        }
+                        : { Items: [{ sk: { S: "test-tag#test-build-id/isr/2.json" } }] });
+                }
+                return Promise.resolve({});
+            });
+            mockS3Send.mockResolvedValue({});
+            mockSsmSend.mockResolvedValue({
+                Parameter: { Value: "test-distribution-id" },
+            });
+            mockCloudFrontSend.mockResolvedValue({});
+            await handlerWithDistribution.revalidateTag("test-tag");
+            expect(queries).toBe(2);
+            const [invalidationInput] = client_cloudfront_1.CreateInvalidationCommand.mock.calls[0];
+            expect(invalidationInput.InvalidationBatch.Paths.Items).toEqual([
+                "/isr/1*",
+                "/isr/2*",
+            ]);
+        });
+        it("collapses to one app-wide wildcard rather than sending many invalidations", async () => {
+            // CloudFront caps a request at 15 wildcard paths and allows 15
+            // invalidations in progress. A tag covering hundreds of pages therefore
+            // cannot be spelled out: sending a request per 15 paths throttles, and a
+            // throttled request is a page that stays stale.
+            process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = "test-param-name";
+            const handlerWithDistribution = new s3_cache_handler_1.S3CacheHandler({
+                context: mockContext,
+            });
+            dynamoResponses({
+                query: {
+                    Items: Array.from({ length: 200 }, (_, i) => ({
+                        sk: { S: `test-tag#test-build-id/isr/${i}.json` },
+                    })),
                 },
             });
-            expect(customHandler).toBeDefined();
+            mockS3Send.mockResolvedValue({});
+            mockSsmSend.mockResolvedValue({
+                Parameter: { Value: "test-distribution-id" },
+            });
+            mockCloudFrontSend.mockResolvedValue({});
+            await handlerWithDistribution.revalidateTag("test-tag");
+            expect(mockCloudFrontSend).toHaveBeenCalledTimes(1);
+            const [invalidationInput] = client_cloudfront_1.CreateInvalidationCommand.mock.calls[0];
+            expect(invalidationInput.InvalidationBatch.Paths.Items).toEqual(["/*"]);
+        });
+        /** A handler with a distribution, and DynamoDB answering `query` for it. */
+        const withDistribution = (query) => {
+            process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = "test-param-name";
+            dynamoResponses({ query });
+            mockSsmSend.mockResolvedValue({
+                Parameter: { Value: "test-distribution-id" },
+            });
+            mockCloudFrontSend.mockResolvedValue({});
+            return new s3_cache_handler_1.S3CacheHandler({ context: mockContext });
+        };
+        const invalidations = () => client_cloudfront_1.CreateInvalidationCommand.mock.calls.map(([input]) => input.InvalidationBatch.Paths.Items);
+        const pages = (tag, count) => ({
+            Items: Array.from({ length: count }, (_, i) => ({
+                sk: { S: `${tag}#test-build-id/isr/${i}.json` },
+            })),
+        });
+        it("sends a tag's paths as one request while they fit", async () => {
+            // CloudFront's wildcard quota is shared by every invalidation in
+            // progress on the distribution. Splitting ten pages' twenty wildcards
+            // into two back-to-back requests had the second rejected, and its pages
+            // stayed stale at the edge.
+            await withDistribution(pages("test-tag", 10)).revalidateTag("test-tag");
+            expect(invalidations()).toHaveLength(1);
+            expect(invalidations()[0]).toHaveLength(10);
+        });
+        it("collapses to the whole app past fifteen wildcards", async () => {
+            await withDistribution(pages("test-tag", 16)).revalidateTag("test-tag");
+            expect(invalidations()).toEqual([["/*"]]);
+        });
+        it("collapses to the whole app under a basePath, its root included", async () => {
+            // Not `/base*`, which would also invalidate a sibling app at `/base2`.
+            useBasePath();
+            await withDistribution(pages("test-tag", 16)).revalidateTag("test-tag");
+            expect(invalidations()).toEqual([["/base", "/base?*", "/base/*"]]);
+        });
+        it("invalidates the whole app under a basePath when a tag's rows cannot be read", async () => {
+            useBasePath();
+            jest.spyOn(console, "error").mockImplementation();
+            const cdnHandler = withDistribution({ Items: [] });
+            mockDynamoSend.mockImplementation((command) => command instanceof client_dynamodb_1.QueryCommand
+                ? Promise.reject(new Error("ProvisionedThroughputExceeded"))
+                : Promise.resolve({}));
+            await cdnHandler.revalidateTag("posts");
+            expect(invalidations()).toEqual([["/base", "/base?*", "/base/*"]]);
+        });
+        it("percent-encodes the routes it invalidates", async () => {
+            // Cache keys are decoded pathnames, while CloudFront caches - and
+            // invalidation paths match - the encoded URI the browser sent.
+            await withDistribution({
+                Items: [
+                    { sk: { S: "test-tag#test-build-id/blog/héllo.json" } },
+                    { sk: { S: "test-tag#test-build-id/blog/hello world.json" } },
+                    // Path delimiters Next.js re-escaped in the key stay as they are.
+                    { sk: { S: "test-tag#test-build-id/files/a%2Fb.json" } },
+                    { sk: { S: "test-tag#test-build-id/@user/50%.json" } },
+                ],
+            }).revalidateTag(["test-tag", "_N_T_/tags/c#?"]);
+            expect(invalidations()).toEqual([
+                [
+                    "/blog/h%C3%A9llo*",
+                    "/blog/hello%20world*",
+                    "/files/a%2Fb*",
+                    "/@user/50%25*",
+                    "/tags/c%23%3F*",
+                ],
+            ]);
+        });
+        it("invalidates every tag of one call in a single request", async () => {
+            // `revalidateTag` hands the handler every tag a request revalidated at
+            // once; a request per tag competes for the same quota.
+            await withDistribution({ Items: [] }).revalidateTag([
+                "_N_T_/a",
+                "_N_T_/b",
+            ]);
+            expect(invalidations()).toEqual([["/a*", "/b*"]]);
+        });
+        it("invalidates the whole app when a tag has more rows than it walks", async () => {
+            // The rows past the last page walked are pages too; invalidating only the
+            // ones read left the rest stale at the edge for up to a year.
+            process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = "test-param-name";
+            mockDynamoSend.mockImplementation((command) => Promise.resolve(command instanceof client_dynamodb_1.QueryCommand
+                ? {
+                    Items: [{ sk: { S: "test-tag#test-build-id/isr/1.json" } }],
+                    LastEvaluatedKey: { pk: { S: "test-build-id" } },
+                }
+                : {}));
+            mockSsmSend.mockResolvedValue({
+                Parameter: { Value: "test-distribution-id" },
+            });
+            mockCloudFrontSend.mockResolvedValue({});
+            await new s3_cache_handler_1.S3CacheHandler({ context: mockContext }).revalidateTag("test-tag");
+            expect(invalidations()).toEqual([["/*"]]);
+        });
+        it("ignores rows that another tag sharing the prefix owns", async () => {
+            // `begins_with(sk, "user#")` also matches the tag `user#42`: its bare
+            // marker row, and its mapping rows. Read as `user`'s, they became
+            // invalidation paths like `/42` that name nothing.
+            await withDistribution({
+                Items: [
+                    { sk: { S: "user#42" } },
+                    { sk: { S: "user#42#test-build-id/account.json" } },
+                    { sk: { S: "user#test-build-id/profile.json" } },
+                ],
+            }).revalidateTag("user");
+            expect(invalidations()).toEqual([["/profile*"]]);
+        });
+        it("adds the build-time prerenders the build's tag manifest names, reading it once", async () => {
+            // A prerender is written by the adapter, never through `set`, so it has
+            // no mapping row: the manifest is the only record of its tags.
+            const cdnHandler = withDistribution({
+                Items: [{ sk: { S: "posts#test-build-id/blog/b.json" } }],
+            });
+            const manifestGets = () => client_s3_1.GetObjectCommand.mock.calls.filter(([input]) => input.Key === "test-build-id/_cdk-nextjs-tag-manifest.json");
+            mockS3Send.mockImplementation((command) => Promise.resolve(command instanceof client_s3_1.GetObjectCommand
+                ? {
+                    Body: {
+                        transformToString: async () => JSON.stringify({ posts: ["blog/a", "index"] }),
+                    },
+                }
+                : {}));
+            await cdnHandler.revalidateTag("posts");
+            await cdnHandler.revalidateTag("constructor");
+            expect(invalidations()).toEqual([["/blog/b*", "/blog/a*", "/", "/?*"]]);
+            expect(manifestGets()).toHaveLength(1);
+        });
+        it("invalidates the whole app when the build's tag manifest cannot be read, and reads it again next time", async () => {
+            const cdnHandler = withDistribution({ Items: [] });
+            mockS3Send.mockRejectedValueOnce(new Error("AccessDenied"));
+            await cdnHandler.revalidateTag("posts");
+            await cdnHandler.revalidateTag("posts");
+            expect(invalidations()).toEqual([["/*"]]);
+            expect(mockS3Send).toHaveBeenCalledTimes(2);
+        });
+        it("invalidates the whole app when a tag's marker row cannot be written", async () => {
+            // Other instances would never see the revalidation, so no path list is
+            // enough.
+            process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = "test-param-name";
+            jest.spyOn(console, "error").mockImplementation();
+            mockDynamoSend.mockImplementation((command) => command instanceof client_dynamodb_1.QueryCommand
+                ? Promise.resolve({ Items: [] })
+                : Promise.reject(new Error("ProvisionedThroughputExceeded")));
+            mockSsmSend.mockResolvedValue({
+                Parameter: { Value: "test-distribution-id" },
+            });
+            mockCloudFrontSend.mockResolvedValue({});
+            await new s3_cache_handler_1.S3CacheHandler({ context: mockContext }).revalidateTag("posts");
+            expect(invalidations()).toEqual([["/*"]]);
+        });
+        it("invalidates the whole app when a tag's mapping rows cannot be read", async () => {
+            // The marker row is written before the Query, so a failed Query leaves
+            // the tag revalidated at the origin with no paths named for the edge.
+            process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = "test-param-name";
+            jest.spyOn(console, "error").mockImplementation();
+            mockDynamoSend.mockImplementation((command) => command instanceof client_dynamodb_1.QueryCommand
+                ? Promise.reject(new Error("ProvisionedThroughputExceeded"))
+                : Promise.resolve({}));
+            mockSsmSend.mockResolvedValue({
+                Parameter: { Value: "test-distribution-id" },
+            });
+            mockCloudFrontSend.mockResolvedValue({});
+            await new s3_cache_handler_1.S3CacheHandler({ context: mockContext }).revalidateTag([
+                "_N_T_/a",
+                "posts",
+            ]);
+            expect(invalidations()).toEqual([["/*"]]);
+        });
+        describe("when CloudFront's invalidation quota is full", () => {
+            beforeEach(() => {
+                jest.useFakeTimers();
+            });
+            afterEach(() => {
+                jest.useRealTimers();
+            });
+            const quotaError = () => Object.assign(new Error("Your request contains too many invalidations"), {
+                name: "TooManyInvalidationsInProgress",
+            });
+            it("retries as one app-wide wildcard after a backoff", async () => {
+                const cdnHandler = withDistribution(pages("test-tag", 2));
+                mockCloudFrontSend
+                    .mockRejectedValueOnce(quotaError())
+                    .mockResolvedValueOnce({});
+                const done = cdnHandler.revalidateTag("test-tag");
+                await jest.advanceTimersByTimeAsync(1000);
+                await done;
+                expect(invalidations()).toEqual([["/isr/0*", "/isr/1*"], ["/*"]]);
+            });
+            it("gives up after the last retry", async () => {
+                const cdnHandler = withDistribution(pages("test-tag", 1));
+                mockCloudFrontSend.mockRejectedValue(quotaError());
+                const done = cdnHandler.revalidateTag("test-tag");
+                await jest.advanceTimersByTimeAsync(3000);
+                await expect(done).resolves.toBeUndefined();
+                expect(invalidations()).toEqual([["/isr/0*"], ["/*"], ["/*"]]);
+            });
+            it("does not retry any other error", async () => {
+                const cdnHandler = withDistribution(pages("test-tag", 1));
+                mockCloudFrontSend.mockRejectedValue(new Error("AccessDenied"));
+                await cdnHandler.revalidateTag("test-tag");
+                expect(invalidations()).toEqual([["/isr/0*"]]);
+            });
+            it("retries the app's root under a basePath too", async () => {
+                // `/base/*` matches neither `/base` nor `/base?_rsc=…`: retrying
+                // `revalidatePath("/")` as that left the home page stale at the edge.
+                useBasePath();
+                const cdnHandler = withDistribution({ Items: [] });
+                mockCloudFrontSend
+                    .mockRejectedValueOnce(quotaError())
+                    .mockResolvedValueOnce({});
+                const done = cdnHandler.revalidateTag("_N_T_/");
+                await jest.advanceTimersByTimeAsync(1000);
+                await done;
+                expect(invalidations()[1]).toEqual(["/base", "/base?*", "/base/*"]);
+            });
+        });
+        it("records a profile's revalidation as stale now, expiring later", async () => {
+            const before = Date.now();
+            await handler.revalidateTag("posts", { expire: 60 });
+            const [input] = client_dynamodb_1.UpdateItemCommand.mock.calls[0];
+            expect(input.Key.sk.S).toBe("posts");
+            expect(input.UpdateExpression).toBe("SET staleAt = :staleAt, expiredAt = :expiredAt");
+            const staleAt = Number(input.ExpressionAttributeValues[":staleAt"].N);
+            expect(staleAt).toBeGreaterThanOrEqual(before);
+            expect(Number(input.ExpressionAttributeValues[":expiredAt"].N)).toBe(staleAt + 60_000);
+        });
+    });
+    /**
+     * The cache handler's half of `res.revalidate()`'s CDN invalidation: the hook
+     * it registers for `invalidateRevalidatedPage` in `runtime/core.ts`. The
+     * runtime's half is in `core.test.ts`.
+     */
+    describe("the revalidated-page hook", () => {
+        const HOOK = manifest_1.REVALIDATED_PAGE_HOOK;
+        const globals = globalThis;
+        beforeEach(() => {
+            delete globals[HOOK];
+            mockSsmSend.mockResolvedValue({ Parameter: { Value: "EDISTRIBUTION" } });
+            mockCloudFrontSend.mockResolvedValue({});
+            client_cloudfront_1.CreateInvalidationCommand.mockClear();
+        });
+        function invalidatedPaths() {
+            const [input] = client_cloudfront_1.CreateInvalidationCommand.mock
+                .calls[0];
+            return input.InvalidationBatch.Paths.Items;
+        }
+        it("is registered only behind a distribution", () => {
+            new s3_cache_handler_1.S3CacheHandler({ context: mockContext });
+            expect(globals[HOOK]).toBeUndefined();
+            process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = "param";
+            new s3_cache_handler_1.S3CacheHandler({ context: mockContext });
+            expect(typeof globals[HOOK]).toBe("function");
+        });
+        it("invalidates the page and its data route under basePath", async () => {
+            process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = "param";
+            new s3_cache_handler_1.S3CacheHandler({ context: mockContext, basePath: "base" });
+            await globals[HOOK]([
+                "/blog/hello",
+                "/_next/data/test-build-id/blog/hello.json",
+            ]);
+            expect(invalidatedPaths()).toEqual([
+                "/base/blog/hello*",
+                "/base/_next/data/test-build-id/blog/hello.json*",
+            ]);
+        });
+        it("spells out the root rather than invalidating the whole app", async () => {
+            process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = "param";
+            new s3_cache_handler_1.S3CacheHandler({ context: mockContext });
+            await globals[HOOK]([
+                "/",
+                "/_next/data/test-build-id/index.json",
+            ]);
+            expect(invalidatedPaths()).toEqual([
+                "/",
+                "/?*",
+                "/_next/data/test-build-id/index.json*",
+            ]);
+        });
+        it("sends every path once, in one invalidation", async () => {
+            process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = "param";
+            new s3_cache_handler_1.S3CacheHandler({ context: mockContext });
+            await globals[HOOK]([
+                "/blog",
+                "/_next/data/test-build-id/en/blog.json",
+                "/en/blog",
+                "/blog",
+            ]);
+            expect(client_cloudfront_1.CreateInvalidationCommand).toHaveBeenCalledTimes(1);
+            expect(invalidatedPaths()).toEqual([
+                "/blog*",
+                "/_next/data/test-build-id/en/blog.json*",
+                "/en/blog*",
+            ]);
+        });
+    });
+    describe("resetRequestCache", () => {
+        it("should complete without errors", async () => {
+            await expect(handler.resetRequestCache()).resolves.not.toThrow();
         });
     });
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"s3-cache-handler.test.js","sourceRoot":"","sources":["../../src/adapter/s3-cache-handler.test.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\n// Mock AWS SDK\njest.mock(\"@aws-sdk/client-s3\");\njest.mock(\"@aws-sdk/client-dynamodb\");\njest.mock(\"@aws-sdk/client-cloudfront\");\njest.mock(\"@aws-sdk/client-ssm\");\n\nimport {\n  CloudFrontClient,\n  CreateInvalidationCommand,\n} from \"@aws-sdk/client-cloudfront\";\nimport {\n  DynamoDBClient,\n  QueryCommand,\n  UpdateItemCommand,\n} from \"@aws-sdk/client-dynamodb\";\nimport {\n  S3Client,\n  GetObjectCommand,\n  PutObjectCommand,\n  DeleteObjectCommand,\n} from \"@aws-sdk/client-s3\";\nimport { SSMClient } from \"@aws-sdk/client-ssm\";\nimport { CacheHandlerContext } from \"next/dist/server/lib/incremental-cache\";\nimport {\n  IncrementalCacheValue,\n  CachedRouteKind,\n  IncrementalCacheKind,\n} from \"next/dist/server/response-cache\";\nimport { S3CacheHandler } from \"./s3-cache-handler\";\n\nconst mockS3Send = jest.fn();\nconst mockDynamoSend = jest.fn();\nconst mockCloudFrontSend = jest.fn();\nconst mockSsmSend = jest.fn();\n\n(S3Client as jest.Mock).mockImplementation(() => ({\n  send: mockS3Send,\n}));\n\n(DynamoDBClient as jest.Mock).mockImplementation(() => ({\n  send: mockDynamoSend,\n}));\n\n(CloudFrontClient as jest.Mock).mockImplementation(() => ({\n  send: mockCloudFrontSend,\n}));\n\n(SSMClient as jest.Mock).mockImplementation(() => ({\n  send: mockSsmSend,\n}));\n\ndescribe(\"S3DynamoCacheHandler\", () => {\n  let handler: S3CacheHandler;\n  let mockContext: CacheHandlerContext;\n\n  // Helper to create set context with tags\n  const createSetContext = (tags: string[]) => ({\n    fetchCache: true as const,\n    tags,\n  });\n\n  beforeEach(() => {\n    mockContext = { dev: false } as CacheHandlerContext;\n\n    // Set up environment variables\n    process.env.CDK_NEXTJS_CACHE_BUCKET_NAME = \"test-bucket\";\n    process.env.CDK_NEXTJS_REVALIDATION_TABLE_NAME = \"test-table\";\n    process.env.CDK_NEXTJS_BUILD_ID = \"test-build-id\";\n    process.env.AWS_REGION = \"us-east-1\";\n\n    // Suppress expected warnings globally (tests deliberately trigger warnings)\n    jest.spyOn(console, \"warn\").mockImplementation();\n\n    handler = new S3CacheHandler({\n      context: mockContext,\n    });\n\n    // Reset mocks\n    mockS3Send.mockReset();\n    mockDynamoSend.mockReset();\n    mockCloudFrontSend.mockReset();\n    mockSsmSend.mockReset();\n  });\n\n  afterEach(() => {\n    // Clean up environment variables\n    delete process.env.CDK_NEXTJS_CACHE_BUCKET_NAME;\n    delete process.env.CDK_NEXTJS_REVALIDATION_TABLE_NAME;\n    delete process.env.CDK_NEXTJS_BUILD_ID;\n    delete process.env.AWS_REGION;\n    delete process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME;\n\n    // Restore console.warn\n    jest.restoreAllMocks();\n  });\n\n  describe(\"get\", () => {\n    it(\"should return null when S3 bucket is not configured\", async () => {\n      delete process.env.CDK_NEXTJS_CACHE_BUCKET_NAME;\n\n      const handlerWithoutBucket = new S3CacheHandler({\n        context: mockContext,\n      });\n\n      const result = await handlerWithoutBucket.get(\"test-key\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n      expect(result).toBeNull();\n    });\n\n    it(\"should retrieve and parse cache value from S3\", 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 cacheValue = {\n        lastModified: Date.now(),\n        value: testData,\n      };\n\n      mockS3Send.mockResolvedValueOnce({\n        Body: {\n          transformToString: jest\n            .fn()\n            .mockResolvedValue(JSON.stringify(cacheValue)),\n        },\n        ContentType: \"application/json\",\n      });\n\n      const result = await handler.get(\"test-key\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n\n      expect(result).toEqual(cacheValue);\n      expect(mockS3Send).toHaveBeenCalledWith(expect.any(GetObjectCommand));\n    });\n\n    it(\"should return null when S3 object not found\", async () => {\n      mockS3Send.mockResolvedValueOnce({\n        Body: null,\n      });\n\n      const result = await handler.get(\"missing-key\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n      expect(result).toBeNull();\n    });\n\n    it(\"should handle S3 errors and return null\", async () => {\n      mockS3Send.mockRejectedValueOnce(new Error(\"S3 Error\"));\n\n      const result = await handler.get(\"error-key\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n      expect(result).toBeNull();\n    });\n  });\n\n  describe(\"set\", () => {\n    it(\"should store cache value in S3\", async () => {\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>set test</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n\n      mockS3Send.mockResolvedValueOnce({});\n      mockDynamoSend.mockResolvedValue({});\n\n      await handler.set(\"set-key\", testData, createSetContext([\"tag1\"]));\n\n      expect(mockS3Send).toHaveBeenCalledWith(expect.any(PutObjectCommand));\n      expect(mockDynamoSend).toHaveBeenCalledWith(\n        expect.any(UpdateItemCommand),\n      );\n    });\n\n    it(\"should not store when S3 bucket is not configured\", async () => {\n      delete process.env.CDK_NEXTJS_CACHE_BUCKET_NAME;\n\n      const handlerWithoutBucket = new S3CacheHandler({\n        context: mockContext,\n      });\n\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>no bucket</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n\n      await handlerWithoutBucket.set(\n        \"no-bucket-key\",\n        testData,\n        createSetContext([]),\n      );\n\n      expect(mockS3Send).not.toHaveBeenCalled();\n    });\n\n    it(\"should handle S3 errors gracefully\", async () => {\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>error test</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n\n      mockS3Send.mockRejectedValueOnce(new Error(\"S3 Put Error\"));\n\n      // Should not throw\n      await expect(\n        handler.set(\"error-key\", testData, createSetContext([])),\n      ).resolves.not.toThrow();\n    });\n  });\n\n  describe(\"revalidateTag\", () => {\n    it(\"should query DynamoDB and delete S3 entries\", async () => {\n      const mockQueryResponse = {\n        Items: [\n          { sk: { S: \"test-tag#cache-key-1\" } },\n          { sk: { S: \"test-tag#cache-key-2\" } },\n        ],\n      };\n\n      mockDynamoSend.mockResolvedValueOnce(mockQueryResponse);\n      mockDynamoSend.mockResolvedValue({}); // For update commands\n      mockS3Send.mockResolvedValue({}); // For delete commands\n\n      await handler.revalidateTag(\"test-tag\");\n\n      expect(mockDynamoSend).toHaveBeenCalledWith(expect.any(QueryCommand));\n      expect(mockDynamoSend).toHaveBeenCalledWith(\n        expect.any(UpdateItemCommand),\n      );\n      expect(mockS3Send).toHaveBeenCalledWith(expect.any(DeleteObjectCommand));\n    });\n\n    it(\"should not revalidate when DynamoDB table is not configured\", async () => {\n      delete process.env.CDK_NEXTJS_REVALIDATION_TABLE_NAME;\n\n      const handlerWithoutTable = new S3CacheHandler({\n        context: mockContext,\n      });\n\n      await handlerWithoutTable.revalidateTag(\"test-tag\");\n\n      expect(mockDynamoSend).not.toHaveBeenCalled();\n    });\n\n    it(\"should handle DynamoDB errors gracefully\", async () => {\n      mockDynamoSend.mockRejectedValueOnce(new Error(\"DynamoDB Error\"));\n\n      // Should not throw\n      await expect(handler.revalidateTag(\"error-tag\")).resolves.not.toThrow();\n    });\n\n    it(\"should create a CloudFront invalidation for affected paths when a distribution parameter is configured\", async () => {\n      process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = \"test-param-name\";\n      const handlerWithDistribution = new S3CacheHandler({\n        context: mockContext,\n      });\n\n      const mockQueryResponse = {\n        Items: [\n          { sk: { S: \"test-tag#test-build-id/isr/1.json\" } },\n          { sk: { S: \"test-tag#test-build-id/isr/2.json\" } },\n        ],\n      };\n\n      mockDynamoSend.mockResolvedValueOnce(mockQueryResponse);\n      mockDynamoSend.mockResolvedValue({}); // For update commands\n      mockS3Send.mockResolvedValue({}); // For delete commands\n      mockSsmSend.mockResolvedValue({\n        Parameter: { Value: \"test-distribution-id\" },\n      });\n      mockCloudFrontSend.mockResolvedValue({});\n\n      await handlerWithDistribution.revalidateTag(\"test-tag\");\n\n      expect(mockSsmSend).toHaveBeenCalledWith(expect.any(Object));\n      expect(mockCloudFrontSend).toHaveBeenCalledWith(\n        expect.any(CreateInvalidationCommand),\n      );\n      const [invalidationInput] = (\n        CreateInvalidationCommand as unknown as jest.Mock\n      ).mock.calls[0];\n      expect(invalidationInput.DistributionId).toBe(\"test-distribution-id\");\n      expect(invalidationInput.InvalidationBatch.Paths.Items).toEqual(\n        expect.arrayContaining([\"/isr/1\", \"/isr/2\"]),\n      );\n    });\n\n    it(\"should not call SSM or CloudFront when no distribution parameter is configured\", async () => {\n      const mockQueryResponse = {\n        Items: [{ sk: { S: \"test-tag#test-build-id/isr/1.json\" } }],\n      };\n\n      mockDynamoSend.mockResolvedValueOnce(mockQueryResponse);\n      mockDynamoSend.mockResolvedValue({});\n      mockS3Send.mockResolvedValue({});\n\n      await handler.revalidateTag(\"test-tag\");\n\n      expect(mockSsmSend).not.toHaveBeenCalled();\n      expect(mockCloudFrontSend).not.toHaveBeenCalled();\n    });\n\n    it(\"should handle SSM/CloudFront invalidation errors gracefully\", async () => {\n      process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = \"test-param-name\";\n      const handlerWithDistribution = new S3CacheHandler({\n        context: mockContext,\n      });\n\n      const mockQueryResponse = {\n        Items: [{ sk: { S: \"test-tag#test-build-id/isr/1.json\" } }],\n      };\n\n      mockDynamoSend.mockResolvedValueOnce(mockQueryResponse);\n      mockDynamoSend.mockResolvedValue({});\n      mockS3Send.mockResolvedValue({});\n      mockSsmSend.mockRejectedValueOnce(new Error(\"SSM Error\"));\n\n      await expect(\n        handlerWithDistribution.revalidateTag(\"test-tag\"),\n      ).resolves.not.toThrow();\n    });\n  });\n\n  describe(\"resetRequestCache\", () => {\n    it(\"should complete without errors\", async () => {\n      await expect(handler.resetRequestCache()).resolves.not.toThrow();\n    });\n  });\n\n  describe(\"custom configuration\", () => {\n    it(\"should accept custom configuration options\", () => {\n      const customHandler = new S3CacheHandler({\n        context: mockContext,\n        s3Config: {\n          bucketName: \"custom-bucket\",\n          region: \"eu-west-1\",\n          buildId: \"custom-build\",\n        },\n        dynamoConfig: {\n          tableName: \"custom-table\",\n          region: \"eu-west-1\",\n          buildId: \"custom-build\",\n        },\n      });\n\n      expect(customHandler).toBeDefined();\n    });\n  });\n});\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"s3-cache-handler.test.js","sourceRoot":"","sources":["../../src/adapter/s3-cache-handler.test.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\nimport { mkdtempSync, rmSync, writeFileSync } from \"node:fs\";\nimport { tmpdir } from \"node:os\";\nimport { join } from \"node:path\";\n// What `require.cache` holds in a running server. Jest's `createRequire` hands\n// out a cache of its own that nothing is ever loaded into, so the handler's\n// lookup of Next.js's tag manifest reads this stand-in instead.\nconst mockModuleCache: Record<string, unknown> = {};\njest.mock(\"node:module\", () => ({\n  ...jest.requireActual(\"node:module\"),\n  createRequire: () => ({ cache: mockModuleCache }),\n}));\n// Mock AWS SDK\njest.mock(\"@aws-sdk/client-s3\");\njest.mock(\"@aws-sdk/client-dynamodb\");\njest.mock(\"@aws-sdk/client-cloudfront\");\njest.mock(\"@aws-sdk/client-ssm\");\n\nimport {\n  CloudFrontClient,\n  CreateInvalidationCommand,\n} from \"@aws-sdk/client-cloudfront\";\nimport {\n  BatchGetItemCommand,\n  DeleteItemCommand,\n  DynamoDBClient,\n  PutItemCommand,\n  QueryCommand,\n  UpdateItemCommand,\n} from \"@aws-sdk/client-dynamodb\";\nimport {\n  S3Client,\n  GetObjectCommand,\n  PutObjectCommand,\n  DeleteObjectCommand,\n} from \"@aws-sdk/client-s3\";\nimport { SSMClient } from \"@aws-sdk/client-ssm\";\nimport { CacheHandlerContext } from \"next/dist/server/lib/incremental-cache\";\nimport {\n  IncrementalCacheValue,\n  CachedRouteKind,\n  IncrementalCacheKind,\n} from \"next/dist/server/response-cache\";\nimport { S3CacheHandler } from \"./s3-cache-handler\";\nimport { sharedTagManifest } from \"./use-cache-common\";\nimport { REVALIDATED_PAGE_HOOK } from \"../runtime/manifest\";\n\nconst mockS3Send = jest.fn();\nconst mockDynamoSend = jest.fn();\nconst mockCloudFrontSend = jest.fn();\nconst mockSsmSend = jest.fn();\n\n(S3Client as jest.Mock).mockImplementation(() => ({\n  send: mockS3Send,\n}));\n\n(DynamoDBClient as jest.Mock).mockImplementation(() => ({\n  send: mockDynamoSend,\n}));\n\n(CloudFrontClient as jest.Mock).mockImplementation(() => ({\n  send: mockCloudFrontSend,\n}));\n\n(SSMClient as jest.Mock).mockImplementation(() => ({\n  send: mockSsmSend,\n}));\n\ndescribe(\"S3DynamoCacheHandler\", () => {\n  let handler: S3CacheHandler;\n  let mockContext: CacheHandlerContext;\n  let distDir: string | undefined;\n\n  /** Stage `required-server-files.json` for an app with `basePath: \"/base\"`. */\n  const useBasePath = () => {\n    distDir = mkdtempSync(join(tmpdir(), \"s3-cache-handler-\"));\n    writeFileSync(\n      join(distDir, \"required-server-files.json\"),\n      JSON.stringify({ config: { basePath: \"/base\" } }),\n    );\n    mockContext.serverDistDir = join(distDir, \"server\");\n  };\n\n  // Helper to create set context with tags\n  const createSetContext = (tags: string[]) => ({\n    fetchCache: true as const,\n    tags,\n  });\n\n  /**\n   * The input a mocked command was constructed with. The SDK's command classes\n   * are automocked, so an instance carries nothing of its own.\n   */\n  const commandInput = (command: unknown, type: unknown) => {\n    const mock = type as jest.Mock;\n    return mock.mock.calls[mock.mock.instances.indexOf(command)][0];\n  };\n\n  /**\n   * Answer DynamoDB by command type rather than by call order: `revalidateTag`\n   * writes its tag marker before querying the tag's mapping rows, and which of\n   * those comes first is an implementation detail. `get` is the marker row every\n   * requested tag has, as a `GetItem` would have returned it.\n   */\n  const dynamoResponses = (responses: {\n    query?: unknown;\n    get?: { Item?: Record<string, unknown> };\n  }) => {\n    mockDynamoSend.mockImplementation((command: unknown) => {\n      if (command instanceof QueryCommand) {\n        return Promise.resolve(responses.query ?? {});\n      }\n      if (command instanceof BatchGetItemCommand) {\n        const { RequestItems } = commandInput(command, BatchGetItemCommand);\n        const [[table, { Keys }]] = Object.entries(RequestItems) as [\n          string,\n          { Keys: { sk: unknown }[] },\n        ][];\n        const item = responses.get?.Item;\n        return Promise.resolve({\n          Responses: {\n            [table]: item ? Keys.map(({ sk }) => ({ ...item, sk })) : [],\n          },\n        });\n      }\n      return Promise.resolve({});\n    });\n  };\n\n  /**\n   * Drop the process's tag manifest, so the next handler starts with one of\n   * its own, as a new instance does.\n   */\n  const resetTagManifest = () => {\n    delete (globalThis as Record<symbol, unknown>)[\n      Symbol.for(\"cdk-nextjs.use-cache.tag-manifest\")\n    ];\n  };\n\n  beforeEach(() => {\n    mockContext = { dev: false } as CacheHandlerContext;\n    resetTagManifest();\n\n    // Set up environment variables\n    process.env.CDK_NEXTJS_CACHE_BUCKET_NAME = \"test-bucket\";\n    process.env.CDK_NEXTJS_REVALIDATION_TABLE_NAME = \"test-table\";\n    process.env.CDK_NEXTJS_BUILD_ID = \"test-build-id\";\n    process.env.AWS_REGION = \"us-east-1\";\n\n    // Suppress expected warnings globally (tests deliberately trigger warnings)\n    jest.spyOn(console, \"warn\").mockImplementation();\n\n    handler = new S3CacheHandler({\n      context: mockContext,\n    });\n\n    // Reset mocks\n    mockS3Send.mockReset();\n    // An empty bucket: no object, such as no build tag manifest.\n    mockS3Send.mockResolvedValue({});\n    mockDynamoSend.mockReset();\n    mockCloudFrontSend.mockReset();\n    mockSsmSend.mockReset();\n  });\n\n  afterEach(() => {\n    // Clean up environment variables\n    delete process.env.CDK_NEXTJS_CACHE_BUCKET_NAME;\n    delete process.env.CDK_NEXTJS_REVALIDATION_TABLE_NAME;\n    delete process.env.CDK_NEXTJS_BUILD_ID;\n    delete process.env.AWS_REGION;\n    delete process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME;\n    delete process.env.CDK_NEXTJS_DISTRIBUTION_ID;\n    if (distDir) {\n      rmSync(distDir, { recursive: true, force: true });\n      distDir = undefined;\n    }\n\n    // Restore console.warn\n    jest.restoreAllMocks();\n  });\n\n  describe(\"get\", () => {\n    it(\"should return null when S3 bucket is not configured\", async () => {\n      delete process.env.CDK_NEXTJS_CACHE_BUCKET_NAME;\n\n      const handlerWithoutBucket = new S3CacheHandler({\n        context: mockContext,\n      });\n\n      const result = await handlerWithoutBucket.get(\"test-key\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n      expect(result).toBeNull();\n    });\n\n    it(\"should retrieve and parse cache value from S3\", 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 cacheValue = {\n        lastModified: Date.now(),\n        value: testData,\n      };\n\n      mockS3Send.mockResolvedValueOnce({\n        Body: {\n          transformToString: jest\n            .fn()\n            .mockResolvedValue(JSON.stringify(cacheValue)),\n        },\n        ContentType: \"application/json\",\n      });\n\n      const result = await handler.get(\"test-key\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n\n      expect(result).toEqual(cacheValue);\n      expect(mockS3Send).toHaveBeenCalledWith(expect.any(GetObjectCommand));\n    });\n\n    it(\"should return null when S3 object not found\", async () => {\n      mockS3Send.mockResolvedValueOnce({\n        Body: null,\n      });\n\n      const result = await handler.get(\"missing-key\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n      expect(result).toBeNull();\n    });\n\n    it(\"invalidates a seeded prerender only when its tag marker is newer\", async () => {\n      // A build-time prerender is written as a file by the adapter's\n      // `onBuildComplete`, never through `set`, so it has no `tags` array and no\n      // DynamoDB mapping rows - its tags live in the render's\n      // `x-next-cache-tags` header. Two bugs met here: those header tags were\n      // ignored, so `revalidateTag` could not reach any static page; and the\n      // mapping rows `set` writes were stamped `revalidatedAt = now`, which is\n      // *after* the entry's own `lastModified`, so a tagged entry looked\n      // revalidated the moment it was stored and every request re-rendered.\n      // Measured against next.js's `test/e2e/app-dir/resume-data-cache`.\n      const lastModified = Date.now();\n      const seeded = {\n        lastModified,\n        value: {\n          kind: CachedRouteKind.APP_PAGE,\n          html: \"<html>seeded</html>\",\n          headers: { \"x-next-cache-tags\": \"_N_T_/,_N_T_/page,test\" },\n        },\n      };\n      const s3Body = () => ({\n        Body: {\n          transformToString: jest\n            .fn()\n            .mockResolvedValue(JSON.stringify(seeded)),\n        },\n        ContentType: \"application/json\",\n      });\n      mockS3Send.mockImplementation((command: unknown) =>\n        Promise.resolve(command instanceof GetObjectCommand ? s3Body() : {}),\n      );\n      const getCtx = {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      } as const;\n      // Each step below changes the markers DynamoDB holds; a new instance\n      // reads them afresh.\n      const freshHandler = () => {\n        resetTagManifest();\n        return new S3CacheHandler({ context: mockContext });\n      };\n\n      // No marker at all: the tag was never revalidated.\n      dynamoResponses({});\n      expect(await freshHandler().get(\"index\", getCtx)).toMatchObject({\n        lastModified,\n      });\n\n      // A marker older than the entry means the entry already reflects it.\n      dynamoResponses({\n        get: { Item: { revalidatedAt: { N: String(lastModified - 1000) } } },\n      });\n      expect(await freshHandler().get(\"index\", getCtx)).toMatchObject({\n        lastModified,\n      });\n      expect(mockS3Send).not.toHaveBeenCalledWith(\n        expect.any(DeleteObjectCommand),\n      );\n\n      // A newer marker: the entry comes back marked expired, and stays in S3.\n      dynamoResponses({\n        get: { Item: { revalidatedAt: { N: String(lastModified + 1000) } } },\n      });\n      expect(await freshHandler().get(\"index\", getCtx)).toMatchObject({\n        lastModified: -1,\n        value: seeded.value,\n      });\n      expect(mockS3Send).not.toHaveBeenCalledWith(\n        expect.any(DeleteObjectCommand),\n      );\n    });\n\n    it(\"reports a revalidated response entry as expired rather than as a miss\", async () => {\n      // `lastModified: -1` is how a cache handler says \"expired, re-render\n      // before answering\": `IncrementalCache.get` turns it into `isStale: -1`,\n      // which `app-page-runtime` reads as an on-demand revalidation and answers\n      // with a blocking render of this route, then stores it. Returning `null`\n      // is not equivalent. A miss on a PPR route whose `prerender-manifest.json`\n      // entry has a `fallback` (`compute: \"resuming\"`) is answered from the\n      // route's fallback shell - `cache-control: private, no-store`, no\n      // `x-nextjs-cache` - and without `partialPrefetching` nothing ever\n      // upgrades that back into a concrete entry. So the first `revalidateTag`\n      // to reach a page left it uncacheable and dynamically resumed per request\n      // for the rest of the deployment's life, which is what the isr e2e's\n      // missing `x-nextjs-cache` header was.\n      const lastModified = Date.now();\n      const stored = {\n        lastModified,\n        tags: [\"collection\"],\n        value: {\n          kind: CachedRouteKind.APP_PAGE,\n          html: \"<html>isr</html>\",\n          headers: { \"x-next-cache-tags\": \"collection\" },\n        },\n      };\n      mockS3Send.mockImplementation((command: unknown) =>\n        Promise.resolve(\n          command instanceof GetObjectCommand\n            ? {\n                Body: {\n                  transformToString: jest\n                    .fn()\n                    .mockResolvedValue(JSON.stringify(stored)),\n                },\n                ContentType: \"application/json\",\n              }\n            : {},\n        ),\n      );\n      dynamoResponses({\n        get: { Item: { revalidatedAt: { N: String(lastModified + 1000) } } },\n      });\n\n      const result = await handler.get(\"isr/1\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n\n      expect(result).toEqual({ lastModified: -1, value: stored.value });\n      // The body is still there for the render that fails, and `set` overwrites\n      // it with a `lastModified` past the marker.\n      expect(mockS3Send).not.toHaveBeenCalledWith(\n        expect.any(DeleteObjectCommand),\n      );\n    });\n\n    it(\"reports a revalidated fetch entry as a miss so the request refetches\", async () => {\n      // The opposite of a response entry: reusing a revalidated `fetch` body is\n      // serving stale data, so this reads as a miss, like Next.js's own\n      // `FileSystemCache` does for its `revalidatedTags`.\n      const lastModified = Date.now();\n      const stored = {\n        lastModified,\n        tags: [\"collection\"],\n        value: {\n          kind: CachedRouteKind.FETCH,\n          data: { headers: {}, body: \"stale\", status: 200, url: \"/api\" },\n          revalidate: 10,\n        },\n      };\n      mockS3Send.mockImplementation((command: unknown) =>\n        Promise.resolve(\n          command instanceof GetObjectCommand\n            ? {\n                Body: {\n                  transformToString: jest\n                    .fn()\n                    .mockResolvedValue(JSON.stringify(stored)),\n                },\n                ContentType: \"application/json\",\n              }\n            : {},\n        ),\n      );\n      dynamoResponses({\n        get: { Item: { revalidatedAt: { N: String(lastModified + 1000) } } },\n      });\n\n      const result = await handler.get(\"fetch-key\", {\n        kind: IncrementalCacheKind.FETCH,\n        revalidate: 10,\n        fetchUrl: \"https://example.test/api\",\n        fetchIdx: 1,\n        tags: [\"collection\"],\n        softTags: [],\n      });\n\n      expect(result).toBeNull();\n      // Not deleted: the refetch this provokes overwrites it through `set`.\n      // Deleting it here raced that write, so a concurrent request's fresh\n      // entry could be the one removed.\n      expect(mockS3Send).not.toHaveBeenCalledWith(\n        expect.any(DeleteObjectCommand),\n      );\n      expect(DeleteItemCommand as unknown as jest.Mock).not.toHaveBeenCalled();\n    });\n\n    it(\"checks a fetch entry against the request's implicit tags, not its own\", async () => {\n      // An untagged `cache: \"force-cache\"` fetch is stored with no tags at all -\n      // the implicit `_N_T_/<path>` chain reaches the handler only as\n      // `ctx.softTags`, which is the source Next.js's own `FileSystemCache` reads\n      // for a `FETCH` get. Checking the stored tags instead left this entry with\n      // nothing to check and no `revalidatePath` could ever evict it.\n      const lastModified = Date.now();\n      const stored = {\n        lastModified,\n        tags: [],\n        value: {\n          kind: CachedRouteKind.FETCH,\n          data: { headers: {}, body: \"stale\", status: 200, url: \"/api\" },\n          revalidate: 10,\n        },\n      };\n      mockS3Send.mockImplementation((command: unknown) =>\n        Promise.resolve(\n          command instanceof GetObjectCommand\n            ? {\n                Body: {\n                  transformToString: jest\n                    .fn()\n                    .mockResolvedValue(JSON.stringify(stored)),\n                },\n                ContentType: \"application/json\",\n              }\n            : {},\n        ),\n      );\n      dynamoResponses({\n        get: { Item: { revalidatedAt: { N: String(lastModified + 1000) } } },\n      });\n\n      const result = await handler.get(\"fetch-key\", {\n        kind: IncrementalCacheKind.FETCH,\n        revalidate: 10,\n        fetchUrl: \"https://next-data-api-endpoint.test/api/random\",\n        fetchIdx: 1,\n        tags: [],\n        softTags: [\"_N_T_/layout\", \"_N_T_/dynamic\"],\n      });\n\n      expect(result).toBeNull();\n      const [{ RequestItems }] = (BatchGetItemCommand as unknown as jest.Mock)\n        .mock.calls[0];\n      expect(\n        RequestItems[\"test-table\"].Keys.map(\n          (key: { sk: { S: string } }) => key.sk.S,\n        ),\n      ).toEqual([\"_N_T_/layout\", \"_N_T_/dynamic\"]);\n    });\n\n    describe(\"a tag revalidated with a profile\", () => {\n      // `revalidateTag(\"posts\", \"max\")` is stale-while-revalidate: the entry is\n      // served once more while a background render replaces it, and expires\n      // outright only after the profile's `expire`. Treating it as `updateTag`\n      // made every such call a blocking re-render.\n      const lastModified = Date.now() - 1000;\n      const stored = {\n        lastModified,\n        value: {\n          kind: CachedRouteKind.APP_PAGE,\n          html: \"<html>posts</html>\",\n          headers: { \"x-next-cache-tags\": \"posts\" },\n        },\n      };\n      const getCtx = {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      } as const;\n      const manifestPath = join(\n        \"/deployment/node_modules/next/dist/server/lib/incremental-cache\",\n        \"tags-manifest.external.js\",\n      );\n      // The module the server loads, resolved for real, so a Next.js upgrade\n      // that moves or reshapes it fails here rather than silently turning\n      // stale-while-revalidate into blocking renders.\n      const realManifestPath =\n        require.resolve(\"next/dist/server/lib/incremental-cache/tags-manifest.external.js\");\n\n      beforeEach(() => {\n        mockS3Send.mockImplementation((command: unknown) =>\n          Promise.resolve(\n            command instanceof GetObjectCommand\n              ? {\n                  Body: {\n                    transformToString: jest\n                      .fn()\n                      .mockResolvedValue(JSON.stringify(stored)),\n                  },\n                  ContentType: \"application/json\",\n                }\n              : {},\n          ),\n        );\n      });\n\n      afterEach(() => {\n        delete mockModuleCache[manifestPath];\n        delete mockModuleCache[realManifestPath];\n      });\n\n      it(\"serves the entry and marks the tag stale in Next.js's manifest\", async () => {\n        const next = jest.requireActual(realManifestPath);\n        mockModuleCache[realManifestPath] = { exports: next };\n        const staleAt = lastModified + 500;\n        dynamoResponses({\n          get: {\n            Item: {\n              staleAt: { N: String(staleAt) },\n              expiredAt: { N: String(Date.now() + 60_000) },\n            },\n          },\n        });\n\n        expect(await handler.get(\"posts\", getCtx)).toEqual({\n          lastModified,\n          value: stored.value,\n        });\n        // Where `IncrementalCache.get` reads it, to answer `isStale: true`.\n        expect(next.tagsManifest.get(\"posts\")).toEqual({ stale: staleAt });\n        expect(next.areTagsStale([\"posts\"], lastModified)).toBe(true);\n      });\n\n      it(\"expires the entry when Next.js's manifest cannot be found\", async () => {\n        // A stale mark nothing reads would serve the entry as fresh; a blocking\n        // render is the safe side of that.\n        dynamoResponses({\n          get: { Item: { staleAt: { N: String(lastModified + 500) } } },\n        });\n\n        expect(await handler.get(\"posts\", getCtx)).toMatchObject({\n          lastModified: -1,\n        });\n      });\n\n      it(\"expires the entry once the profile's expire has passed\", async () => {\n        dynamoResponses({\n          get: {\n            Item: {\n              staleAt: { N: String(lastModified + 100) },\n              expiredAt: { N: String(lastModified + 500) },\n            },\n          },\n        });\n\n        expect(await handler.get(\"posts\", getCtx)).toMatchObject({\n          lastModified: -1,\n        });\n      });\n\n      describe(\"behind a distribution\", () => {\n        // `revalidateTag`'s invalidation goes out before the stale entry is\n        // served, and the stale response carries the entry's original\n        // `s-maxage`: CloudFront caches it again. Only the regeneration's `set`\n        // knows when the fresh entry exists to be fetched instead.\n        let cdnHandler: S3CacheHandler;\n        const regenerated = stored.value as unknown as IncrementalCacheValue;\n        const invalidatedPaths = (): string[][] =>\n          (CreateInvalidationCommand as unknown as jest.Mock).mock.calls.map(\n            ([input]) => input.InvalidationBatch.Paths.Items,\n          );\n\n        beforeEach(() => {\n          process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = \"test-param-name\";\n          cdnHandler = new S3CacheHandler({ context: mockContext });\n          mockModuleCache[manifestPath] = {\n            exports: { tagsManifest: new Map() },\n          };\n          dynamoResponses({\n            get: { Item: { staleAt: { N: String(lastModified + 500) } } },\n          });\n          mockSsmSend.mockResolvedValue({\n            Parameter: { Value: \"test-distribution-id\" },\n          });\n          mockCloudFrontSend.mockResolvedValue({});\n        });\n\n        it(\"invalidates the page again once its regeneration is stored\", async () => {\n          await cdnHandler.get(\"posts\", getCtx);\n          expect(invalidatedPaths()).toEqual([]);\n\n          await cdnHandler.set(\"posts\", regenerated, {\n            cacheControl: { revalidate: false, expire: undefined },\n            isRoutePPREnabled: false,\n            isFallback: false,\n          } as any);\n\n          expect(invalidatedPaths()).toEqual([[\"/posts*\"]]);\n\n          // Once: a later write of the same page is an ordinary one.\n          await cdnHandler.set(\"posts\", regenerated, {\n            cacheControl: { revalidate: false, expire: undefined },\n            isRoutePPREnabled: false,\n            isFallback: false,\n          } as any);\n          expect(invalidatedPaths()).toHaveLength(1);\n        });\n\n        it(\"remembers a stale memory hit by the key it was read under\", async () => {\n          await cdnHandler.isRevalidated(stored, getCtx, \"posts\");\n          await cdnHandler.set(\"posts\", regenerated, {\n            isRoutePPREnabled: false,\n            isFallback: false,\n          } as any);\n\n          expect(invalidatedPaths()).toEqual([[\"/posts*\"]]);\n        });\n\n        it(\"does not invalidate after an ordinary write\", async () => {\n          await cdnHandler.set(\"posts\", regenerated, {\n            isRoutePPREnabled: false,\n            isFallback: false,\n          } as any);\n\n          expect(invalidatedPaths()).toEqual([]);\n        });\n\n        it(\"forgets a stale page that is deleted instead of regenerated\", async () => {\n          await cdnHandler.get(\"posts\", getCtx);\n          await cdnHandler.set(\"posts\", null, {\n            isRoutePPREnabled: false,\n            isFallback: false,\n          } as any);\n          await cdnHandler.set(\"posts\", regenerated, {\n            isRoutePPREnabled: false,\n            isFallback: false,\n          } as any);\n\n          expect(invalidatedPaths()).toEqual([]);\n        });\n      });\n    });\n\n    it(\"should handle S3 errors and return null\", async () => {\n      mockS3Send.mockRejectedValueOnce(new Error(\"S3 Error\"));\n\n      const result = await handler.get(\"error-key\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n      expect(result).toBeNull();\n    });\n  });\n\n  describe(\"tag marker cache\", () => {\n    // Every cache hit checks its tags' markers, and all of a deployment's\n    // markers share one partition key: read per request, they capped a route's\n    // cache hits at ~1,900 req/s. Each instance holds them for a second.\n    const lastModified = Date.now() - 60_000;\n    const stored = {\n      lastModified,\n      value: {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>cached</html>\",\n        headers: { \"x-next-cache-tags\": \"_N_T_/page,posts\" },\n      },\n    };\n    const getCtx = {\n      kind: IncrementalCacheKind.APP_PAGE,\n      isFallback: false,\n    } as const;\n    const markerReads = () =>\n      mockDynamoSend.mock.calls.filter(\n        ([command]) => command instanceof BatchGetItemCommand,\n      ).length;\n    // What `get` answers for a revalidated page: expired, not a miss.\n    const expired = { lastModified: -1 };\n    const revalidatedAfterStore = {\n      get: { Item: { revalidatedAt: { N: String(lastModified + 1000) } } },\n    };\n\n    beforeEach(() => {\n      mockS3Send.mockImplementation((command: unknown) =>\n        Promise.resolve(\n          command instanceof GetObjectCommand\n            ? {\n                Body: {\n                  transformToString: jest\n                    .fn()\n                    .mockResolvedValue(JSON.stringify(stored)),\n                },\n                ContentType: \"application/json\",\n              }\n            : {},\n        ),\n      );\n      dynamoResponses({});\n    });\n\n    it(\"answers checks within the TTL from the markers it already read\", async () => {\n      await handler.get(\"page\", getCtx);\n      await handler.get(\"page\", getCtx);\n\n      expect(markerReads()).toBe(1);\n    });\n\n    it(\"shares one read between concurrent checks\", async () => {\n      await Promise.all([\n        handler.get(\"page\", getCtx),\n        handler.get(\"page\", getCtx),\n        handler.get(\"page\", getCtx),\n      ]);\n\n      expect(markerReads()).toBe(1);\n    });\n\n    it(\"sees its own revalidateTag at once, and logs it for the others\", async () => {\n      expect(await handler.get(\"page\", getCtx)).toMatchObject({ lastModified });\n\n      dynamoResponses(revalidatedAfterStore);\n      await handler.revalidateTag(\"posts\");\n\n      expect(await handler.get(\"page\", getCtx)).toMatchObject(expired);\n      const puts = mockDynamoSend.mock.calls.filter(\n        ([command]) => command instanceof PutItemCommand,\n      );\n      expect(puts).toHaveLength(1);\n      expect(commandInput(puts[0][0], PutItemCommand).Item).toMatchObject({\n        pk: { S: \"test-build-id#log\" },\n        sk: { S: expect.stringMatching(/^\\d{15}#posts$/) },\n        revalidatedAt: { N: expect.any(String) },\n        ttl: { N: expect.any(String) },\n      });\n    });\n\n    it(\"writes each tag once when the 'use cache' handlers get the same call\", async () => {\n      // Next.js calls `revalidateTag` here and `updateTags` on every\n      // `cacheHandlers` entry, and all of them share one manifest.\n      await Promise.all([\n        handler.revalidateTag([\"posts\"]),\n        sharedTagManifest().update([\"posts\"], undefined),\n      ]);\n\n      const writes = mockDynamoSend.mock.calls.filter(\n        ([command]) =>\n          command instanceof UpdateItemCommand ||\n          command instanceof PutItemCommand,\n      );\n      expect(writes).toHaveLength(2);\n    });\n  });\n\n  describe(\"set\", () => {\n    // Mapping rows exist only to name CloudFront paths, so only a deployment\n    // with a distribution keeps them.\n    beforeEach(() => {\n      process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = \"test-param-name\";\n      handler = new S3CacheHandler({ context: mockContext });\n    });\n\n    it(\"keeps no mapping rows without a distribution to invalidate\", async () => {\n      // The Regional constructs have no CloudFront. A row per tag per `set`,\n      // and the S3 read before a delete to name them, bought nothing there.\n      delete process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME;\n      const regional = new S3CacheHandler({ context: mockContext });\n      mockS3Send.mockResolvedValue({});\n      mockDynamoSend.mockResolvedValue({});\n\n      await regional.set(\n        \"/isr/1\",\n        {\n          kind: CachedRouteKind.APP_PAGE,\n          html: \"<p/>\",\n          rscData: undefined,\n          headers: { \"x-next-cache-tags\": \"tag\" },\n          postponed: undefined,\n          segmentData: undefined,\n          status: undefined,\n        },\n        createSetContext([]),\n      );\n      await regional.set(\"/isr/1\", null, { isFallback: false });\n\n      expect(mockDynamoSend).not.toHaveBeenCalled();\n      expect(mockS3Send).not.toHaveBeenCalledWith(expect.any(GetObjectCommand));\n      expect(mockS3Send).toHaveBeenCalledWith(expect.any(DeleteObjectCommand));\n    });\n\n    it(\"should store cache value in S3\", async () => {\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>set test</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n\n      mockS3Send.mockResolvedValueOnce({});\n      mockDynamoSend.mockResolvedValue({});\n\n      await handler.set(\"set-key\", testData, createSetContext([\"tag1\"]));\n\n      expect(mockS3Send).toHaveBeenCalledWith(expect.any(PutObjectCommand));\n      expect(mockDynamoSend).toHaveBeenCalledWith(\n        expect.any(UpdateItemCommand),\n      );\n    });\n\n    it(\"should not store when S3 bucket is not configured\", async () => {\n      delete process.env.CDK_NEXTJS_CACHE_BUCKET_NAME;\n\n      const handlerWithoutBucket = new S3CacheHandler({\n        context: mockContext,\n      });\n\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>no bucket</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n\n      await handlerWithoutBucket.set(\n        \"no-bucket-key\",\n        testData,\n        createSetContext([]),\n      );\n\n      expect(mockS3Send).not.toHaveBeenCalled();\n    });\n\n    it(\"maps the tags a page carries only in its x-next-cache-tags header\", async () => {\n      // `ResponseCache.set` builds a page's `ctx` without tags, so the render's\n      // header is the only place they exist. No mapping row meant `revalidateTag`\n      // found nothing to invalidate and CloudFront kept the stale HTML.\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>tagged</html>\",\n        rscData: undefined,\n        headers: { \"x-next-cache-tags\": \"header-tag,other-tag\" },\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n\n      mockS3Send.mockResolvedValue({});\n      mockDynamoSend.mockResolvedValue({});\n\n      await handler.set(\"/isr/1\", testData, createSetContext([]));\n\n      const mappingKeys = (UpdateItemCommand as unknown as jest.Mock).mock.calls\n        .map(([input]) => input.Key.sk.S)\n        .sort();\n      expect(mappingKeys).toEqual([\n        \"header-tag#test-build-id/isr/1.json\",\n        \"other-tag#test-build-id/isr/1.json\",\n      ]);\n    });\n\n    it(\"prefers the context's tags over the header when both are present\", async () => {\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>tagged</html>\",\n        rscData: undefined,\n        headers: { \"x-next-cache-tags\": \"header-tag\" },\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n\n      mockS3Send.mockResolvedValue({});\n      mockDynamoSend.mockResolvedValue({});\n\n      await handler.set(\"/isr/1\", testData, createSetContext([\"ctx-tag\"]));\n\n      const mappingKeys = (UpdateItemCommand as unknown as jest.Mock).mock.calls\n        .map(([input]) => input.Key.sk.S)\n        .sort();\n      expect(mappingKeys).toEqual([\"ctx-tag#test-build-id/isr/1.json\"]);\n    });\n\n    it(\"removes a deleted page's mapping rows, reading its tags from S3\", async () => {\n      // A response delete - a cached route that starts answering `notFound()` -\n      // arrives as `set(key, null, { cacheControl, ... })` with no tags at all,\n      // so the entry itself is the only place its mapping rows can be named\n      // from. Left behind, they resolve on the next `revalidateTag` to a cache\n      // key whose object is gone and spend a CloudFront wildcard path on it.\n      const stored = {\n        lastModified: Date.now(),\n        tags: [\"collection\", \"_N_T_/isr/1\"],\n        value: {\n          kind: CachedRouteKind.APP_PAGE,\n          html: \"<html>gone</html>\",\n        },\n      };\n      mockS3Send.mockImplementation((command: unknown) =>\n        Promise.resolve(\n          command instanceof GetObjectCommand\n            ? {\n                Body: {\n                  transformToString: jest\n                    .fn()\n                    .mockResolvedValue(JSON.stringify(stored)),\n                },\n                ContentType: \"application/json\",\n              }\n            : {},\n        ),\n      );\n      mockDynamoSend.mockResolvedValue({});\n\n      await handler.set(\"/isr/1\", null, {\n        cacheControl: { revalidate: 60, expire: undefined },\n        isRoutePPREnabled: false,\n        isFallback: false,\n      });\n\n      expect(mockS3Send).toHaveBeenCalledWith(expect.any(DeleteObjectCommand));\n      const deletedKeys = (DeleteItemCommand as unknown as jest.Mock).mock.calls\n        .map(([input]) => input.Key.sk.S)\n        .sort();\n      // Mapping rows only. The bare-tag marker row belongs to the tag, and\n      // `checkIfRevalidated` reads it for every other entry carrying it.\n      expect(deletedKeys).toEqual([\n        \"_N_T_/isr/1#test-build-id/isr/1.json\",\n        \"collection#test-build-id/isr/1.json\",\n      ]);\n    });\n\n    it(\"deletes a fetch entry's mapping rows from the context's tags alone\", async () => {\n      // `ctx` carries them here, so the pre-delete read is skipped: only the\n      // DeleteObject reaches S3.\n      mockS3Send.mockResolvedValue({});\n      mockDynamoSend.mockResolvedValue({});\n\n      await handler.set(\"fetch-key\", null, createSetContext([\"ctx-tag\"]));\n\n      expect(mockS3Send).not.toHaveBeenCalledWith(expect.any(GetObjectCommand));\n      const deletedKeys = (\n        DeleteItemCommand as unknown as jest.Mock\n      ).mock.calls.map(([input]) => input.Key.sk.S);\n      expect(deletedKeys).toEqual([\"ctx-tag#test-build-id/fetch-key.json\"]);\n    });\n\n    it(\"deletes no mapping rows for an untagged entry\", async () => {\n      mockS3Send.mockImplementation((command: unknown) =>\n        Promise.resolve(\n          command instanceof GetObjectCommand\n            ? {\n                Body: {\n                  transformToString: jest.fn().mockResolvedValue(\n                    JSON.stringify({\n                      lastModified: Date.now(),\n                      value: { kind: CachedRouteKind.APP_PAGE, html: \"<p/>\" },\n                    }),\n                  ),\n                },\n                ContentType: \"application/json\",\n              }\n            : {},\n        ),\n      );\n      mockDynamoSend.mockResolvedValue({});\n\n      await handler.set(\"/untagged\", null, { isFallback: false });\n\n      expect(mockS3Send).toHaveBeenCalledWith(expect.any(DeleteObjectCommand));\n      expect(DeleteItemCommand as unknown as jest.Mock).not.toHaveBeenCalled();\n    });\n\n    it(\"still deletes the object when its tags cannot be read\", async () => {\n      mockS3Send.mockImplementation((command: unknown) =>\n        command instanceof GetObjectCommand\n          ? Promise.reject(new Error(\"S3 Get Error\"))\n          : Promise.resolve({}),\n      );\n      mockDynamoSend.mockResolvedValue({});\n\n      await expect(\n        handler.set(\"/isr/1\", null, { isFallback: false }),\n      ).resolves.not.toThrow();\n\n      expect(mockS3Send).toHaveBeenCalledWith(expect.any(DeleteObjectCommand));\n    });\n\n    it(\"should handle S3 errors gracefully\", async () => {\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>error test</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n\n      mockS3Send.mockRejectedValueOnce(new Error(\"S3 Put Error\"));\n\n      // Should not throw\n      await expect(\n        handler.set(\"error-key\", testData, createSetContext([])),\n      ).resolves.not.toThrow();\n    });\n  });\n\n  describe(\"revalidateTag\", () => {\n    it(\"should record the revalidation without deleting the tag's S3 entries\", async () => {\n      const mockQueryResponse = {\n        Items: [\n          { sk: { S: \"test-tag#cache-key-1\" } },\n          { sk: { S: \"test-tag#cache-key-2\" } },\n        ],\n      };\n\n      dynamoResponses({ query: mockQueryResponse });\n      mockS3Send.mockResolvedValue({});\n\n      await handler.revalidateTag(\"test-tag\");\n\n      // No distribution, so no mapping rows to read: the marker is all of it.\n      expect(mockDynamoSend).not.toHaveBeenCalledWith(expect.any(QueryCommand));\n      expect(mockDynamoSend).toHaveBeenCalledWith(\n        expect.any(UpdateItemCommand),\n      );\n      // The marker row is the invalidation; `get` reads it and hands the entry\n      // back expired so Next.js re-renders the route and replaces the object.\n      // Deleting the objects here made the next request a hard miss, which on a\n      // PPR route is answered from the uncacheable fallback shell for good.\n      expect(mockS3Send).not.toHaveBeenCalledWith(\n        expect.any(DeleteObjectCommand),\n      );\n\n      // The tag marker `checkIfRevalidated` reads: keyed by the bare tag, so\n      // entries with no mapping row of their own still see the revalidation.\n      const markerWrite = (UpdateItemCommand as unknown as jest.Mock).mock.calls\n        .map(([input]) => input)\n        .find((input) => input.Key.sk.S === \"test-tag\");\n      expect(markerWrite).toMatchObject({\n        UpdateExpression: \"SET revalidatedAt = :revalidatedAt\",\n      });\n    });\n\n    it(\"should not revalidate when DynamoDB table is not configured\", async () => {\n      delete process.env.CDK_NEXTJS_REVALIDATION_TABLE_NAME;\n\n      const handlerWithoutTable = new S3CacheHandler({\n        context: mockContext,\n      });\n\n      await handlerWithoutTable.revalidateTag(\"test-tag\");\n\n      expect(mockDynamoSend).not.toHaveBeenCalled();\n    });\n\n    it(\"should handle DynamoDB errors gracefully\", async () => {\n      mockDynamoSend.mockRejectedValueOnce(new Error(\"DynamoDB Error\"));\n\n      // Should not throw\n      await expect(handler.revalidateTag(\"error-tag\")).resolves.not.toThrow();\n    });\n\n    it(\"should create a CloudFront invalidation for affected paths when a distribution parameter is configured\", async () => {\n      process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = \"test-param-name\";\n      const handlerWithDistribution = new S3CacheHandler({\n        context: mockContext,\n      });\n\n      const mockQueryResponse = {\n        Items: [\n          { sk: { S: \"test-tag#test-build-id/isr/1.json\" } },\n          { sk: { S: \"test-tag#test-build-id/isr/2.json\" } },\n        ],\n      };\n\n      dynamoResponses({ query: mockQueryResponse });\n      mockS3Send.mockResolvedValue({}); // For delete commands\n      mockSsmSend.mockResolvedValue({\n        Parameter: { Value: \"test-distribution-id\" },\n      });\n      mockCloudFrontSend.mockResolvedValue({});\n\n      await handlerWithDistribution.revalidateTag(\"test-tag\");\n\n      expect(mockSsmSend).toHaveBeenCalledWith(expect.any(Object));\n      expect(mockCloudFrontSend).toHaveBeenCalledWith(\n        expect.any(CreateInvalidationCommand),\n      );\n      const [invalidationInput] = (\n        CreateInvalidationCommand as unknown as jest.Mock\n      ).mock.calls[0];\n      expect(invalidationInput.DistributionId).toBe(\"test-distribution-id\");\n      // One trailing wildcard per page: an invalidation path matches only the\n      // query string it spells out, and a page's RSC payload is cached under\n      // `?_rsc=<hash>` - `/isr/1*` covers it, and the slash variant, for one\n      // of the fifteen wildcards instead of two.\n      expect(invalidationInput.InvalidationBatch.Paths.Items).toEqual([\n        \"/isr/1*\",\n        \"/isr/2*\",\n      ]);\n    });\n\n    it(\"invalidates a distribution whose ID is in the environment without SSM\", async () => {\n      // NextjsGlobalContainers: the task can name the distribution directly.\n      process.env.CDK_NEXTJS_DISTRIBUTION_ID = \"direct-distribution-id\";\n      const handlerWithDistribution = new S3CacheHandler({\n        context: mockContext,\n      });\n      dynamoResponses({\n        query: { Items: [{ sk: { S: \"test-tag#test-build-id/isr/1.json\" } }] },\n      });\n      mockS3Send.mockResolvedValue({});\n      mockCloudFrontSend.mockResolvedValue({});\n\n      await handlerWithDistribution.revalidateTag(\"test-tag\");\n\n      expect(mockSsmSend).not.toHaveBeenCalled();\n      const [invalidationInput] = (\n        CreateInvalidationCommand as unknown as jest.Mock\n      ).mock.calls[0];\n      expect(invalidationInput.DistributionId).toBe(\"direct-distribution-id\");\n    });\n\n    it(\"splits a mapping row at the tag's length, so a tag containing # still resolves\", async () => {\n      // A tag is app-defined: `revalidateTag(\"user#42\")` is legal. Splitting at\n      // the first \"#\" left \"42#test-build-id/account.json\" as the S3 key, whose\n      // invalidation path names nothing CloudFront cached, so the page stayed\n      // stale while the row was stamped revalidated and never retried.\n      process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = \"test-param-name\";\n      const handlerWithDistribution = new S3CacheHandler({\n        context: mockContext,\n      });\n\n      dynamoResponses({\n        query: { Items: [{ sk: { S: \"user#42#test-build-id/account.json\" } }] },\n      });\n      mockSsmSend.mockResolvedValue({\n        Parameter: { Value: \"test-distribution-id\" },\n      });\n      mockCloudFrontSend.mockResolvedValue({});\n\n      await handlerWithDistribution.revalidateTag(\"user#42\");\n\n      const [invalidationInput] = (\n        CreateInvalidationCommand as unknown as jest.Mock\n      ).mock.calls[0];\n      expect(invalidationInput.InvalidationBatch.Paths.Items).toEqual([\n        \"/account*\",\n      ]);\n    });\n\n    it(\"invalidates the path a revalidatePath tag names even with no mapping rows\", async () => {\n      // A build-time prerender has no mapping rows, so the query comes back\n      // empty and there is nothing to derive a CloudFront path from - except the\n      // tag, which for `revalidatePath` is `_N_T_<path>`. Without this the CDN\n      // answers with the pre-revalidation page until `s-maxage=31536000`\n      // expires. Measured against next.js's `test/e2e/app-dir/trailingslash`.\n      process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = \"test-param-name\";\n      const handlerWithDistribution = new S3CacheHandler({\n        context: mockContext,\n      });\n\n      dynamoResponses({ query: { Items: [] } });\n      mockSsmSend.mockResolvedValue({\n        Parameter: { Value: \"test-distribution-id\" },\n      });\n      mockCloudFrontSend.mockResolvedValue({});\n\n      await handlerWithDistribution.revalidateTag(\"_N_T_/en/legacy/\");\n\n      const [invalidationInput] = (\n        CreateInvalidationCommand as unknown as jest.Mock\n      ).mock.calls[0];\n      // Both slash variants, which the trailing wildcard covers: a\n      // `trailingSlash` app's cached URI is the redirect target, not the route.\n      expect(invalidationInput.InvalidationBatch.Paths.Items).toEqual([\n        \"/en/legacy*\",\n      ]);\n    });\n\n    it(\"invalidates the URI under the app's basePath, not the bare route\", async () => {\n      // CloudFront cached `/base/isr/1`; the cache key and the `revalidatePath`\n      // tag both name `/isr/1`, because Next.js strips `basePath` before routing\n      // and never shows it to the cache handler. Invalidating the bare route\n      // matches nothing at the edge, so the stale page survives until\n      // `s-maxage` expires.\n      process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = \"test-param-name\";\n      useBasePath();\n      const handlerWithBasePath = new S3CacheHandler({\n        context: mockContext,\n      });\n\n      dynamoResponses({\n        query: {\n          Items: [\n            { sk: { S: \"test-tag#test-build-id/isr/1.json\" } },\n            { sk: { S: \"test-tag#test-build-id/index.json\" } },\n          ],\n        },\n      });\n      mockS3Send.mockResolvedValue({});\n      mockSsmSend.mockResolvedValue({\n        Parameter: { Value: \"test-distribution-id\" },\n      });\n      mockCloudFrontSend.mockResolvedValue({});\n\n      await handlerWithBasePath.revalidateTag(\"test-tag\");\n\n      const [invalidationInput] = (\n        CreateInvalidationCommand as unknown as jest.Mock\n      ).mock.calls[0];\n      expect(invalidationInput.InvalidationBatch.Paths.Items).toEqual(\n        expect.arrayContaining([\n          \"/base/isr/1*\",\n          // The app's root under a `basePath` is `/base`, not `/base/`, and\n          // spelled out: `/base*` would be the whole app.\n          \"/base\",\n          \"/base?*\",\n          \"/base/\",\n          \"/base/?*\",\n        ]),\n      );\n      expect(invalidationInput.InvalidationBatch.Paths.Items).not.toContain(\n        \"/isr/1\",\n      );\n    });\n\n    it(\"adds the basePath to a revalidatePath tag's path too\", async () => {\n      process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = \"test-param-name\";\n      useBasePath();\n      const handlerWithBasePath = new S3CacheHandler({\n        context: mockContext,\n      });\n\n      dynamoResponses({ query: { Items: [] } });\n      mockSsmSend.mockResolvedValue({\n        Parameter: { Value: \"test-distribution-id\" },\n      });\n      mockCloudFrontSend.mockResolvedValue({});\n\n      await handlerWithBasePath.revalidateTag(\"_N_T_/blog\");\n\n      const [invalidationInput] = (\n        CreateInvalidationCommand as unknown as jest.Mock\n      ).mock.calls[0];\n      expect(invalidationInput.InvalidationBatch.Paths.Items).toEqual([\n        \"/base/blog*\",\n      ]);\n    });\n\n    it(\"does not invalidate a CloudFront path for an app tag\", async () => {\n      process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = \"test-param-name\";\n      const handlerWithDistribution = new S3CacheHandler({\n        context: mockContext,\n      });\n\n      dynamoResponses({ query: { Items: [] } });\n\n      await handlerWithDistribution.revalidateTag(\"posts\");\n\n      // Nothing to invalidate: an app tag names no path, and no entry is mapped\n      // to it.\n      expect(mockCloudFrontSend).not.toHaveBeenCalled();\n    });\n\n    it(\"should not call SSM or CloudFront when no distribution parameter is configured\", async () => {\n      const mockQueryResponse = {\n        Items: [{ sk: { S: \"test-tag#test-build-id/isr/1.json\" } }],\n      };\n\n      dynamoResponses({ query: mockQueryResponse });\n      mockS3Send.mockResolvedValue({});\n\n      await handler.revalidateTag(\"test-tag\");\n\n      expect(mockSsmSend).not.toHaveBeenCalled();\n      expect(mockCloudFrontSend).not.toHaveBeenCalled();\n    });\n\n    it(\"should handle SSM/CloudFront invalidation errors gracefully\", async () => {\n      process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = \"test-param-name\";\n      const handlerWithDistribution = new S3CacheHandler({\n        context: mockContext,\n      });\n\n      const mockQueryResponse = {\n        Items: [{ sk: { S: \"test-tag#test-build-id/isr/1.json\" } }],\n      };\n\n      dynamoResponses({ query: mockQueryResponse });\n      mockS3Send.mockResolvedValue({});\n      mockSsmSend.mockRejectedValueOnce(new Error(\"SSM Error\"));\n\n      await expect(\n        handlerWithDistribution.revalidateTag(\"test-tag\"),\n      ).resolves.not.toThrow();\n    });\n\n    it(\"invalidates the page itself for a revalidatePath(path, 'page') tag\", async () => {\n      // `revalidatePath(path, type)` appends the type to the implicit tag, so the\n      // tag reads `_N_T_/pricing/page` - a path no URL has. Taking it literally\n      // invalidated nothing that existed, which is the whole of the bug: the\n      // second argument silently turned CDN invalidation off.\n      process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = \"test-param-name\";\n      const handlerWithDistribution = new S3CacheHandler({\n        context: mockContext,\n      });\n\n      dynamoResponses({ query: { Items: [] } });\n      mockSsmSend.mockResolvedValue({\n        Parameter: { Value: \"test-distribution-id\" },\n      });\n      mockCloudFrontSend.mockResolvedValue({});\n\n      await handlerWithDistribution.revalidateTag(\"_N_T_/pricing/page\");\n\n      const [invalidationInput] = (\n        CreateInvalidationCommand as unknown as jest.Mock\n      ).mock.calls[0];\n      expect(invalidationInput.InvalidationBatch.Paths.Items).toEqual(\n        expect.arrayContaining([\"/pricing*\"]),\n      );\n    });\n\n    it(\"skips mapping rows that name no cached URI\", async () => {\n      // A dynamic template and a fetch-cache entry are both rows a real tag\n      // carries, and neither is a URL: `/blog/[slug]` matches nothing at the edge\n      // (CloudFront has no such URI), and a fetch key is a hash of the request.\n      process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = \"test-param-name\";\n      const handlerWithDistribution = new S3CacheHandler({\n        context: mockContext,\n      });\n\n      dynamoResponses({\n        query: {\n          Items: [\n            { sk: { S: \"test-tag#test-build-id/blog/[slug].json\" } },\n            {\n              sk: {\n                S: \"test-tag#test-build-id/0123456789abcdef0123456789abcdef.json\",\n              },\n            },\n            { sk: { S: \"test-tag#test-build-id/blog/hello.json\" } },\n          ],\n        },\n      });\n      mockS3Send.mockResolvedValue({});\n      mockSsmSend.mockResolvedValue({\n        Parameter: { Value: \"test-distribution-id\" },\n      });\n      mockCloudFrontSend.mockResolvedValue({});\n\n      await handlerWithDistribution.revalidateTag(\"test-tag\");\n\n      const [invalidationInput] = (\n        CreateInvalidationCommand as unknown as jest.Mock\n      ).mock.calls[0];\n      const items: string[] = invalidationInput.InvalidationBatch.Paths.Items;\n      expect(items).toEqual([\"/blog/hello*\"]);\n      expect(items.some((path) => path.includes(\"[\"))).toBe(false);\n      expect(items.some((path) => path.includes(\"0123456789abcdef\"))).toBe(\n        false,\n      );\n    });\n\n    it(\"walks every Query page of a tag's mapping rows\", async () => {\n      // One `Query` answers with at most 1 MB. A tag on a large app runs past\n      // that, and taking only the first page deleted some of the tag's entries\n      // and invalidated only some of its paths - a partial revalidation that\n      // looks like a cache bug.\n      process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = \"test-param-name\";\n      const handlerWithDistribution = new S3CacheHandler({\n        context: mockContext,\n      });\n\n      let queries = 0;\n      mockDynamoSend.mockImplementation((command: unknown) => {\n        if (command instanceof QueryCommand) {\n          queries++;\n          return Promise.resolve(\n            queries === 1\n              ? {\n                  Items: [{ sk: { S: \"test-tag#test-build-id/isr/1.json\" } }],\n                  LastEvaluatedKey: { pk: { S: \"test-build-id\" } },\n                }\n              : { Items: [{ sk: { S: \"test-tag#test-build-id/isr/2.json\" } }] },\n          );\n        }\n        return Promise.resolve({});\n      });\n      mockS3Send.mockResolvedValue({});\n      mockSsmSend.mockResolvedValue({\n        Parameter: { Value: \"test-distribution-id\" },\n      });\n      mockCloudFrontSend.mockResolvedValue({});\n\n      await handlerWithDistribution.revalidateTag(\"test-tag\");\n\n      expect(queries).toBe(2);\n      const [invalidationInput] = (\n        CreateInvalidationCommand as unknown as jest.Mock\n      ).mock.calls[0];\n      expect(invalidationInput.InvalidationBatch.Paths.Items).toEqual([\n        \"/isr/1*\",\n        \"/isr/2*\",\n      ]);\n    });\n\n    it(\"collapses to one app-wide wildcard rather than sending many invalidations\", async () => {\n      // CloudFront caps a request at 15 wildcard paths and allows 15\n      // invalidations in progress. A tag covering hundreds of pages therefore\n      // cannot be spelled out: sending a request per 15 paths throttles, and a\n      // throttled request is a page that stays stale.\n      process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = \"test-param-name\";\n      const handlerWithDistribution = new S3CacheHandler({\n        context: mockContext,\n      });\n\n      dynamoResponses({\n        query: {\n          Items: Array.from({ length: 200 }, (_, i) => ({\n            sk: { S: `test-tag#test-build-id/isr/${i}.json` },\n          })),\n        },\n      });\n      mockS3Send.mockResolvedValue({});\n      mockSsmSend.mockResolvedValue({\n        Parameter: { Value: \"test-distribution-id\" },\n      });\n      mockCloudFrontSend.mockResolvedValue({});\n\n      await handlerWithDistribution.revalidateTag(\"test-tag\");\n\n      expect(mockCloudFrontSend).toHaveBeenCalledTimes(1);\n      const [invalidationInput] = (\n        CreateInvalidationCommand as unknown as jest.Mock\n      ).mock.calls[0];\n      expect(invalidationInput.InvalidationBatch.Paths.Items).toEqual([\"/*\"]);\n    });\n\n    /** A handler with a distribution, and DynamoDB answering `query` for it. */\n    const withDistribution = (query: unknown) => {\n      process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = \"test-param-name\";\n      dynamoResponses({ query });\n      mockSsmSend.mockResolvedValue({\n        Parameter: { Value: \"test-distribution-id\" },\n      });\n      mockCloudFrontSend.mockResolvedValue({});\n      return new S3CacheHandler({ context: mockContext });\n    };\n    const invalidations = (): string[][] =>\n      (CreateInvalidationCommand as unknown as jest.Mock).mock.calls.map(\n        ([input]) => input.InvalidationBatch.Paths.Items,\n      );\n    const pages = (tag: string, count: number) => ({\n      Items: Array.from({ length: count }, (_, i) => ({\n        sk: { S: `${tag}#test-build-id/isr/${i}.json` },\n      })),\n    });\n\n    it(\"sends a tag's paths as one request while they fit\", async () => {\n      // CloudFront's wildcard quota is shared by every invalidation in\n      // progress on the distribution. Splitting ten pages' twenty wildcards\n      // into two back-to-back requests had the second rejected, and its pages\n      // stayed stale at the edge.\n      await withDistribution(pages(\"test-tag\", 10)).revalidateTag(\"test-tag\");\n\n      expect(invalidations()).toHaveLength(1);\n      expect(invalidations()[0]).toHaveLength(10);\n    });\n\n    it(\"collapses to the whole app past fifteen wildcards\", async () => {\n      await withDistribution(pages(\"test-tag\", 16)).revalidateTag(\"test-tag\");\n\n      expect(invalidations()).toEqual([[\"/*\"]]);\n    });\n\n    it(\"collapses to the whole app under a basePath, its root included\", async () => {\n      // Not `/base*`, which would also invalidate a sibling app at `/base2`.\n      useBasePath();\n      await withDistribution(pages(\"test-tag\", 16)).revalidateTag(\"test-tag\");\n\n      expect(invalidations()).toEqual([[\"/base\", \"/base?*\", \"/base/*\"]]);\n    });\n\n    it(\"invalidates the whole app under a basePath when a tag's rows cannot be read\", async () => {\n      useBasePath();\n      jest.spyOn(console, \"error\").mockImplementation();\n      const cdnHandler = withDistribution({ Items: [] });\n      mockDynamoSend.mockImplementation((command: unknown) =>\n        command instanceof QueryCommand\n          ? Promise.reject(new Error(\"ProvisionedThroughputExceeded\"))\n          : Promise.resolve({}),\n      );\n\n      await cdnHandler.revalidateTag(\"posts\");\n\n      expect(invalidations()).toEqual([[\"/base\", \"/base?*\", \"/base/*\"]]);\n    });\n\n    it(\"percent-encodes the routes it invalidates\", async () => {\n      // Cache keys are decoded pathnames, while CloudFront caches - and\n      // invalidation paths match - the encoded URI the browser sent.\n      await withDistribution({\n        Items: [\n          { sk: { S: \"test-tag#test-build-id/blog/héllo.json\" } },\n          { sk: { S: \"test-tag#test-build-id/blog/hello world.json\" } },\n          // Path delimiters Next.js re-escaped in the key stay as they are.\n          { sk: { S: \"test-tag#test-build-id/files/a%2Fb.json\" } },\n          { sk: { S: \"test-tag#test-build-id/@user/50%.json\" } },\n        ],\n      }).revalidateTag([\"test-tag\", \"_N_T_/tags/c#?\"]);\n\n      expect(invalidations()).toEqual([\n        [\n          \"/blog/h%C3%A9llo*\",\n          \"/blog/hello%20world*\",\n          \"/files/a%2Fb*\",\n          \"/@user/50%25*\",\n          \"/tags/c%23%3F*\",\n        ],\n      ]);\n    });\n\n    it(\"invalidates every tag of one call in a single request\", async () => {\n      // `revalidateTag` hands the handler every tag a request revalidated at\n      // once; a request per tag competes for the same quota.\n      await withDistribution({ Items: [] }).revalidateTag([\n        \"_N_T_/a\",\n        \"_N_T_/b\",\n      ]);\n\n      expect(invalidations()).toEqual([[\"/a*\", \"/b*\"]]);\n    });\n\n    it(\"invalidates the whole app when a tag has more rows than it walks\", async () => {\n      // The rows past the last page walked are pages too; invalidating only the\n      // ones read left the rest stale at the edge for up to a year.\n      process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = \"test-param-name\";\n      mockDynamoSend.mockImplementation((command: unknown) =>\n        Promise.resolve(\n          command instanceof QueryCommand\n            ? {\n                Items: [{ sk: { S: \"test-tag#test-build-id/isr/1.json\" } }],\n                LastEvaluatedKey: { pk: { S: \"test-build-id\" } },\n              }\n            : {},\n        ),\n      );\n      mockSsmSend.mockResolvedValue({\n        Parameter: { Value: \"test-distribution-id\" },\n      });\n      mockCloudFrontSend.mockResolvedValue({});\n\n      await new S3CacheHandler({ context: mockContext }).revalidateTag(\n        \"test-tag\",\n      );\n\n      expect(invalidations()).toEqual([[\"/*\"]]);\n    });\n\n    it(\"ignores rows that another tag sharing the prefix owns\", async () => {\n      // `begins_with(sk, \"user#\")` also matches the tag `user#42`: its bare\n      // marker row, and its mapping rows. Read as `user`'s, they became\n      // invalidation paths like `/42` that name nothing.\n      await withDistribution({\n        Items: [\n          { sk: { S: \"user#42\" } },\n          { sk: { S: \"user#42#test-build-id/account.json\" } },\n          { sk: { S: \"user#test-build-id/profile.json\" } },\n        ],\n      }).revalidateTag(\"user\");\n\n      expect(invalidations()).toEqual([[\"/profile*\"]]);\n    });\n\n    it(\"adds the build-time prerenders the build's tag manifest names, reading it once\", async () => {\n      // A prerender is written by the adapter, never through `set`, so it has\n      // no mapping row: the manifest is the only record of its tags.\n      const cdnHandler = withDistribution({\n        Items: [{ sk: { S: \"posts#test-build-id/blog/b.json\" } }],\n      });\n      const manifestGets = () =>\n        (GetObjectCommand as unknown as jest.Mock).mock.calls.filter(\n          ([input]) =>\n            input.Key === \"test-build-id/_cdk-nextjs-tag-manifest.json\",\n        );\n      mockS3Send.mockImplementation((command: unknown) =>\n        Promise.resolve(\n          command instanceof GetObjectCommand\n            ? {\n                Body: {\n                  transformToString: async () =>\n                    JSON.stringify({ posts: [\"blog/a\", \"index\"] }),\n                },\n              }\n            : {},\n        ),\n      );\n\n      await cdnHandler.revalidateTag(\"posts\");\n      await cdnHandler.revalidateTag(\"constructor\");\n\n      expect(invalidations()).toEqual([[\"/blog/b*\", \"/blog/a*\", \"/\", \"/?*\"]]);\n      expect(manifestGets()).toHaveLength(1);\n    });\n\n    it(\"invalidates the whole app when the build's tag manifest cannot be read, and reads it again next time\", async () => {\n      const cdnHandler = withDistribution({ Items: [] });\n      mockS3Send.mockRejectedValueOnce(new Error(\"AccessDenied\"));\n\n      await cdnHandler.revalidateTag(\"posts\");\n      await cdnHandler.revalidateTag(\"posts\");\n\n      expect(invalidations()).toEqual([[\"/*\"]]);\n      expect(mockS3Send).toHaveBeenCalledTimes(2);\n    });\n\n    it(\"invalidates the whole app when a tag's marker row cannot be written\", async () => {\n      // Other instances would never see the revalidation, so no path list is\n      // enough.\n      process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = \"test-param-name\";\n      jest.spyOn(console, \"error\").mockImplementation();\n      mockDynamoSend.mockImplementation((command: unknown) =>\n        command instanceof QueryCommand\n          ? Promise.resolve({ Items: [] })\n          : Promise.reject(new Error(\"ProvisionedThroughputExceeded\")),\n      );\n      mockSsmSend.mockResolvedValue({\n        Parameter: { Value: \"test-distribution-id\" },\n      });\n      mockCloudFrontSend.mockResolvedValue({});\n\n      await new S3CacheHandler({ context: mockContext }).revalidateTag(\"posts\");\n\n      expect(invalidations()).toEqual([[\"/*\"]]);\n    });\n\n    it(\"invalidates the whole app when a tag's mapping rows cannot be read\", async () => {\n      // The marker row is written before the Query, so a failed Query leaves\n      // the tag revalidated at the origin with no paths named for the edge.\n      process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = \"test-param-name\";\n      jest.spyOn(console, \"error\").mockImplementation();\n      mockDynamoSend.mockImplementation((command: unknown) =>\n        command instanceof QueryCommand\n          ? Promise.reject(new Error(\"ProvisionedThroughputExceeded\"))\n          : Promise.resolve({}),\n      );\n      mockSsmSend.mockResolvedValue({\n        Parameter: { Value: \"test-distribution-id\" },\n      });\n      mockCloudFrontSend.mockResolvedValue({});\n\n      await new S3CacheHandler({ context: mockContext }).revalidateTag([\n        \"_N_T_/a\",\n        \"posts\",\n      ]);\n\n      expect(invalidations()).toEqual([[\"/*\"]]);\n    });\n\n    describe(\"when CloudFront's invalidation quota is full\", () => {\n      beforeEach(() => {\n        jest.useFakeTimers();\n      });\n      afterEach(() => {\n        jest.useRealTimers();\n      });\n\n      const quotaError = () =>\n        Object.assign(\n          new Error(\"Your request contains too many invalidations\"),\n          {\n            name: \"TooManyInvalidationsInProgress\",\n          },\n        );\n\n      it(\"retries as one app-wide wildcard after a backoff\", async () => {\n        const cdnHandler = withDistribution(pages(\"test-tag\", 2));\n        mockCloudFrontSend\n          .mockRejectedValueOnce(quotaError())\n          .mockResolvedValueOnce({});\n\n        const done = cdnHandler.revalidateTag(\"test-tag\");\n        await jest.advanceTimersByTimeAsync(1000);\n        await done;\n\n        expect(invalidations()).toEqual([[\"/isr/0*\", \"/isr/1*\"], [\"/*\"]]);\n      });\n\n      it(\"gives up after the last retry\", async () => {\n        const cdnHandler = withDistribution(pages(\"test-tag\", 1));\n        mockCloudFrontSend.mockRejectedValue(quotaError());\n\n        const done = cdnHandler.revalidateTag(\"test-tag\");\n        await jest.advanceTimersByTimeAsync(3000);\n        await expect(done).resolves.toBeUndefined();\n\n        expect(invalidations()).toEqual([[\"/isr/0*\"], [\"/*\"], [\"/*\"]]);\n      });\n\n      it(\"does not retry any other error\", async () => {\n        const cdnHandler = withDistribution(pages(\"test-tag\", 1));\n        mockCloudFrontSend.mockRejectedValue(new Error(\"AccessDenied\"));\n\n        await cdnHandler.revalidateTag(\"test-tag\");\n\n        expect(invalidations()).toEqual([[\"/isr/0*\"]]);\n      });\n\n      it(\"retries the app's root under a basePath too\", async () => {\n        // `/base/*` matches neither `/base` nor `/base?_rsc=…`: retrying\n        // `revalidatePath(\"/\")` as that left the home page stale at the edge.\n        useBasePath();\n        const cdnHandler = withDistribution({ Items: [] });\n        mockCloudFrontSend\n          .mockRejectedValueOnce(quotaError())\n          .mockResolvedValueOnce({});\n\n        const done = cdnHandler.revalidateTag(\"_N_T_/\");\n        await jest.advanceTimersByTimeAsync(1000);\n        await done;\n\n        expect(invalidations()[1]).toEqual([\"/base\", \"/base?*\", \"/base/*\"]);\n      });\n    });\n\n    it(\"records a profile's revalidation as stale now, expiring later\", async () => {\n      const before = Date.now();\n      await handler.revalidateTag(\"posts\", { expire: 60 });\n\n      const [input] = (UpdateItemCommand as unknown as jest.Mock).mock.calls[0];\n      expect(input.Key.sk.S).toBe(\"posts\");\n      expect(input.UpdateExpression).toBe(\n        \"SET staleAt = :staleAt, expiredAt = :expiredAt\",\n      );\n      const staleAt = Number(input.ExpressionAttributeValues[\":staleAt\"].N);\n      expect(staleAt).toBeGreaterThanOrEqual(before);\n      expect(Number(input.ExpressionAttributeValues[\":expiredAt\"].N)).toBe(\n        staleAt + 60_000,\n      );\n    });\n  });\n\n  /**\n   * The cache handler's half of `res.revalidate()`'s CDN invalidation: the hook\n   * it registers for `invalidateRevalidatedPage` in `runtime/core.ts`. The\n   * runtime's half is in `core.test.ts`.\n   */\n  describe(\"the revalidated-page hook\", () => {\n    const HOOK = REVALIDATED_PAGE_HOOK;\n    const globals = globalThis as Record<symbol, unknown>;\n    type Hook = (routes: readonly string[]) => Promise<void>;\n\n    beforeEach(() => {\n      delete globals[HOOK];\n      mockSsmSend.mockResolvedValue({ Parameter: { Value: \"EDISTRIBUTION\" } });\n      mockCloudFrontSend.mockResolvedValue({});\n      (CreateInvalidationCommand as unknown as jest.Mock).mockClear();\n    });\n\n    function invalidatedPaths(): string[] {\n      const [input] = (CreateInvalidationCommand as unknown as jest.Mock).mock\n        .calls[0];\n      return input.InvalidationBatch.Paths.Items;\n    }\n\n    it(\"is registered only behind a distribution\", () => {\n      new S3CacheHandler({ context: mockContext });\n      expect(globals[HOOK]).toBeUndefined();\n\n      process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = \"param\";\n      new S3CacheHandler({ context: mockContext });\n      expect(typeof globals[HOOK]).toBe(\"function\");\n    });\n\n    it(\"invalidates the page and its data route under basePath\", async () => {\n      process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = \"param\";\n      new S3CacheHandler({ context: mockContext, basePath: \"base\" });\n      await (globals[HOOK] as Hook)([\n        \"/blog/hello\",\n        \"/_next/data/test-build-id/blog/hello.json\",\n      ]);\n      expect(invalidatedPaths()).toEqual([\n        \"/base/blog/hello*\",\n        \"/base/_next/data/test-build-id/blog/hello.json*\",\n      ]);\n    });\n\n    it(\"spells out the root rather than invalidating the whole app\", async () => {\n      process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = \"param\";\n      new S3CacheHandler({ context: mockContext });\n      await (globals[HOOK] as Hook)([\n        \"/\",\n        \"/_next/data/test-build-id/index.json\",\n      ]);\n      expect(invalidatedPaths()).toEqual([\n        \"/\",\n        \"/?*\",\n        \"/_next/data/test-build-id/index.json*\",\n      ]);\n    });\n\n    it(\"sends every path once, in one invalidation\", async () => {\n      process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME = \"param\";\n      new S3CacheHandler({ context: mockContext });\n      await (globals[HOOK] as Hook)([\n        \"/blog\",\n        \"/_next/data/test-build-id/en/blog.json\",\n        \"/en/blog\",\n        \"/blog\",\n      ]);\n      expect(CreateInvalidationCommand).toHaveBeenCalledTimes(1);\n      expect(invalidatedPaths()).toEqual([\n        \"/blog*\",\n        \"/_next/data/test-build-id/en/blog.json*\",\n        \"/en/blog*\",\n      ]);\n    });\n  });\n\n  describe(\"resetRequestCache\", () => {\n    it(\"should complete without errors\", async () => {\n      await expect(handler.resetRequestCache()).resolves.not.toThrow();\n    });\n  });\n});\n"]}