cdk-nextjs 0.6.2 → 0.7.1

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

@@ -9,200 +9,525 @@ exports.S3CacheHandler = void 0;
 */
 /* eslint-disable import/no-extraneous-dependencies */
 const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_module_1 = require("node:module");
 const node_path_1 = require("node:path");
 const client_cloudfront_1 = require("@aws-sdk/client-cloudfront");
 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 debug_1 = __importDefault(require("debug"));
+const aws_cache_store_1 = require("./aws-cache-store");
 const cache_utils_1 = require("./cache-utils");
+const use_cache_common_1 = require("./use-cache-common");
+const manifest_1 = require("../runtime/manifest");
+const base_path_1 = require("../utils/base-path");
+/**
+ * The tags a stored entry has to be tag-revalidated against.
+ *
+ * A runtime `set` records `tags` alongside the entry, but a build-time prerender
+ * does not: those entries are written as files by the adapter's
+ * `onBuildComplete` rather than through `set`, and carry their tags only in the
+ * render's `x-next-cache-tags` header — the same place Next.js's own
+ * `IncrementalCache.get` reads them from when it decides staleness. Without this
+ * fallback no prerendered page is reachable by `revalidateTag`/`revalidatePath`
+ * until some later runtime re-render happens to replace the seeded entry, so an
+ * app whose pages are all static never revalidates at all. Measured against
+ * next.js's `test/e2e/app-dir/resume-data-cache`.
+ */
+function entryTags(stored) {
+    return stored.tags?.length ? stored.tags : (0, cache_utils_1.headerTags)(stored.value);
+}
+/**
+ * The `lastModified` that tells Next.js "this entry is expired, re-render it
+ * 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` instead is not the same thing:
+ * a miss on a PPR route whose `prerender-manifest.json` entry carries a
+ * `fallback` (`compute: "resuming"`) is answered from the route's fallback
+ * shell, which is served `cache-control: private, no-store` with no
+ * `x-nextjs-cache` header, and - unless `partialPrefetching` is on - is never
+ * upgraded into a concrete entry. So the first `revalidateTag` to reach a
+ * seeded prerender left that page uncacheable, and dynamically resumed per
+ * request, for the rest of the deployment's life. The isr e2e sees it as an
+ * absent `x-nextjs-cache`.
+ */
+const EXPIRED_LAST_MODIFIED = -1;
+/**
+ * Whether a `get` is for the `fetch` cache rather than for a route's response,
+ * as a narrowing predicate so that `ctx.tags` and `ctx.softTags` — which only
+ * {@link GetIncrementalFetchCacheContext} has — are reachable without a cast.
+ *
+ * `IncrementalCacheKind.FETCH`, compared as its own string value so this file
+ * keeps importing no Next.js internals (the enum is `const`, so it has no
+ * runtime representation to import anyway).
+ */
+function isFetchCacheGet(ctx) {
+    return ctx.kind === "FETCH";
+}
+/** `NEXT_CACHE_IMPLICIT_TAG_ID`, inlined so this file imports no Next.js internals. */
+const NEXT_CACHE_IMPLICIT_TAG_ID = "_N_T_";
+/**
+ * The `type` argument of `revalidatePath`, which Next.js appends to the implicit
+ * tag as a path segment. @see implicitTagPaths
+ */
+const REVALIDATE_PATH_TYPES = ["layout", "page"];
+/**
+ * The request paths a `revalidatePath` tag could name, or empty for an app tag.
+ *
+ * `revalidatePath("/blog")` reaches the cache handler as the implicit tag
+ * `_N_T_/blog` - the path is right there in the tag, which is what makes the CDN
+ * copy of a build-time prerender reachable at all. A `revalidateTag("posts")`
+ * carries no path and depends on the mapping rows instead.
+ *
+ * Two paths come back when the tag ends in a `revalidatePath` *type*, because
+ * `revalidatePath(path, type)` appends it to the tag
+ * (`next/dist/server/web/spec-extension/revalidate.js`):
+ * `revalidatePath("/blog", "layout")` is `_N_T_/blog/layout`, and
+ * `revalidatePath("/", "layout")` is `_N_T_/layout`. Reading either of those as a
+ * request path invalidates a URI that does not exist and never touches the one
+ * that does. The suffix cannot be told apart from a route that genuinely ends in
+ * `/layout`, so both readings are emitted: an invalidation path matching nothing
+ * costs a path, while missing the real one leaves the edge stale for the whole
+ * `s-maxage`.
+ */
+function implicitTagPaths(tag) {
+    if (!tag.startsWith(`${NEXT_CACHE_IMPLICIT_TAG_ID}/`)) {
+        return [];
+    }
+    const path = tag.slice(NEXT_CACHE_IMPLICIT_TAG_ID.length);
+    const candidates = [path];
+    for (const type of REVALIDATE_PATH_TYPES) {
+        if (path.endsWith(`/${type}`)) {
+            // `_N_T_/layout` is the root, not the empty path.
+            candidates.push(path.slice(0, -(type.length + 1)) || "/");
+        }
+    }
+    // A dynamic route template ("/blog/[slug]") matches no cached URI. Harmless to
+    // send, but it costs an invalidation path, and those are metered.
+    return Array.from(new Set(candidates)).filter((p) => !p.includes("["));
+}
+/**
+ * Invalidation paths covering every URI CloudFront could be holding the response
+ * for `route` under, once `basePath` is prefixed.
+ *
+ * An invalidation path matches only the query string it spells out, and a page's
+ * RSC payload is cached under `?_rsc=<hash>`; dropping the HTML while leaving the
+ * payload behind leaves the router navigating to the pre-revalidation page. A
+ * `trailingSlash` app caches the redirect target rather than the route, so the
+ * slash variant has to go too.
+ *
+ * One trailing wildcard covers all four (`/blog`, `/blog?…`, `/blog/`,
+ * `/blog/?…`) for a single wildcard path, where spelling them out cost two -
+ * and wildcards are the quota that runs out. It also matches `/blogroll` and
+ * everything under `/blog/`, which is a lower hit rate on those, never a stale
+ * page. The app's root is the exception: `/*` there is the whole app.
+ *
+ * `basePath` is prefixed here because neither source of a route carries it.
+ * Cache keys are routes — Next.js strips `basePath` before routing, so the cache
+ * handler never sees one — and `revalidatePath("/blog")` names the route as
+ * well. CloudFront only ever saw `/base/blog`, so invalidating `/blog` clears
+ * nothing and the edge keeps serving the pre-revalidation page until `s-maxage`
+ * expires. The app's root under a `basePath` is `/base`, not `/base/`.
+ */
+function cdnInvalidationPaths(route, basePath) {
+    const trimmed = route.replace(/\/+$/, "");
+    if (trimmed === "") {
+        return basePath
+            ? [basePath, `${basePath}?*`, `${basePath}/`, `${basePath}/?*`]
+            : ["/", "/?*"];
+    }
+    return [`${basePath}${encodeInvalidationRoute(trimmed)}*`];
+}
+/**
+ * The app's `basePath`, from the `required-server-files.json` every deployment
+ * root stages next to `serverDistDir`: Next.js hands the cache handler no
+ * other copy.
+ */
+function appBasePath(serverDistDir) {
+    if (!serverDistDir) {
+        return undefined;
+    }
+    try {
+        const file = (0, node_path_1.join)(serverDistDir, "..", "required-server-files.json");
+        return JSON.parse((0, node_fs_1.readFileSync)(file, "utf8")).config?.basePath;
+    }
+    catch (error) {
+        console.warn("Could not read basePath for CDN invalidation:", error);
+        return undefined;
+    }
+}
+/**
+ * `route` as the URI a browser requests it under, which is what CloudFront
+ * caches it by.
+ *
+ * Next.js builds cache keys from the *decoded* pathname (`decodePathParams` in
+ * `route-module.js`), so `/blog/héllo` or `/blog/hello world` reach here raw,
+ * while CloudFront holds `/blog/h%C3%A9llo`, and an invalidation path matches
+ * the encoded form only - AWS requires non-ASCII and unsafe characters to be
+ * percent-encoded, and nothing else. Each segment is encoded the way
+ * `encodeURI` does, which leaves the characters a browser sends raw in a path
+ * (`@`, `:`, `,`, `;`, ...) alone. A `%` that already starts an escape is kept:
+ * `decodePathParams` re-escapes path delimiters (`%2F`, `%3F`, `%23`, `%5C`),
+ * and a `revalidatePath` tag may name the encoded path itself. `?` and `#` can
+ * only be in a decoded segment as data, so they are encoded too.
+ */
+function encodeInvalidationRoute(route) {
+    return route
+        .split("/")
+        .map((segment) => segment
+        .split(/(%[0-9A-Fa-f]{2})/)
+        .map((part, i) => i % 2 === 1
+        ? part
+        : encodeURI(part).replace(/[?#]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`))
+        .join(""))
+        .join("/");
+}
+/**
+ * Whether a cache key is a fetch-cache entry rather than a page route.
+ *
+ * Those keys are the hash Next.js derives from the request — a single segment of
+ * lowercase hex, long enough that no route pathname takes the same shape. They
+ * are mapped to tags exactly like pages are, but name no URI CloudFront could be
+ * holding, so an invalidation path built from one is always wasted.
+ */
+function isFetchCacheKey(key) {
+    return /^[0-9a-f]{32,}$/.test(key);
+}
+/** Whether CloudFront counts this path against the wildcard quota. */
+function isWildcardPath(path) {
+    return path.includes("*");
+}
+/**
+ * The most wildcard paths one `revalidateTag` sends before collapsing to a single
+ * app-wide wildcard, and the most paths of any kind.
+ *
+ * CloudFront's wildcard quota is per *distribution*, not per request: the
+ * invalidations it has in progress share it, so splitting an oversized set into
+ * back-to-back requests is what gets the later ones rejected
+ * (`TooManyInvalidationsInProgress`, or a throttle under the newer rate-based
+ * quotas) - and a rejected request is a page that stays stale at the edge. So
+ * everything goes out as one request, and a set that would not fit in one is
+ * answered with the whole app (`/*`, see `wholeAppInvalidationPaths`) instead:
+ * a worse hit rate, and a strictly correct answer.
+ * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-invalidations
+ */
+const MAX_WILDCARD_PATHS_PER_INVALIDATION = 15;
+const MAX_PATHS_PER_INVALIDATION = 3000;
+/**
+ * Retries of an invalidation CloudFront rejected for its in-progress quota, and
+ * the delay before the first; each later one waits twice as long.
+ *
+ * Sizing a request against the quota cannot see the invalidations other
+ * instances already have in flight, so two `revalidateTag`s close together can
+ * each fit on their own and still be rejected together. Dropping the rejected
+ * one left its pages stale at the edge for the whole `s-maxage`. The retry asks
+ * for the whole app instead, which is one wildcard - the least of the quota any
+ * request can take - at the cost of a colder edge.
+ */
+const INVALIDATION_RETRIES = 2;
+const INVALIDATION_RETRY_DELAY_MS = 1000;
+/** The errors that mean "the quota is full right now", not "this is wrong". */
+function isInvalidationQuotaError(error) {
+    const name = error?.name;
+    return name === "TooManyInvalidationsInProgress" || name === "Throttling";
+}
+/**
+ * The most cache keys to remember as served stale while awaiting their
+ * regeneration. A background render that fails never calls `set`, so without a
+ * bound its key would stay behind for the life of the instance.
+ * @see S3CacheHandler.softRevalidatedKeys
+ */
+const MAX_SOFT_REVALIDATED_KEYS = 1000;
+/**
+ * How many 1 MB Query pages of one tag's mapping rows to walk. A ceiling rather
+ * than a real limit: it bounds a runaway tag instead of paginating a whole table
+ * on a request path. A tag cut off here invalidates the whole app, because the
+ * rows it never read are pages whose edge copy would otherwise stay stale.
+ */
+const MAX_TAG_QUERY_PAGES = 20;
+/**
+ * Next.js's in-process tag manifest, which `IncrementalCache.get` consults to
+ * decide whether an entry is stale - or `undefined` when it cannot be found
+ * unambiguously.
+ *
+ * `revalidateTag(tag, profile)` asks for stale-while-revalidate: the entry is
+ * served once more while a background render replaces it. A cache handler has
+ * no field to say "stale" in - `lastModified: -1` means expired, which blocks -
+ * so this sets the tag's `stale` timestamp where Next.js already looks for it,
+ * which is exactly what its own `FileSystemCache.revalidateTag` does. The module
+ * is read from the loaded-module cache rather than `require`d: the handler is
+ * bundled apart from the app, and resolving `next` from here could reach a
+ * different copy than the server loaded, whose manifest nothing reads. A stale
+ * mark written there would serve the entry as fresh, so without exactly one
+ * loaded copy the caller falls back to expiring the entry outright.
+ */
+const TAGS_MANIFEST_MODULE = "/next/dist/server/lib/incremental-cache/tags-manifest.external.js";
+function nextTagsManifest() {
+    const cache = (0, node_module_1.createRequire)((0, node_path_1.join)(process.cwd(), "index.js")).cache;
+    const loaded = Object.keys(cache).filter((path) => path.replace(/\\/g, "/").endsWith(TAGS_MANIFEST_MODULE));
+    if (loaded.length !== 1) {
+        return undefined;
+    }
+    const manifest = cache[loaded[0]]?.exports?.tagsManifest;
+    return manifest instanceof Map ? manifest : undefined;
+}
 class S3CacheHandler {
     s3Client;
     dynamoClient;
     cloudFrontClient;
     ssmClient;
-    s3Config;
-    dynamoConfig;
+    bucket;
+    tags;
+    config;
     cloudFrontConfig;
     debug = (0, debug_1.default)("cdk-nextjs:cache-handler:s3");
     // Cached for the lifetime of this instance (i.e. the compute instance) once
     // resolved, since a deployment's distribution ID never changes at runtime.
     cachedDistributionId = null;
+    /**
+     * Cache keys this instance served stale because of a soft `revalidateTag`,
+     * whose regenerated entry `set` has yet to write.
+     *
+     * `revalidateTag(tag, profile)` invalidates CloudFront at once, but the next
+     * request is answered from the stale entry - stale-while-revalidate - and that
+     * response carries the entry's original `s-maxage`, so the edge caches the
+     * stale body again. The background render that replaces it runs in this same
+     * process, so `set` checks this set and invalidates the key's paths a second
+     * time once the fresh entry is in S3. Without that, the edge kept serving the
+     * pre-revalidation page for the whole `s-maxage`.
+     *
+     * Expiring soft-revalidated entries outright instead would also keep the edge
+     * right, but it turns every `revalidateTag(tag, "max")` into a blocking render
+     * at the origin, which is the thing a profile asks not to happen.
+     */
+    softRevalidatedKeys = new Set();
+    /** @see buildTagManifest */
+    buildTags;
     constructor(options) {
-        const buildId = process.env.CDK_NEXTJS_BUILD_ID || "";
-        // Initialize S3 configuration from environment variables and options
-        this.s3Config = {
-            bucketName: options.s3Config?.bucketName ||
-                process.env.CDK_NEXTJS_CACHE_BUCKET_NAME ||
-                "",
-            region: options.s3Config?.region || process.env.AWS_REGION || "us-east-1",
-            buildId: options.s3Config?.buildId || buildId,
-        };
-        // Initialize DynamoDB configuration from environment variables and options
-        this.dynamoConfig = {
-            tableName: options.dynamoConfig?.tableName ||
-                process.env.CDK_NEXTJS_REVALIDATION_TABLE_NAME ||
-                "",
-            region: options.dynamoConfig?.region || process.env.AWS_REGION || "us-east-1",
-            buildId: options.dynamoConfig?.buildId || buildId,
-        };
-        // Initialize CloudFront configuration from environment variables and options.
+        this.config = (0, aws_cache_store_1.resolveAwsCacheConfig)();
         // Only set for CloudFront-fronted deployments (NextjsGlobalFunctions/Containers).
         // When unset, on-demand revalidation skips CDN invalidation and relies on the
         // distribution's cache policy TTL (driven by the origin's Cache-Control header)
         // to eventually pick up fresh content.
         this.cloudFrontConfig = {
-            distributionIdParameterName: options.cloudFrontConfig?.distributionIdParameterName ||
-                process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME ||
-                "",
-            region: options.cloudFrontConfig?.region ||
-                process.env.AWS_REGION ||
-                "us-east-1",
+            distributionId: process.env.CDK_NEXTJS_DISTRIBUTION_ID || "",
+            distributionIdParameterName: process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME || "",
+            basePath: (0, base_path_1.basePathPrefix)(options.basePath),
         };
+        // Only invalidation needs it, so only a handler behind a distribution reads
+        // it, and a missing file there is worth a warning.
+        if (this.invalidatesCdn && options.basePath === undefined) {
+            this.cloudFrontConfig.basePath = (0, base_path_1.basePathPrefix)(appBasePath(options.context.serverDistDir));
+        }
         // Initialize AWS clients
-        this.s3Client = new client_s3_1.S3Client({ region: this.s3Config.region });
-        this.dynamoClient = new client_dynamodb_1.DynamoDBClient({
-            region: this.dynamoConfig.region,
-        });
-        this.cloudFrontClient = new client_cloudfront_1.CloudFrontClient({
-            region: this.cloudFrontConfig.region,
-        });
-        this.ssmClient = new client_ssm_1.SSMClient({ region: this.cloudFrontConfig.region });
-        if (!this.s3Config.bucketName) {
+        const { region } = this.config;
+        this.s3Client = new client_s3_1.S3Client({ region });
+        this.dynamoClient = new client_dynamodb_1.DynamoDBClient({ region });
+        this.cloudFrontClient = new client_cloudfront_1.CloudFrontClient({ region });
+        this.ssmClient = new client_ssm_1.SSMClient({ region });
+        this.bucket = new aws_cache_store_1.CacheBucket(this.s3Client, this.config.bucketName);
+        // The process's one copy of the tag markers, shared with the `'use cache'`
+        // handlers: one `revalidateTag` writes each tag's rows once, and one log
+        // `Query` per interval serves every handler.
+        this.tags = (0, use_cache_common_1.sharedTagManifest)();
+        // `res.revalidate()` regenerates a page without going through
+        // `revalidateTag`, so the runtime asks for the CDN copies itself, through
+        // this hook (`invalidateRevalidatedPage` in `src/runtime/core.ts`). A global
+        // because the runtime and this handler are separate bundles in one process.
+        // Every instance registers the same thing, so the latest one winning is fine.
+        if (this.invalidatesCdn) {
+            globalThis[manifest_1.REVALIDATED_PAGE_HOOK] = (routes) => {
+                const { basePath } = this.cloudFrontConfig;
+                return this.invalidateCloudFrontPaths(routes.flatMap((route) => cdnInvalidationPaths(route, basePath)));
+            };
+        }
+        if (!this.config.bucketName) {
             console.warn("CDK_NEXTJS_CACHE_BUCKET_NAME environment variable not set, S3 cache disabled");
         }
-        if (!this.dynamoConfig.tableName) {
+        if (!this.config.tableName) {
             console.warn("CDK_NEXTJS_REVALIDATION_TABLE_NAME environment variable not set, revalidation tracking disabled");
         }
-        if (!buildId) {
+        if (!process.env.CDK_NEXTJS_BUILD_ID) {
             console.warn("CDK_NEXTJS_BUILD_ID environment variable not set, cache isolation may not work correctly");
         }
-        // Log the options for debugging (optional usage to avoid unused parameter warning)
-        if (options.context.dev) {
-            this.debug("S3DynamoCacheHandler initialized in development mode");
-        }
     }
     async get(cacheKey, ctx) {
         try {
-            // Log context for debugging (optional usage to avoid unused parameter warning)
-            if (ctx.kind) {
-                this.debug(`S3 cache get operation for ${cacheKey} with kind: ${ctx.kind}`);
-            }
-            if (!this.s3Config.bucketName) {
+            if (!this.config.bucketName) {
                 return null;
             }
             const s3Key = this.buildS3Key(cacheKey);
-            const command = new client_s3_1.GetObjectCommand({
-                Bucket: this.s3Config.bucketName,
-                Key: s3Key,
-            });
-            const response = await this.s3Client.send(command);
-            if (!response.Body) {
+            const response = await this.bucket.get(s3Key);
+            if (!response) {
+                this.debug(`S3 CACHE MISS: ${cacheKey}`);
                 return null;
             }
-            // Handle different content types appropriately for documented formats
-            let cacheValue;
-            const contentType = response.ContentType || "application/json";
-            // Handle text-based data (JSON, HTML, plain text) - all documented formats are text-based
-            const bodyString = await response.Body.transformToString("utf-8");
-            if (contentType.includes("application/json")) {
-                // Parse the stored CacheHandlerValue directly
-                const parsedValue = (0, cache_utils_1.parseCacheValue)(bodyString);
-                // Extract the actual CacheHandlerValue (without tags) for return
-                cacheValue = {
-                    lastModified: parsedValue.lastModified,
-                    value: parsedValue.value,
-                };
-                // Check if cache has been invalidated by tag revalidation
-                const storedTags = parsedValue.tags || [];
-                if (storedTags.length > 0 && this.dynamoConfig.tableName) {
-                    const isInvalidated = await this.checkIfRevalidated(cacheValue.lastModified, storedTags);
-                    if (isInvalidated) {
-                        this.debug(`S3 CACHE INVALIDATED BY TAG: ${cacheKey}`);
-                        // Delete the stale S3 entry
-                        await this.deleteS3Entry(s3Key);
-                        return null;
-                    }
-                }
-            }
-            else {
-                console.log(`Invalid content type: ${contentType}`);
-                // This shouldn't happen since we always store as JSON now
-                return null;
+            // Every object is JSON (`putJson`, and the seeded `.json` files); one
+            // that does not parse is a miss, through the `catch` below.
+            const parsedValue = (0, cache_utils_1.parseCacheValue)(response);
+            if (await this.isRevalidated(parsedValue, ctx, cacheKey)) {
+                this.debug(`S3 CACHE INVALIDATED BY TAG: ${cacheKey}`);
+                // A revalidated `fetch` entry has to read as a miss so the request
+                // refetches instead of reusing the body - the same thing Next.js's
+                // own `FileSystemCache` does with `revalidatedTags`. Only a
+                // *response* entry gets handed back expired, because for those a
+                // miss is worse than stale: see `EXPIRED_LAST_MODIFIED`.
+                //
+                // Neither is deleted. The refetch or re-render this provokes
+                // overwrites the object through `set`, with a `lastModified` past the
+                // tag's marker; deleting it here as well raced that write, and a
+                // concurrent request's fresh entry could be the one removed. Keeping
+                // a response entry also means a render that fails is answered from
+                // the last good copy rather than from a shell.
+                return isFetchCacheGet(ctx)
+                    ? null
+                    : { lastModified: EXPIRED_LAST_MODIFIED, value: parsedValue.value };
             }
             this.debug(`S3 CACHE HIT: ${cacheKey} (${s3Key})`);
-            return cacheValue;
+            // Without the stored tags.
+            return {
+                lastModified: parsedValue.lastModified,
+                value: parsedValue.value,
+            };
         }
         catch (error) {
-            if (error instanceof client_s3_1.NoSuchKey) {
-                this.debug(`S3 CACHE MISS: ${cacheKey}`);
-                return null;
-            }
-            // Log actual errors (not cache misses)
+            // Log actual errors (a cache miss is not one: see `CacheBucket.get`)
             console.error(`Error retrieving cache from S3:`, error);
             return null;
         }
     }
+    /**
+     * Whether a tag revalidation has expired `entry`, for a `get` with `ctx`.
+     *
+     * Public because the in-memory layer in front of this handler has to ask too:
+     * a memory hit never reaches {@link get}, and without this check an instance
+     * other than the one that ran `revalidateTag` kept answering from memory for
+     * the whole memory TTL - long enough for CloudFront to cache the stale page
+     * again after the invalidation.
+     *
+     * Which tags to check depends on the kind, and Next.js's own
+     * `FileSystemCache.get` splits the same two ways: a response entry is checked
+     * against the tags *it* was stored with, but a `fetch` entry is checked
+     * against `[...ctx.tags, ...ctx.softTags]` — the tags of the request asking
+     * for it. That distinction is load-bearing, because a `fetch` entry is only
+     * ever stored with its *explicit* `cache: { tags }` and never with the
+     * implicit `_N_T_/<path>` chain, which arrives only as `ctx.softTags`.
+     * Reading the stored tags for a `fetch` too meant an untagged `force-cache`
+     * fetch had `[]`, skipped the check entirely, and no `revalidatePath` could
+     * ever evict it: a `force-dynamic` page whose data comes from such a fetch
+     * re-rendered on every request and still served the same body forever.
+     * Measured against next.js's `test/e2e/app-dir/revalidate-path-with-rewrites`.
+     *
+     * `cacheKey` is the key the entry was read under. A response entry found
+     * stale is remembered by it, for `set` to invalidate CloudFront again once
+     * its regeneration lands: see {@link softRevalidatedKeys}.
+     */
+    async isRevalidated(entry, ctx, cacheKey) {
+        if (!this.config.tableName) {
+            return false;
+        }
+        const checkTags = isFetchCacheGet(ctx)
+            ? [...(ctx.tags ?? []), ...(ctx.softTags ?? [])]
+            : entryTags(entry);
+        if (checkTags.length === 0) {
+            return false;
+        }
+        const state = await this.checkIfRevalidated(entry.lastModified ?? 0, checkTags);
+        if (state === "stale" && !isFetchCacheGet(ctx)) {
+            this.noteSoftRevalidated(cacheKey);
+        }
+        return state === "expired";
+    }
+    /**
+     * Remember that `cacheKey` was served stale, when there is a distribution
+     * whose copy of it will need invalidating again. See
+     * {@link softRevalidatedKeys}.
+     */
+    noteSoftRevalidated(cacheKey) {
+        if (!this.invalidatesCdn) {
+            return;
+        }
+        this.softRevalidatedKeys.delete(cacheKey);
+        if (this.softRevalidatedKeys.size >= MAX_SOFT_REVALIDATED_KEYS) {
+            // Insertion order: the first key is the one waiting longest.
+            const oldest = this.softRevalidatedKeys.values().next().value;
+            if (oldest !== undefined) {
+                this.softRevalidatedKeys.delete(oldest);
+            }
+        }
+        this.softRevalidatedKeys.add(cacheKey);
+    }
     async set(cacheKey, data, ctx) {
         try {
             if (!data) {
                 // Delete from S3 and DynamoDB
                 this.debug(`S3 CACHE DELETE: ${cacheKey}`);
-                if (!this.s3Config.bucketName) {
+                if (!this.config.bucketName) {
                     return;
                 }
+                // The entry is gone, so there is no regeneration left to wait for.
+                this.softRevalidatedKeys.delete(cacheKey);
                 // Build S3 key without needing to know the kind
                 const s3Key = this.buildS3Key(cacheKey);
-                try {
-                    const deleteCommand = new client_s3_1.DeleteObjectCommand({
-                        Bucket: this.s3Config.bucketName,
-                        Key: s3Key,
-                    });
-                    await this.s3Client.send(deleteCommand);
-                    this.debug(`S3 CACHE DELETED: ${s3Key}`);
-                }
-                catch (error) {
-                    if (error instanceof client_s3_1.NoSuchKey) {
-                        this.debug(`Failed to delete S3 key ${s3Key}:`, error);
-                    }
-                }
-                // TODO: Also delete tag associations from DynamoDB if needed
+                // Read the entry's tags before the object is gone: they are the only
+                // way to name its mapping rows, whose sort key is `tag#s3Key` and so
+                // cannot be queried from the key side. See `storedEntryTags`.
+                const tags = await this.storedEntryTags(s3Key, ctx);
+                await this.s3Client.send(new client_s3_1.DeleteObjectCommand({
+                    Bucket: this.config.bucketName,
+                    Key: s3Key,
+                }));
+                this.debug(`S3 CACHE DELETED: ${s3Key}`);
+                await this.deleteDynamoDBTagMappings(s3Key, tags);
                 return;
             }
-            // Debug logging to understand what data is being cached
-            const tags = (0, cache_utils_1.getTags)(ctx);
-            this.debug(`S3 CACHE SET: Key: ${cacheKey}, tags: ${tags || "none"}`);
-            // Note: ctx.tags are available but revalidation is handled separately in revalidateTag method
-            // Log tags for debugging if present (only in SetIncrementalFetchCacheContext)
-            if (tags && tags.length > 0) {
-                this.debug(`S3 cache entry for ${cacheKey} has tags:`, tags);
-            }
-            if (!this.s3Config.bucketName) {
+            // `entryTags`, not `getTags(ctx)` alone: for a page or route response
+            // `ctx` carries only `{ cacheControl, isRoutePPREnabled, isFallback }` —
+            // `ResponseCache.set` builds it that way and `IncrementalCache.set`
+            // forwards it unchanged — so the tags live in the render's
+            // `x-next-cache-tags` header and nowhere else. Reading only `ctx` meant no
+            // runtime-rendered page ever got a mapping row, and a page that is not in
+            // the build's tag manifest names none either: a later
+            // `revalidateTag` found nothing to invalidate and CloudFront kept serving
+            // the stale HTML and RSC payload for the whole `s-maxage`. Same source the
+            // read path above already falls back to.
+            const tags = entryTags({ tags: (0, cache_utils_1.getTags)(ctx), value: data });
+            this.debug(`S3 CACHE SET: Key: ${cacheKey}, tags: ${tags.length ? tags : "none"}`);
+            if (!this.config.bucketName) {
                 return;
             }
             const s3Key = this.buildS3Key(cacheKey);
             // Create CacheHandlerValue structure for S3 storage with tags
             const cacheHandlerValue = {
-                lastModified: Date.now(),
+                // On the marker clock, since that is what it is compared with.
+                lastModified: (0, aws_cache_store_1.markerClock)(),
                 value: data,
             };
             // Store tags with the cache entry for revalidation checking
             const cacheEntryWithTags = {
                 ...cacheHandlerValue,
-                tags: tags || [],
+                tags,
             };
             // Serialize with custom handling for Map and Buffer objects
             const body = (0, cache_utils_1.serializeCacheValue)(cacheEntryWithTags);
-            const command = new client_s3_1.PutObjectCommand({
-                Bucket: this.s3Config.bucketName,
-                Key: s3Key,
-                Body: body,
-                ContentType: "application/json; charset=utf-8", // Always JSON since we store CacheHandlerValue
-            });
-            await this.s3Client.send(command);
+            // Always JSON since we store CacheHandlerValue
+            await this.bucket.putJson(s3Key, body);
             this.debug(`S3 CACHE STORED: ${cacheKey} (${data.kind})`);
+            // The regeneration of an entry served stale: CloudFront may have cached
+            // that stale response after `revalidateTag`'s invalidation, so the key's
+            // paths go once more now that S3 holds the fresh one.
+            if (this.softRevalidatedKeys.delete(cacheKey)) {
+                const route = this.s3KeyToInvalidationPath(s3Key);
+                if (route !== undefined) {
+                    this.debug(`SOFT REVALIDATION REGENERATED: ${cacheKey}`);
+                    await this.invalidateCloudFrontPaths(cdnInvalidationPaths(route, this.cloudFrontConfig.basePath));
+                }
+            }
             // Store tag-to-cache-key mappings in DynamoDB for revalidation
-            if (tags && tags.length > 0 && this.dynamoConfig.tableName) {
+            if (tags.length > 0 && this.mapsTagsToPaths) {
                 this.debug(`STORING TAGS: ${cacheKey} -> [${tags.join(", ")}]`);
                 await this.storeDynamoDBTagMappings(s3Key, tags);
             }
@@ -211,140 +536,253 @@ class S3CacheHandler {
             console.error("Error storing cache to S3:", error);
         }
     }
-    async revalidateTag(tag) {
+    async revalidateTag(tag, durations) {
         const tags = Array.isArray(tag) ? tag : [tag];
         this.debug(`REVALIDATING TAGS: [${tags.join(", ")}]`);
-        try {
-            if (!this.dynamoConfig.tableName) {
-                return;
+        if (!this.config.tableName) {
+            return;
+        }
+        // Record the revalidation against each tag itself, not only against the
+        // cache keys already mapped to it: `checkIfRevalidated` reads these marker
+        // rows, and a build-time prerender has no mapping rows at all.
+        const recorded = await this.tags.update(tags, durations);
+        if (!this.mapsTagsToPaths) {
+            return;
+        }
+        const { basePath } = this.cloudFrontConfig;
+        if (!recorded) {
+            // Other instances may never learn of this revalidation, so no path list
+            // is enough: drop the whole app from CloudFront rather than serve stale
+            // pages until their TTL.
+            await this.invalidateCloudFrontPaths((0, base_path_1.wholeAppInvalidationPaths)(basePath));
+            return;
+        }
+        // Settled rather than `all`: one tag's throttled Query must not drop the
+        // CloudFront paths every other tag resolved.
+        const results = await Promise.allSettled(tags.map((t) => this.tagRoutes(t)));
+        const routes = [];
+        let wholeApp = false;
+        for (const result of results) {
+            if (result.status === "rejected") {
+                console.error("Error reading tag mappings:", result.reason);
+                // The tag's entries are revalidated at the origin while nothing names
+                // their CloudFront paths. The same answer as a tag cut short by
+                // `MAX_TAG_QUERY_PAGES`: the whole app, never a stale page.
+                wholeApp = true;
+                continue;
             }
-            // Process all tags in parallel for better performance
-            await Promise.all(tags.map((t) => this.revalidateSingleTag(t)));
+            routes.push(...result.value.routes);
+            wholeApp ||= result.value.truncated;
         }
-        catch (error) {
-            console.error("Error updating revalidation metadata:", error);
+        // Invalidate the CDN edge cache so CloudFront-fronted deployments don't
+        // keep serving stale responses until the cache policy's TTL naturally
+        // expires. One request for every tag at once: see
+        // `MAX_WILDCARD_PATHS_PER_INVALIDATION` for why never several.
+        await this.invalidateCloudFrontPaths(wholeApp
+            ? (0, base_path_1.wholeAppInvalidationPaths)(basePath)
+            : routes.flatMap((route) => cdnInvalidationPaths(route, basePath)));
+    }
+    /**
+     * The routes CloudFront could be holding a response for `tag` under -
+     * `truncated` when they could not all be named: more mapping rows than
+     * {@link MAX_TAG_QUERY_PAGES}, or no build tag manifest to read.
+     */
+    async tagRoutes(tag) {
+        const [{ items, truncated }, buildTags] = await Promise.all([
+            this.queryTagMappings(tag),
+            this.buildTagManifest(),
+        ]);
+        // Extract S3 keys from sort keys (format: "tag#s3Key"). Split at the tag's
+        // own length rather than at the first "#": a tag is app-defined and may
+        // contain one, and `revalidateTag("user#42")` then yielded
+        // "42#<buildId>/account.json" — whose invalidation path
+        // ("/42#<buildId>/account") names nothing CloudFront cached, so the edge
+        // kept serving the stale page.
+        //
+        // The same `#` makes `begins_with(sk, "user#")` match rows that are not
+        // `user`'s at all: the marker row of tag `user#42` (sk `user#42`) and every
+        // mapping row of it (`user#42#<buildId>/…`). What is left after the prefix
+        // is an S3 key only if it starts with the build's own prefix, which is how
+        // `buildS3Key` writes every one.
+        const prefixLength = tag.length + 1;
+        const keyPrefix = this.config.buildId ? `${this.config.buildId}/` : "";
+        const s3Keys = items
+            .map((item) => item.sk?.S?.slice(prefixLength))
+            .filter((s3Key) => Boolean(s3Key && s3Key.startsWith(keyPrefix)));
+        // The build-time prerenders carrying the tag, which no `set` wrote a row
+        // for.
+        for (const cacheKey of buildTags?.get(tag) ?? []) {
+            s3Keys.push(this.buildS3Key(cacheKey));
         }
+        this.debug(`TAG ${tag}: Found ${s3Keys.length} cache entries to invalidate`);
+        // The mapping rows themselves are deliberately left alone. Stamping
+        // `revalidatedAt` on each `tag#cacheKey` row is what this used to do, and
+        // nothing has read that attribute since `checkIfRevalidated` began reading
+        // the bare-tag marker row written above — so the writes were dead, and they
+        // were dead *in front of* the invalidation. One throttled `UpdateItem`
+        // rejected the batch, the CloudFront invalidation never ran, and the only
+        // trace was a `console.error` while the edge kept serving the stale page.
+        //
+        // Deliberately not deleting the tag's S3 objects either. The marker row
+        // above is what invalidates them: `get` compares it against each entry's
+        // own `lastModified` and hands the entry back expired, which is the signal
+        // that makes Next.js re-render *this* route and store the result (see
+        // `EXPIRED_LAST_MODIFIED`). Deleting the object instead turned the next
+        // request into a hard miss, and a hard miss on a PPR route is answered from
+        // the route's fallback shell — uncacheable, and never upgraded back into a
+        // concrete entry, so one `revalidateTag` left the page resuming
+        // dynamically for good.
+        const routes = s3Keys
+            .map((s3Key) => this.s3KeyToInvalidationPath(s3Key))
+            .filter((route) => route !== undefined);
+        // A `revalidatePath` names its path in the tag itself, which is the only
+        // way to reach a build-time prerender's CDN copy when it has no mapping
+        // row.
+        routes.push(...implicitTagPaths(tag));
+        return { routes, truncated: truncated || !buildTags };
     }
-    async revalidateSingleTag(tag) {
-        // Query all paths associated with this tag
-        const queryCommand = new client_dynamodb_1.QueryCommand({
-            TableName: this.dynamoConfig.tableName,
-            KeyConditionExpression: "pk = :pk AND begins_with(sk, :skPrefix)",
-            ExpressionAttributeValues: {
-                ":pk": { S: this.dynamoConfig.buildId },
-                ":skPrefix": { S: `${tag}#` },
-            },
+    /**
+     * The build-time prerenders' cache keys by tag ({@link INIT_CACHE_TAG_MANIFEST}),
+     * read from the cache bucket once per instance, or `undefined` when that
+     * failed, to be read again next time. A prerender is written by the adapter,
+     * never through `set`, so this is the only record of which tags name its
+     * CloudFront paths, and it is served with a year-long `s-maxage`.
+     */
+    buildTagManifest() {
+        this.buildTags ??= this.bucket
+            .get(`${this.config.buildId}/${cache_utils_1.INIT_CACHE_TAG_MANIFEST}`)
+            // None is normal: only tagged prerenders write one.
+            .then((object) => new Map(Object.entries(JSON.parse(object ?? "{}"))));
+        return this.buildTags.catch((error) => {
+            this.buildTags = undefined;
+            console.warn("Could not read the build's tag manifest:", error);
+            return undefined;
         });
-        const queryResponse = await this.dynamoClient.send(queryCommand);
-        if (queryResponse.Items) {
-            // Extract S3 keys from sort keys (format: "tag#s3Key")
-            const cacheKeys = queryResponse.Items.map((item) => {
-                const sk = item.sk?.S;
-                if (sk) {
-                    const hashIndex = sk.indexOf("#");
-                    return hashIndex !== -1 ? sk.substring(hashIndex + 1) : null;
-                }
-                return null;
-            }).filter(Boolean);
-            this.debug(`TAG ${tag}: Found ${cacheKeys.length} cache entries to invalidate`);
-            // Update revalidation timestamp for all cache keys with this tag
-            const updatePromises = queryResponse.Items.map(async (item) => {
-                const sk = item.sk?.S;
-                if (sk) {
-                    const updateCommand = new client_dynamodb_1.UpdateItemCommand({
-                        TableName: this.dynamoConfig.tableName,
-                        Key: {
-                            pk: { S: this.dynamoConfig.buildId },
-                            sk: { S: sk },
-                        },
-                        UpdateExpression: "SET revalidatedAt = :timestamp",
-                        ExpressionAttributeValues: {
-                            ":timestamp": { N: Date.now().toString() },
-                        },
-                    });
-                    return this.dynamoClient.send(updateCommand);
-                }
-                return Promise.resolve();
-            });
-            await Promise.all(updatePromises.filter(Boolean));
-            // Delete the corresponding S3 cache entries to invalidate them
-            if (this.s3Config.bucketName) {
-                const deletePromises = cacheKeys.map(async (s3Key) => {
-                    if (s3Key) {
-                        const deleteCommand = new client_s3_1.DeleteObjectCommand({
-                            Bucket: this.s3Config.bucketName,
-                            Key: s3Key,
-                        });
-                        try {
-                            await this.s3Client.send(deleteCommand);
-                        }
-                        catch (error) {
-                            // Log but don't fail - the entry might not exist in S3
-                            console.warn(`Failed to delete S3 cache entry ${s3Key}:`, error);
-                        }
-                    }
-                });
-                await Promise.all(deletePromises.filter(Boolean));
-            }
-            // Invalidate the CDN edge cache so CloudFront-fronted deployments don't
-            // keep serving stale responses until the cache policy's TTL naturally expires.
-            if (this.cloudFrontConfig.distributionIdParameterName) {
-                const invalidationPaths = cacheKeys
-                    .filter((s3Key) => Boolean(s3Key))
-                    .map((s3Key) => this.s3KeyToInvalidationPath(s3Key));
-                await this.invalidateCloudFrontPaths(invalidationPaths);
-            }
+    }
+    /**
+     * Every mapping row for `tag`, following `LastEvaluatedKey`, and whether
+     * {@link MAX_TAG_QUERY_PAGES} cut the walk short.
+     *
+     * DynamoDB caps a Query at 1 MB of items regardless of how many match, and
+     * there is one row per tagged entry a runtime `set` wrote, so a large site
+     * passes 1 MB on a common tag. Stopping at the
+     * first page invalidates only that page's entries while still reporting
+     * success, which is indistinguishable from revalidation having worked.
+     */
+    async queryTagMappings(tag) {
+        const items = [];
+        let exclusiveStartKey;
+        let pages = 0;
+        do {
+            const response = await this.dynamoClient.send(new client_dynamodb_1.QueryCommand({
+                TableName: this.config.tableName,
+                KeyConditionExpression: "pk = :pk AND begins_with(sk, :skPrefix)",
+                ExpressionAttributeValues: {
+                    ":pk": { S: this.config.buildId },
+                    ":skPrefix": { S: `${tag}#` },
+                },
+                ExclusiveStartKey: exclusiveStartKey,
+            }));
+            items.push(...(response.Items ?? []));
+            exclusiveStartKey = response.LastEvaluatedKey;
+            pages++;
+        } while (exclusiveStartKey && pages < MAX_TAG_QUERY_PAGES);
+        const truncated = exclusiveStartKey !== undefined;
+        if (truncated) {
+            console.warn(`Stopped paginating tag "${tag}" after ${pages} pages ` +
+                `(${items.length} entries); invalidating the whole app instead.`);
         }
+        return { items, truncated };
     }
     /**
-     * Reverses `buildS3Key` to recover the request path CloudFront cached the
-     * response under. Fetch-cache entries (opaque hash keys, not page routes)
-     * translate to a path that won't match anything cached, which is harmless.
+     * Reverses `buildS3Key` to recover the route the response was cached for, for
+     * {@link cdnInvalidationPaths} to turn into the URIs CloudFront holds it under, or
+     * `undefined` for a key that names no cached URI.
+     *
+     * Two kinds of mapping row do not: a dynamic route template (`blog/[slug].json`,
+     * which the adapter's seeded entries include), and a fetch-cache entry, whose
+     * key is an opaque hash rather than a route. Both would invalidate a URI that
+     * cannot exist, and each one costs one of the fifteen wildcard paths an
+     * invalidation may carry — so they are dropped here rather than crowding out
+     * the real ones.
      */
     s3KeyToInvalidationPath(s3Key) {
-        const prefix = `${this.s3Config.buildId}/`;
+        const prefix = `${this.config.buildId}/`;
         const withoutPrefix = s3Key.startsWith(prefix)
             ? s3Key.slice(prefix.length)
             : s3Key;
         const withoutSuffix = withoutPrefix.endsWith(".json")
             ? withoutPrefix.slice(0, -".json".length)
             : withoutPrefix;
+        if (withoutSuffix.includes("[") || isFetchCacheKey(withoutSuffix)) {
+            return undefined;
+        }
         return withoutSuffix === "index" ? "/" : `/${withoutSuffix}`;
     }
+    /**
+     * Invalidate `paths` in a single request, or the whole app
+     * ({@link wholeAppInvalidationPaths}) when they would not fit in one. See
+     * {@link MAX_WILDCARD_PATHS_PER_INVALIDATION}.
+     */
     async invalidateCloudFrontPaths(paths) {
-        const uniquePaths = Array.from(new Set(paths));
-        if (uniquePaths.length === 0) {
+        let batch = Array.from(new Set(paths));
+        if (batch.length === 0) {
             return;
         }
-        try {
-            const distributionId = await this.getDistributionId();
-            if (!distributionId) {
+        const distributionId = await this.getDistributionId().catch((error) => {
+            console.warn("Could not resolve the distribution to invalidate:", error);
+            return null;
+        });
+        if (!distributionId) {
+            return;
+        }
+        const wildcards = batch.filter(isWildcardPath).length;
+        if (wildcards > MAX_WILDCARD_PATHS_PER_INVALIDATION ||
+            batch.length > MAX_PATHS_PER_INVALIDATION) {
+            const wholeApp = (0, base_path_1.wholeAppInvalidationPaths)(this.cloudFrontConfig.basePath);
+            this.debug(`CLOUDFRONT INVALIDATION: ${batch.length} paths (${wildcards} ` +
+                `wildcards) do not fit one request, collapsing to ` +
+                `[${wholeApp.join(", ")}]`);
+            batch = wholeApp;
+        }
+        for (let attempt = 0;; attempt++) {
+            this.debug(`CLOUDFRONT INVALIDATION: [${batch.join(", ")}] on distribution ${distributionId}`);
+            try {
+                await this.cloudFrontClient.send(new client_cloudfront_1.CreateInvalidationCommand({
+                    DistributionId: distributionId,
+                    InvalidationBatch: {
+                        CallerReference: (0, node_crypto_1.randomUUID)(),
+                        Paths: {
+                            Quantity: batch.length,
+                            Items: batch,
+                        },
+                    },
+                }));
+                return;
+            }
+            catch (error) {
+                if (isInvalidationQuotaError(error) && attempt < INVALIDATION_RETRIES) {
+                    // See `INVALIDATION_RETRIES`.
+                    batch = (0, base_path_1.wholeAppInvalidationPaths)(this.cloudFrontConfig.basePath);
+                    await new Promise((resolve) => setTimeout(resolve, INVALIDATION_RETRY_DELAY_MS * 2 ** attempt));
+                    continue;
+                }
+                // Log but don't fail - the S3/DynamoDB invalidation already succeeded,
+                // and the CloudFront cache policy TTL provides an eventual fallback.
+                console.warn(`Failed to create CloudFront invalidation for [${batch.join(", ")}]:`, error);
                 return;
             }
-            this.debug(`CLOUDFRONT INVALIDATION: [${uniquePaths.join(", ")}] on distribution ${distributionId}`);
-            await this.cloudFrontClient.send(new client_cloudfront_1.CreateInvalidationCommand({
-                DistributionId: distributionId,
-                InvalidationBatch: {
-                    CallerReference: (0, node_crypto_1.randomUUID)(),
-                    Paths: {
-                        Quantity: uniquePaths.length,
-                        Items: uniquePaths,
-                    },
-                },
-            }));
-        }
-        catch (error) {
-            // Log but don't fail - the S3/DynamoDB invalidation already succeeded,
-            // and the CloudFront cache policy TTL provides an eventual fallback.
-            console.warn("Failed to create CloudFront invalidation:", error);
         }
     }
     /**
-     * Resolves the distribution's physical ID via SSM Parameter Store, caching
-     * it for the lifetime of this instance. See `CloudFrontInvalidationConfig`
-     * for why this indirection (rather than a plain env var) is necessary.
+     * The distribution's physical ID, from the environment or else SSM Parameter
+     * Store, cached for the lifetime of this instance. See
+     * `CloudFrontInvalidationConfig` for why Functions need the indirection.
      */
     async getDistributionId() {
+        if (this.cloudFrontConfig.distributionId) {
+            return this.cloudFrontConfig.distributionId;
+        }
         if (this.cachedDistributionId) {
             return this.cachedDistributionId;
         }
@@ -361,31 +799,44 @@ class S3CacheHandler {
         // This handler doesn't maintain request-level cache state
         // The actual cache clearing is handled by the memory cache handler
     }
+    /**
+     * Whether this deployment keeps `tag#s3Key` mapping rows at all.
+     *
+     * Their one reader is `revalidateTag`'s CloudFront invalidation, which needs
+     * the entries' paths - tag revalidation itself runs on the bare-tag marker
+     * rows. A deployment with no distribution (the Regional constructs) would pay
+     * a DynamoDB write per tag on every `set`, a Query per `revalidateTag`, and an
+     * extra S3 read before every delete, for rows nothing ever reads.
+     */
+    get mapsTagsToPaths() {
+        return Boolean(this.config.tableName) && this.invalidatesCdn;
+    }
+    /** Whether there is a distribution to invalidate. */
+    get invalidatesCdn() {
+        return Boolean(this.cloudFrontConfig.distributionId ||
+            this.cloudFrontConfig.distributionIdParameterName);
+    }
+    /** `{buildId}/{cacheKey}.json`; see {@link buildS3Key}. */
     buildS3Key(cacheKey) {
-        // Use BUILD_ID prefixing: {buildId}/{cacheKey}.json
-        // Handle edge cases:
-        // - Root path "/" should become "index" or similar
-        // - Remove leading slashes to prevent empty folders
-        let cleanCacheKey = cacheKey;
-        if (cacheKey === "/" || cacheKey === "") {
-            cleanCacheKey = "index";
-        }
-        else if (cacheKey.startsWith("/")) {
-            cleanCacheKey = cacheKey.slice(1);
-        }
-        return (0, node_path_1.join)(this.s3Config.buildId, `${cleanCacheKey}.json`);
+        return (0, aws_cache_store_1.buildS3Key)(this.config.buildId, cacheKey);
     }
     async storeDynamoDBTagMappings(s3Key, tags) {
         try {
             const updatePromises = tags.map(async (tag) => {
                 const tagCacheKey = `${tag}#${s3Key}`;
                 const updateCommand = new client_dynamodb_1.UpdateItemCommand({
-                    TableName: this.dynamoConfig.tableName,
+                    TableName: this.config.tableName,
                     Key: {
-                        pk: { S: this.dynamoConfig.buildId },
+                        pk: { S: this.config.buildId },
                         sk: { S: tagCacheKey },
                     },
-                    UpdateExpression: "SET createdAt = if_not_exists(createdAt, :now), revalidatedAt = :now",
+                    // Deliberately no `revalidatedAt`: a mapping row records only that an
+                    // entry carries the tag. Stamping it at write time made every tagged
+                    // entry look revalidated one millisecond after it was stored — the
+                    // row's timestamp is taken after the entry's `lastModified` — so
+                    // `checkIfRevalidated` deleted healthy entries and the page
+                    // re-rendered on every request.
+                    UpdateExpression: "SET createdAt = if_not_exists(createdAt, :now)",
                     ExpressionAttributeValues: {
                         ":now": { N: Date.now().toString() },
                     },
@@ -399,54 +850,133 @@ class S3CacheHandler {
             // Don't throw - cache storage should continue even if tag mapping fails
         }
     }
-    async checkIfRevalidated(cacheLastModified, tags) {
+    /**
+     * Drop the `tag#s3Key` mapping rows for an entry that no longer exists.
+     *
+     * The counterpart of {@link storeDynamoDBTagMappings}, and the reason its
+     * caller has to know the entry's tags: a mapping row's sort key starts with
+     * the tag, so the rows belonging to one cache key cannot be queried for - only
+     * a full scan of the build's partition would find them.
+     *
+     * Left behind, a row still resolves to a cache key on the next
+     * `revalidateTag`, which spends one of CloudFront's fifteen wildcard paths
+     * invalidating a URI whose entry was deleted - crowding out the paths that do
+     * need it, and past {@link MAX_WILDCARD_PATHS_PER_INVALIDATION} collapsing the
+     * whole app into one wildcard. The rows also count against the 1 MB a tag's Query returns, so
+     * enough of them push live entries onto a page
+     * {@link MAX_TAG_QUERY_PAGES} may not reach.
+     *
+     * Only the mapping rows: the bare-`tag` marker row `revalidateTag`
+     * writes belongs to the tag rather than to any entry, and `checkIfRevalidated`
+     * reads it for every *other* entry carrying that tag.
+     *
+     * Deliberately no CloudFront invalidation for the deleted path. The edge copy
+     * does outlive the object, but this runs on every revalidated `fetch` entry as
+     * well, where the key names no URI, and an invalidation request per deleted
+     * entry is a cost the TTL already bounds.
+     */
+    async deleteDynamoDBTagMappings(s3Key, tags) {
+        if (!this.mapsTagsToPaths || tags.length === 0) {
+            return;
+        }
         try {
-            // Check each tag to see if it has been revalidated after the cache was created
-            for (const tag of tags) {
-                const queryCommand = new client_dynamodb_1.QueryCommand({
-                    TableName: this.dynamoConfig.tableName,
-                    KeyConditionExpression: "pk = :pk AND begins_with(sk, :skPrefix)",
-                    ExpressionAttributeValues: {
-                        ":pk": { S: this.dynamoConfig.buildId },
-                        ":skPrefix": { S: `${tag}#` },
+            await Promise.all(
+            // A page's tags can repeat - `ctx.tags` and the render's header are both
+            // read - and one delete per tag is enough.
+            Array.from(new Set(tags)).map(async (tag) => {
+                await this.dynamoClient.send(new client_dynamodb_1.DeleteItemCommand({
+                    TableName: this.config.tableName,
+                    Key: {
+                        pk: { S: this.config.buildId },
+                        sk: { S: `${tag}#${s3Key}` },
                     },
-                    ProjectionExpression: "revalidatedAt",
-                    Limit: 1, // We only need to check if any entry exists with this tag
-                });
-                const queryResponse = await this.dynamoClient.send(queryCommand);
-                if (queryResponse.Items && queryResponse.Items.length > 0) {
-                    const revalidatedAt = queryResponse.Items[0].revalidatedAt?.N;
-                    if (revalidatedAt && parseInt(revalidatedAt) > cacheLastModified) {
-                        this.debug(`Tag ${tag} was revalidated at ${revalidatedAt}, cache created at ${cacheLastModified}`);
-                        return true; // Cache is invalidated
-                    }
-                }
-            }
-            return false; // Cache is still valid
+                }));
+            }));
+            this.debug(`DELETED TAG MAPPINGS: ${s3Key} -> [${tags.join(", ")}]`);
         }
         catch (error) {
-            console.error("Error checking cache revalidation:", error);
-            // On error, assume cache is valid to avoid unnecessary cache misses
-            return false;
+            // Log but don't fail: the entry itself is already gone, and a stale
+            // mapping row costs an invalidation path rather than a wrong response.
+            console.error("Error deleting DynamoDB tag mappings:", error);
         }
     }
-    async deleteS3Entry(s3Key) {
+    /**
+     * The tags an entry about to be deleted was stored with.
+     *
+     * `ctx` carries them for a `fetch` delete, but a response delete arrives as
+     * `{ cacheControl, isRoutePPREnabled, isFallback }` - `ResponseCache.set`
+     * builds it that way - so the entry itself is the only source, and it has to
+     * be read before it is removed. That is one extra GET on a path that runs when
+     * a cached route starts answering `notFound()`: `IncrementalCache.set`
+     * forwards `ResponseCache`'s null value through to here.
+     *
+     * A page is also the case worth paying it for, since it carries the whole
+     * implicit `_N_T_/…` chain and therefore the most rows.
+     */
+    async storedEntryTags(s3Key, ctx) {
+        const ctxTags = (0, cache_utils_1.getTags)(ctx);
+        if (ctxTags?.length) {
+            return ctxTags;
+        }
+        if (!this.mapsTagsToPaths) {
+            return [];
+        }
         try {
-            if (!this.s3Config.bucketName) {
-                return;
+            const response = await this.bucket.get(s3Key);
+            if (!response) {
+                return [];
             }
-            const deleteCommand = new client_s3_1.DeleteObjectCommand({
-                Bucket: this.s3Config.bucketName,
-                Key: s3Key,
-            });
-            await this.s3Client.send(deleteCommand);
-            this.debug(`Deleted stale S3 cache entry: ${s3Key}`);
+            return entryTags((0, cache_utils_1.parseCacheValue)(response));
         }
         catch (error) {
-            // Log but don't fail - the entry might not exist in S3
-            console.warn(`Failed to delete stale S3 cache entry ${s3Key}:`, error);
+            console.warn(`Failed to read tags of ${s3Key} before deleting:`, error);
+            return [];
+        }
+    }
+    /**
+     * Whether any of `tags` was revalidated after this entry was stored, and how.
+     *
+     * Reads the per-tag marker rows `revalidateTag` writes, as this instance
+     * tracks them: see `TrackedTagMarkers` for when they are read.
+     * Scanning the tag's mapping rows instead would answer the wrong question:
+     * those rows exist per cache *key*, so which one a `Limit: 1` query returned
+     * depended on sort order, and an entry could be judged against another
+     * entry's timestamp.
+     *
+     * A tag revalidated with a profile only makes the entry *stale*: that is
+     * reported to Next.js through its tag manifest (see {@link nextTagsManifest})
+     * and answered `"stale"` here, so the entry is served while a background
+     * render replaces it. When the manifest cannot be reached a stale entry is
+     * reported expired instead - a blocking render, never a stale page presented
+     * as fresh.
+     */
+    async checkIfRevalidated(cacheLastModified, tags) {
+        await this.tags.refresh();
+        await this.tags.ensure(tags);
+        const state = this.tags.state(tags, cacheLastModified);
+        if (state !== "stale") {
+            if (state === "expired") {
+                this.debug(`Tags [${tags}] expired entry created at ${cacheLastModified}`);
+            }
+            return state;
+        }
+        const manifest = nextTagsManifest();
+        if (!manifest) {
+            this.debug(`Tags [${tags}] are stale and Next.js's tag manifest is ` +
+                `unreachable, expiring the entry instead`);
+            return "expired";
+        }
+        for (const tag of tags) {
+            const staleAt = this.tags.get(tag)?.staleAt;
+            const existing = manifest.get(tag);
+            if (staleAt !== undefined &&
+                staleAt > cacheLastModified &&
+                (existing?.stale ?? 0) < staleAt) {
+                manifest.set(tag, { ...existing, stale: staleAt });
+            }
         }
+        return "stale";
     }
 }
 exports.S3CacheHandler = S3CacheHandler;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"s3-cache-handler.js","sourceRoot":"","sources":["../../src/adapter/s3-cache-handler.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n  S3 and DynamoDB cache handler for Next.js incremental cache\n*/\n/* eslint-disable import/no-extraneous-dependencies */\nimport { randomUUID } from \"node:crypto\";\nimport { join } from \"node:path\";\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  NoSuchKey,\n} from \"@aws-sdk/client-s3\";\nimport { SSMClient, GetParameterCommand } from \"@aws-sdk/client-ssm\";\nimport getDebug from \"debug\";\nimport {\n  CacheHandler,\n  CacheHandlerValue,\n  CacheHandlerContext,\n} from \"next/dist/server/lib/incremental-cache\";\nimport {\n  IncrementalCacheValue,\n  GetIncrementalFetchCacheContext,\n  GetIncrementalResponseCacheContext,\n  SetIncrementalFetchCacheContext,\n  SetIncrementalResponseCacheContext,\n} from \"next/dist/server/response-cache\";\nimport { serializeCacheValue, parseCacheValue, getTags } from \"./cache-utils\";\n\ninterface S3CacheConfig {\n  bucketName: string;\n  region: string;\n  buildId: string;\n}\n\ninterface DynamoDBRevalidationConfig {\n  tableName: string;\n  region: string;\n  buildId: string;\n}\n\ninterface CloudFrontInvalidationConfig {\n  /**\n   * Name (not value) of the SSM Parameter holding the distribution ID.\n   *\n   * The distribution ID itself can't be passed as a plain env var: CDK\n   * constructs the Lambda/Fargate task before the distribution exists (the\n   * distribution's origin references the compute's function URL/ALB), so\n   * embedding the distribution's physical ID directly in the compute's\n   * environment or IAM policy would create a circular CloudFormation\n   * dependency. The parameter *name* is static and known at synth time, so\n   * it can be safely embedded; only its *value* depends on the distribution.\n   */\n  distributionIdParameterName: string;\n  region: string;\n}\n\nexport interface S3CacheHandlerOptions {\n  context: CacheHandlerContext;\n  s3Config?: Partial<S3CacheConfig>;\n  dynamoConfig?: Partial<DynamoDBRevalidationConfig>;\n  cloudFrontConfig?: Partial<CloudFrontInvalidationConfig>;\n}\n\nexport class S3CacheHandler implements CacheHandler {\n  private s3Client: S3Client;\n  private dynamoClient: DynamoDBClient;\n  private cloudFrontClient: CloudFrontClient;\n  private ssmClient: SSMClient;\n  private s3Config: S3CacheConfig;\n  private dynamoConfig: DynamoDBRevalidationConfig;\n  private cloudFrontConfig: CloudFrontInvalidationConfig;\n  private debug = getDebug(\"cdk-nextjs:cache-handler:s3\");\n\n  // Cached for the lifetime of this instance (i.e. the compute instance) once\n  // resolved, since a deployment's distribution ID never changes at runtime.\n  private cachedDistributionId: string | null = null;\n\n  constructor(options: S3CacheHandlerOptions) {\n    const buildId = process.env.CDK_NEXTJS_BUILD_ID || \"\";\n\n    // Initialize S3 configuration from environment variables and options\n    this.s3Config = {\n      bucketName:\n        options.s3Config?.bucketName ||\n        process.env.CDK_NEXTJS_CACHE_BUCKET_NAME ||\n        \"\",\n      region: options.s3Config?.region || process.env.AWS_REGION || \"us-east-1\",\n      buildId: options.s3Config?.buildId || buildId,\n    };\n\n    // Initialize DynamoDB configuration from environment variables and options\n    this.dynamoConfig = {\n      tableName:\n        options.dynamoConfig?.tableName ||\n        process.env.CDK_NEXTJS_REVALIDATION_TABLE_NAME ||\n        \"\",\n      region:\n        options.dynamoConfig?.region || process.env.AWS_REGION || \"us-east-1\",\n      buildId: options.dynamoConfig?.buildId || buildId,\n    };\n\n    // Initialize CloudFront configuration from environment variables and options.\n    // Only set for CloudFront-fronted deployments (NextjsGlobalFunctions/Containers).\n    // When unset, on-demand revalidation skips CDN invalidation and relies on the\n    // distribution's cache policy TTL (driven by the origin's Cache-Control header)\n    // to eventually pick up fresh content.\n    this.cloudFrontConfig = {\n      distributionIdParameterName:\n        options.cloudFrontConfig?.distributionIdParameterName ||\n        process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME ||\n        \"\",\n      region:\n        options.cloudFrontConfig?.region ||\n        process.env.AWS_REGION ||\n        \"us-east-1\",\n    };\n\n    // Initialize AWS clients\n    this.s3Client = new S3Client({ region: this.s3Config.region });\n    this.dynamoClient = new DynamoDBClient({\n      region: this.dynamoConfig.region,\n    });\n    this.cloudFrontClient = new CloudFrontClient({\n      region: this.cloudFrontConfig.region,\n    });\n    this.ssmClient = new SSMClient({ region: this.cloudFrontConfig.region });\n\n    if (!this.s3Config.bucketName) {\n      console.warn(\n        \"CDK_NEXTJS_CACHE_BUCKET_NAME environment variable not set, S3 cache disabled\",\n      );\n    }\n\n    if (!this.dynamoConfig.tableName) {\n      console.warn(\n        \"CDK_NEXTJS_REVALIDATION_TABLE_NAME environment variable not set, revalidation tracking disabled\",\n      );\n    }\n\n    if (!buildId) {\n      console.warn(\n        \"CDK_NEXTJS_BUILD_ID environment variable not set, cache isolation may not work correctly\",\n      );\n    }\n\n    // Log the options for debugging (optional usage to avoid unused parameter warning)\n    if (options.context.dev) {\n      this.debug(\"S3DynamoCacheHandler initialized in development mode\");\n    }\n  }\n\n  async get(\n    cacheKey: string,\n    ctx: GetIncrementalFetchCacheContext | GetIncrementalResponseCacheContext,\n  ): Promise<CacheHandlerValue | null> {\n    try {\n      // Log context for debugging (optional usage to avoid unused parameter warning)\n      if (ctx.kind) {\n        this.debug(\n          `S3 cache get operation for ${cacheKey} with kind: ${ctx.kind}`,\n        );\n      }\n\n      if (!this.s3Config.bucketName) {\n        return null;\n      }\n\n      const s3Key = this.buildS3Key(cacheKey);\n\n      const command = new GetObjectCommand({\n        Bucket: this.s3Config.bucketName,\n        Key: s3Key,\n      });\n\n      const response = await this.s3Client.send(command);\n\n      if (!response.Body) {\n        return null;\n      }\n\n      // Handle different content types appropriately for documented formats\n      let cacheValue: CacheHandlerValue;\n      const contentType = response.ContentType || \"application/json\";\n\n      // Handle text-based data (JSON, HTML, plain text) - all documented formats are text-based\n      const bodyString = await response.Body.transformToString(\"utf-8\");\n\n      if (contentType.includes(\"application/json\")) {\n        // Parse the stored CacheHandlerValue directly\n        const parsedValue = parseCacheValue(bodyString);\n\n        // Extract the actual CacheHandlerValue (without tags) for return\n        cacheValue = {\n          lastModified: parsedValue.lastModified,\n          value: parsedValue.value,\n        };\n\n        // Check if cache has been invalidated by tag revalidation\n        const storedTags = parsedValue.tags || [];\n        if (storedTags.length > 0 && this.dynamoConfig.tableName) {\n          const isInvalidated = await this.checkIfRevalidated(\n            cacheValue.lastModified,\n            storedTags,\n          );\n          if (isInvalidated) {\n            this.debug(`S3 CACHE INVALIDATED BY TAG: ${cacheKey}`);\n            // Delete the stale S3 entry\n            await this.deleteS3Entry(s3Key);\n            return null;\n          }\n        }\n      } else {\n        console.log(`Invalid content type: ${contentType}`);\n        // This shouldn't happen since we always store as JSON now\n        return null;\n      }\n\n      this.debug(`S3 CACHE HIT: ${cacheKey} (${s3Key})`);\n\n      return cacheValue;\n    } catch (error) {\n      if (error instanceof NoSuchKey) {\n        this.debug(`S3 CACHE MISS: ${cacheKey}`);\n        return null;\n      }\n\n      // Log actual errors (not cache misses)\n      console.error(`Error retrieving cache from S3:`, error);\n      return null;\n    }\n  }\n\n  async set(\n    cacheKey: string,\n    data: IncrementalCacheValue | null,\n    ctx: SetIncrementalFetchCacheContext | SetIncrementalResponseCacheContext,\n  ): Promise<void> {\n    try {\n      if (!data) {\n        // Delete from S3 and DynamoDB\n        this.debug(`S3 CACHE DELETE: ${cacheKey}`);\n\n        if (!this.s3Config.bucketName) {\n          return;\n        }\n\n        // Build S3 key without needing to know the kind\n        const s3Key = this.buildS3Key(cacheKey);\n\n        try {\n          const deleteCommand = new DeleteObjectCommand({\n            Bucket: this.s3Config.bucketName,\n            Key: s3Key,\n          });\n          await this.s3Client.send(deleteCommand);\n          this.debug(`S3 CACHE DELETED: ${s3Key}`);\n        } catch (error) {\n          if (error instanceof NoSuchKey) {\n            this.debug(`Failed to delete S3 key ${s3Key}:`, error);\n          }\n        }\n\n        // TODO: Also delete tag associations from DynamoDB if needed\n        return;\n      }\n\n      // Debug logging to understand what data is being cached\n      const tags = getTags(ctx);\n      this.debug(`S3 CACHE SET: Key: ${cacheKey}, tags: ${tags || \"none\"}`);\n\n      // Note: ctx.tags are available but revalidation is handled separately in revalidateTag method\n      // Log tags for debugging if present (only in SetIncrementalFetchCacheContext)\n      if (tags && tags.length > 0) {\n        this.debug(`S3 cache entry for ${cacheKey} has tags:`, tags);\n      }\n\n      if (!this.s3Config.bucketName) {\n        return;\n      }\n\n      const s3Key = this.buildS3Key(cacheKey);\n\n      // Create CacheHandlerValue structure for S3 storage with tags\n      const cacheHandlerValue: CacheHandlerValue = {\n        lastModified: Date.now(),\n        value: data,\n      };\n\n      // Store tags with the cache entry for revalidation checking\n      const cacheEntryWithTags = {\n        ...cacheHandlerValue,\n        tags: tags || [],\n      };\n\n      // Serialize with custom handling for Map and Buffer objects\n      const body = serializeCacheValue(cacheEntryWithTags);\n\n      const command = new PutObjectCommand({\n        Bucket: this.s3Config.bucketName,\n        Key: s3Key,\n        Body: body,\n        ContentType: \"application/json; charset=utf-8\", // Always JSON since we store CacheHandlerValue\n      });\n\n      await this.s3Client.send(command);\n\n      this.debug(`S3 CACHE STORED: ${cacheKey} (${data.kind})`);\n\n      // Store tag-to-cache-key mappings in DynamoDB for revalidation\n      if (tags && tags.length > 0 && this.dynamoConfig.tableName) {\n        this.debug(`STORING TAGS: ${cacheKey} -> [${tags.join(\", \")}]`);\n        await this.storeDynamoDBTagMappings(s3Key, tags);\n      }\n    } catch (error) {\n      console.error(\"Error storing cache to S3:\", error);\n    }\n  }\n\n  async revalidateTag(tag: string | string[]): Promise<void> {\n    const tags = Array.isArray(tag) ? tag : [tag];\n    this.debug(`REVALIDATING TAGS: [${tags.join(\", \")}]`);\n\n    try {\n      if (!this.dynamoConfig.tableName) {\n        return;\n      }\n\n      // Process all tags in parallel for better performance\n      await Promise.all(tags.map((t) => this.revalidateSingleTag(t)));\n    } catch (error) {\n      console.error(\"Error updating revalidation metadata:\", error);\n    }\n  }\n\n  private async revalidateSingleTag(tag: string): Promise<void> {\n    // Query all paths associated with this tag\n    const queryCommand = new QueryCommand({\n      TableName: this.dynamoConfig.tableName,\n      KeyConditionExpression: \"pk = :pk AND begins_with(sk, :skPrefix)\",\n      ExpressionAttributeValues: {\n        \":pk\": { S: this.dynamoConfig.buildId },\n        \":skPrefix\": { S: `${tag}#` },\n      },\n    });\n\n    const queryResponse = await this.dynamoClient.send(queryCommand);\n\n    if (queryResponse.Items) {\n      // Extract S3 keys from sort keys (format: \"tag#s3Key\")\n      const cacheKeys = queryResponse.Items.map((item) => {\n        const sk = item.sk?.S;\n        if (sk) {\n          const hashIndex = sk.indexOf(\"#\");\n          return hashIndex !== -1 ? sk.substring(hashIndex + 1) : null;\n        }\n        return null;\n      }).filter(Boolean);\n\n      this.debug(\n        `TAG ${tag}: Found ${cacheKeys.length} cache entries to invalidate`,\n      );\n\n      // Update revalidation timestamp for all cache keys with this tag\n      const updatePromises = queryResponse.Items.map(async (item) => {\n        const sk = item.sk?.S;\n        if (sk) {\n          const updateCommand = new UpdateItemCommand({\n            TableName: this.dynamoConfig.tableName,\n            Key: {\n              pk: { S: this.dynamoConfig.buildId },\n              sk: { S: sk },\n            },\n            UpdateExpression: \"SET revalidatedAt = :timestamp\",\n            ExpressionAttributeValues: {\n              \":timestamp\": { N: Date.now().toString() },\n            },\n          });\n\n          return this.dynamoClient.send(updateCommand);\n        }\n        return Promise.resolve();\n      });\n\n      await Promise.all(updatePromises.filter(Boolean));\n\n      // Delete the corresponding S3 cache entries to invalidate them\n      if (this.s3Config.bucketName) {\n        const deletePromises = cacheKeys.map(async (s3Key) => {\n          if (s3Key) {\n            const deleteCommand = new DeleteObjectCommand({\n              Bucket: this.s3Config.bucketName,\n              Key: s3Key,\n            });\n\n            try {\n              await this.s3Client.send(deleteCommand);\n            } catch (error) {\n              // Log but don't fail - the entry might not exist in S3\n              console.warn(`Failed to delete S3 cache entry ${s3Key}:`, error);\n            }\n          }\n        });\n\n        await Promise.all(deletePromises.filter(Boolean));\n      }\n\n      // Invalidate the CDN edge cache so CloudFront-fronted deployments don't\n      // keep serving stale responses until the cache policy's TTL naturally expires.\n      if (this.cloudFrontConfig.distributionIdParameterName) {\n        const invalidationPaths = cacheKeys\n          .filter((s3Key): s3Key is string => Boolean(s3Key))\n          .map((s3Key) => this.s3KeyToInvalidationPath(s3Key));\n        await this.invalidateCloudFrontPaths(invalidationPaths);\n      }\n    }\n  }\n\n  /**\n   * Reverses `buildS3Key` to recover the request path CloudFront cached the\n   * response under. Fetch-cache entries (opaque hash keys, not page routes)\n   * translate to a path that won't match anything cached, which is harmless.\n   */\n  private s3KeyToInvalidationPath(s3Key: string): string {\n    const prefix = `${this.s3Config.buildId}/`;\n    const withoutPrefix = s3Key.startsWith(prefix)\n      ? s3Key.slice(prefix.length)\n      : s3Key;\n    const withoutSuffix = withoutPrefix.endsWith(\".json\")\n      ? withoutPrefix.slice(0, -\".json\".length)\n      : withoutPrefix;\n\n    return withoutSuffix === \"index\" ? \"/\" : `/${withoutSuffix}`;\n  }\n\n  private async invalidateCloudFrontPaths(paths: string[]): Promise<void> {\n    const uniquePaths = Array.from(new Set(paths));\n    if (uniquePaths.length === 0) {\n      return;\n    }\n\n    try {\n      const distributionId = await this.getDistributionId();\n      if (!distributionId) {\n        return;\n      }\n\n      this.debug(\n        `CLOUDFRONT INVALIDATION: [${uniquePaths.join(\", \")}] on distribution ${distributionId}`,\n      );\n\n      await this.cloudFrontClient.send(\n        new CreateInvalidationCommand({\n          DistributionId: distributionId,\n          InvalidationBatch: {\n            CallerReference: randomUUID(),\n            Paths: {\n              Quantity: uniquePaths.length,\n              Items: uniquePaths,\n            },\n          },\n        }),\n      );\n    } catch (error) {\n      // Log but don't fail - the S3/DynamoDB invalidation already succeeded,\n      // and the CloudFront cache policy TTL provides an eventual fallback.\n      console.warn(\"Failed to create CloudFront invalidation:\", error);\n    }\n  }\n\n  /**\n   * Resolves the distribution's physical ID via SSM Parameter Store, caching\n   * it for the lifetime of this instance. See `CloudFrontInvalidationConfig`\n   * for why this indirection (rather than a plain env var) is necessary.\n   */\n  private async getDistributionId(): Promise<string | null> {\n    if (this.cachedDistributionId) {\n      return this.cachedDistributionId;\n    }\n\n    if (!this.cloudFrontConfig.distributionIdParameterName) {\n      return null;\n    }\n\n    const response = await this.ssmClient.send(\n      new GetParameterCommand({\n        Name: this.cloudFrontConfig.distributionIdParameterName,\n      }),\n    );\n\n    this.cachedDistributionId = response.Parameter?.Value || null;\n    return this.cachedDistributionId;\n  }\n\n  async resetRequestCache(): Promise<void> {\n    // This handler doesn't maintain request-level cache state\n    // The actual cache clearing is handled by the memory cache handler\n  }\n\n  private buildS3Key(cacheKey: string): string {\n    // Use BUILD_ID prefixing: {buildId}/{cacheKey}.json\n\n    // Handle edge cases:\n    // - Root path \"/\" should become \"index\" or similar\n    // - Remove leading slashes to prevent empty folders\n    let cleanCacheKey = cacheKey;\n\n    if (cacheKey === \"/\" || cacheKey === \"\") {\n      cleanCacheKey = \"index\";\n    } else if (cacheKey.startsWith(\"/\")) {\n      cleanCacheKey = cacheKey.slice(1);\n    }\n\n    return join(this.s3Config.buildId, `${cleanCacheKey}.json`);\n  }\n\n  private async storeDynamoDBTagMappings(\n    s3Key: string,\n    tags: string[],\n  ): Promise<void> {\n    try {\n      const updatePromises = tags.map(async (tag) => {\n        const tagCacheKey = `${tag}#${s3Key}`;\n        const updateCommand = new UpdateItemCommand({\n          TableName: this.dynamoConfig.tableName,\n          Key: {\n            pk: { S: this.dynamoConfig.buildId },\n            sk: { S: tagCacheKey },\n          },\n          UpdateExpression:\n            \"SET createdAt = if_not_exists(createdAt, :now), revalidatedAt = :now\",\n          ExpressionAttributeValues: {\n            \":now\": { N: Date.now().toString() },\n          },\n        });\n\n        await this.dynamoClient.send(updateCommand);\n      });\n\n      await Promise.all(updatePromises);\n    } catch (error) {\n      console.error(\"Error storing DynamoDB tag mappings:\", error);\n      // Don't throw - cache storage should continue even if tag mapping fails\n    }\n  }\n\n  private async checkIfRevalidated(\n    cacheLastModified: number,\n    tags: string[],\n  ): Promise<boolean> {\n    try {\n      // Check each tag to see if it has been revalidated after the cache was created\n      for (const tag of tags) {\n        const queryCommand = new QueryCommand({\n          TableName: this.dynamoConfig.tableName,\n          KeyConditionExpression: \"pk = :pk AND begins_with(sk, :skPrefix)\",\n          ExpressionAttributeValues: {\n            \":pk\": { S: this.dynamoConfig.buildId },\n            \":skPrefix\": { S: `${tag}#` },\n          },\n          ProjectionExpression: \"revalidatedAt\",\n          Limit: 1, // We only need to check if any entry exists with this tag\n        });\n\n        const queryResponse = await this.dynamoClient.send(queryCommand);\n\n        if (queryResponse.Items && queryResponse.Items.length > 0) {\n          const revalidatedAt = queryResponse.Items[0].revalidatedAt?.N;\n          if (revalidatedAt && parseInt(revalidatedAt) > cacheLastModified) {\n            this.debug(\n              `Tag ${tag} was revalidated at ${revalidatedAt}, cache created at ${cacheLastModified}`,\n            );\n            return true; // Cache is invalidated\n          }\n        }\n      }\n\n      return false; // Cache is still valid\n    } catch (error) {\n      console.error(\"Error checking cache revalidation:\", error);\n      // On error, assume cache is valid to avoid unnecessary cache misses\n      return false;\n    }\n  }\n\n  private async deleteS3Entry(s3Key: string): Promise<void> {\n    try {\n      if (!this.s3Config.bucketName) {\n        return;\n      }\n\n      const deleteCommand = new DeleteObjectCommand({\n        Bucket: this.s3Config.bucketName,\n        Key: s3Key,\n      });\n\n      await this.s3Client.send(deleteCommand);\n      this.debug(`Deleted stale S3 cache entry: ${s3Key}`);\n    } catch (error) {\n      // Log but don't fail - the entry might not exist in S3\n      console.warn(`Failed to delete stale S3 cache entry ${s3Key}:`, error);\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"s3-cache-handler.js","sourceRoot":"","sources":["../../src/adapter/s3-cache-handler.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n  S3 and DynamoDB cache handler for Next.js incremental cache\n*/\n/* eslint-disable import/no-extraneous-dependencies */\nimport { randomUUID } from \"node:crypto\";\nimport { readFileSync } from \"node:fs\";\nimport { createRequire } from \"node:module\";\nimport { join } from \"node:path\";\nimport {\n  CloudFrontClient,\n  CreateInvalidationCommand,\n} from \"@aws-sdk/client-cloudfront\";\nimport {\n  AttributeValue,\n  DeleteItemCommand,\n  DynamoDBClient,\n  QueryCommand,\n  UpdateItemCommand,\n} from \"@aws-sdk/client-dynamodb\";\nimport { S3Client, DeleteObjectCommand } from \"@aws-sdk/client-s3\";\nimport { SSMClient, GetParameterCommand } from \"@aws-sdk/client-ssm\";\nimport getDebug from \"debug\";\nimport {\n  CacheHandler,\n  CacheHandlerValue,\n  CacheHandlerContext,\n} from \"next/dist/server/lib/incremental-cache\";\nimport {\n  IncrementalCacheValue,\n  GetIncrementalFetchCacheContext,\n  GetIncrementalResponseCacheContext,\n  SetIncrementalFetchCacheContext,\n  SetIncrementalResponseCacheContext,\n} from \"next/dist/server/response-cache\";\nimport {\n  AwsCacheConfig,\n  buildS3Key,\n  CacheBucket,\n  markerClock,\n  resolveAwsCacheConfig,\n  RevalidateDurations,\n  RevalidationState,\n  TrackedTagMarkers,\n} from \"./aws-cache-store\";\nimport {\n  serializeCacheValue,\n  parseCacheValue,\n  getTags,\n  headerTags,\n  INIT_CACHE_TAG_MANIFEST,\n} from \"./cache-utils\";\nimport { sharedTagManifest } from \"./use-cache-common\";\nimport { REVALIDATED_PAGE_HOOK } from \"../runtime/manifest\";\nimport { basePathPrefix, wholeAppInvalidationPaths } from \"../utils/base-path\";\n\n/**\n * The tags a stored entry has to be tag-revalidated against.\n *\n * A runtime `set` records `tags` alongside the entry, but a build-time prerender\n * does not: those entries are written as files by the adapter's\n * `onBuildComplete` rather than through `set`, and carry their tags only in the\n * render's `x-next-cache-tags` header — the same place Next.js's own\n * `IncrementalCache.get` reads them from when it decides staleness. Without this\n * fallback no prerendered page is reachable by `revalidateTag`/`revalidatePath`\n * until some later runtime re-render happens to replace the seeded entry, so an\n * app whose pages are all static never revalidates at all. Measured against\n * next.js's `test/e2e/app-dir/resume-data-cache`.\n */\nfunction entryTags(stored: { tags?: string[]; value?: unknown }): string[] {\n  return stored.tags?.length ? stored.tags : headerTags(stored.value);\n}\n\n/**\n * The `lastModified` that tells Next.js \"this entry is expired, re-render it\n * before answering\".\n *\n * `IncrementalCache.get` turns it into `isStale: -1`, which `app-page-runtime`\n * reads as an on-demand revalidation and answers with a blocking render of\n * *this* route, then stores it. Returning `null` instead is not the same thing:\n * a miss on a PPR route whose `prerender-manifest.json` entry carries a\n * `fallback` (`compute: \"resuming\"`) is answered from the route's fallback\n * shell, which is served `cache-control: private, no-store` with no\n * `x-nextjs-cache` header, and - unless `partialPrefetching` is on - is never\n * upgraded into a concrete entry. So the first `revalidateTag` to reach a\n * seeded prerender left that page uncacheable, and dynamically resumed per\n * request, for the rest of the deployment's life. The isr e2e sees it as an\n * absent `x-nextjs-cache`.\n */\nconst EXPIRED_LAST_MODIFIED = -1;\n\n/**\n * Whether a `get` is for the `fetch` cache rather than for a route's response,\n * as a narrowing predicate so that `ctx.tags` and `ctx.softTags` — which only\n * {@link GetIncrementalFetchCacheContext} has — are reachable without a cast.\n *\n * `IncrementalCacheKind.FETCH`, compared as its own string value so this file\n * keeps importing no Next.js internals (the enum is `const`, so it has no\n * runtime representation to import anyway).\n */\nfunction isFetchCacheGet(\n  ctx: GetIncrementalFetchCacheContext | GetIncrementalResponseCacheContext,\n): ctx is GetIncrementalFetchCacheContext {\n  return ctx.kind === \"FETCH\";\n}\n\n/** `NEXT_CACHE_IMPLICIT_TAG_ID`, inlined so this file imports no Next.js internals. */\nconst NEXT_CACHE_IMPLICIT_TAG_ID = \"_N_T_\";\n\n/**\n * The `type` argument of `revalidatePath`, which Next.js appends to the implicit\n * tag as a path segment. @see implicitTagPaths\n */\nconst REVALIDATE_PATH_TYPES = [\"layout\", \"page\"];\n\n/**\n * The request paths a `revalidatePath` tag could name, or empty for an app tag.\n *\n * `revalidatePath(\"/blog\")` reaches the cache handler as the implicit tag\n * `_N_T_/blog` - the path is right there in the tag, which is what makes the CDN\n * copy of a build-time prerender reachable at all. A `revalidateTag(\"posts\")`\n * carries no path and depends on the mapping rows instead.\n *\n * Two paths come back when the tag ends in a `revalidatePath` *type*, because\n * `revalidatePath(path, type)` appends it to the tag\n * (`next/dist/server/web/spec-extension/revalidate.js`):\n * `revalidatePath(\"/blog\", \"layout\")` is `_N_T_/blog/layout`, and\n * `revalidatePath(\"/\", \"layout\")` is `_N_T_/layout`. Reading either of those as a\n * request path invalidates a URI that does not exist and never touches the one\n * that does. The suffix cannot be told apart from a route that genuinely ends in\n * `/layout`, so both readings are emitted: an invalidation path matching nothing\n * costs a path, while missing the real one leaves the edge stale for the whole\n * `s-maxage`.\n */\nfunction implicitTagPaths(tag: string): string[] {\n  if (!tag.startsWith(`${NEXT_CACHE_IMPLICIT_TAG_ID}/`)) {\n    return [];\n  }\n  const path = tag.slice(NEXT_CACHE_IMPLICIT_TAG_ID.length);\n  const candidates = [path];\n  for (const type of REVALIDATE_PATH_TYPES) {\n    if (path.endsWith(`/${type}`)) {\n      // `_N_T_/layout` is the root, not the empty path.\n      candidates.push(path.slice(0, -(type.length + 1)) || \"/\");\n    }\n  }\n  // A dynamic route template (\"/blog/[slug]\") matches no cached URI. Harmless to\n  // send, but it costs an invalidation path, and those are metered.\n  return Array.from(new Set(candidates)).filter((p) => !p.includes(\"[\"));\n}\n\n/**\n * Invalidation paths covering every URI CloudFront could be holding the response\n * for `route` under, once `basePath` is prefixed.\n *\n * An invalidation path matches only the query string it spells out, and a page's\n * RSC payload is cached under `?_rsc=<hash>`; dropping the HTML while leaving the\n * payload behind leaves the router navigating to the pre-revalidation page. A\n * `trailingSlash` app caches the redirect target rather than the route, so the\n * slash variant has to go too.\n *\n * One trailing wildcard covers all four (`/blog`, `/blog?…`, `/blog/`,\n * `/blog/?…`) for a single wildcard path, where spelling them out cost two -\n * and wildcards are the quota that runs out. It also matches `/blogroll` and\n * everything under `/blog/`, which is a lower hit rate on those, never a stale\n * page. The app's root is the exception: `/*` there is the whole app.\n *\n * `basePath` is prefixed here because neither source of a route carries it.\n * Cache keys are routes — Next.js strips `basePath` before routing, so the cache\n * handler never sees one — and `revalidatePath(\"/blog\")` names the route as\n * well. CloudFront only ever saw `/base/blog`, so invalidating `/blog` clears\n * nothing and the edge keeps serving the pre-revalidation page until `s-maxage`\n * expires. The app's root under a `basePath` is `/base`, not `/base/`.\n */\nfunction cdnInvalidationPaths(route: string, basePath: string): string[] {\n  const trimmed = route.replace(/\\/+$/, \"\");\n  if (trimmed === \"\") {\n    return basePath\n      ? [basePath, `${basePath}?*`, `${basePath}/`, `${basePath}/?*`]\n      : [\"/\", \"/?*\"];\n  }\n  return [`${basePath}${encodeInvalidationRoute(trimmed)}*`];\n}\n\n/**\n * The app's `basePath`, from the `required-server-files.json` every deployment\n * root stages next to `serverDistDir`: Next.js hands the cache handler no\n * other copy.\n */\nfunction appBasePath(serverDistDir: string | undefined): string | undefined {\n  if (!serverDistDir) {\n    return undefined;\n  }\n  try {\n    const file = join(serverDistDir, \"..\", \"required-server-files.json\");\n    return JSON.parse(readFileSync(file, \"utf8\")).config?.basePath;\n  } catch (error) {\n    console.warn(\"Could not read basePath for CDN invalidation:\", error);\n    return undefined;\n  }\n}\n\n/**\n * `route` as the URI a browser requests it under, which is what CloudFront\n * caches it by.\n *\n * Next.js builds cache keys from the *decoded* pathname (`decodePathParams` in\n * `route-module.js`), so `/blog/héllo` or `/blog/hello world` reach here raw,\n * while CloudFront holds `/blog/h%C3%A9llo`, and an invalidation path matches\n * the encoded form only - AWS requires non-ASCII and unsafe characters to be\n * percent-encoded, and nothing else. Each segment is encoded the way\n * `encodeURI` does, which leaves the characters a browser sends raw in a path\n * (`@`, `:`, `,`, `;`, ...) alone. A `%` that already starts an escape is kept:\n * `decodePathParams` re-escapes path delimiters (`%2F`, `%3F`, `%23`, `%5C`),\n * and a `revalidatePath` tag may name the encoded path itself. `?` and `#` can\n * only be in a decoded segment as data, so they are encoded too.\n */\nfunction encodeInvalidationRoute(route: string): string {\n  return route\n    .split(\"/\")\n    .map((segment) =>\n      segment\n        .split(/(%[0-9A-Fa-f]{2})/)\n        .map((part, i) =>\n          i % 2 === 1\n            ? part\n            : encodeURI(part).replace(\n                /[?#]/g,\n                (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`,\n              ),\n        )\n        .join(\"\"),\n    )\n    .join(\"/\");\n}\n\n/**\n * Whether a cache key is a fetch-cache entry rather than a page route.\n *\n * Those keys are the hash Next.js derives from the request — a single segment of\n * lowercase hex, long enough that no route pathname takes the same shape. They\n * are mapped to tags exactly like pages are, but name no URI CloudFront could be\n * holding, so an invalidation path built from one is always wasted.\n */\nfunction isFetchCacheKey(key: string): boolean {\n  return /^[0-9a-f]{32,}$/.test(key);\n}\n\n/** Whether CloudFront counts this path against the wildcard quota. */\nfunction isWildcardPath(path: string): boolean {\n  return path.includes(\"*\");\n}\n\n/**\n * The most wildcard paths one `revalidateTag` sends before collapsing to a single\n * app-wide wildcard, and the most paths of any kind.\n *\n * CloudFront's wildcard quota is per *distribution*, not per request: the\n * invalidations it has in progress share it, so splitting an oversized set into\n * back-to-back requests is what gets the later ones rejected\n * (`TooManyInvalidationsInProgress`, or a throttle under the newer rate-based\n * quotas) - and a rejected request is a page that stays stale at the edge. So\n * everything goes out as one request, and a set that would not fit in one is\n * answered with the whole app (`/*`, see `wholeAppInvalidationPaths`) instead:\n * a worse hit rate, and a strictly correct answer.\n * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-invalidations\n */\nconst MAX_WILDCARD_PATHS_PER_INVALIDATION = 15;\n\nconst MAX_PATHS_PER_INVALIDATION = 3000;\n\n/**\n * Retries of an invalidation CloudFront rejected for its in-progress quota, and\n * the delay before the first; each later one waits twice as long.\n *\n * Sizing a request against the quota cannot see the invalidations other\n * instances already have in flight, so two `revalidateTag`s close together can\n * each fit on their own and still be rejected together. Dropping the rejected\n * one left its pages stale at the edge for the whole `s-maxage`. The retry asks\n * for the whole app instead, which is one wildcard - the least of the quota any\n * request can take - at the cost of a colder edge.\n */\nconst INVALIDATION_RETRIES = 2;\nconst INVALIDATION_RETRY_DELAY_MS = 1000;\n\n/** The errors that mean \"the quota is full right now\", not \"this is wrong\". */\nfunction isInvalidationQuotaError(error: unknown): boolean {\n  const name = (error as { name?: unknown } | null)?.name;\n  return name === \"TooManyInvalidationsInProgress\" || name === \"Throttling\";\n}\n\n/**\n * The most cache keys to remember as served stale while awaiting their\n * regeneration. A background render that fails never calls `set`, so without a\n * bound its key would stay behind for the life of the instance.\n * @see S3CacheHandler.softRevalidatedKeys\n */\nconst MAX_SOFT_REVALIDATED_KEYS = 1000;\n\n/**\n * How many 1 MB Query pages of one tag's mapping rows to walk. A ceiling rather\n * than a real limit: it bounds a runaway tag instead of paginating a whole table\n * on a request path. A tag cut off here invalidates the whole app, because the\n * rows it never read are pages whose edge copy would otherwise stay stale.\n */\nconst MAX_TAG_QUERY_PAGES = 20;\n\n/**\n * Next.js's in-process tag manifest, which `IncrementalCache.get` consults to\n * decide whether an entry is stale - or `undefined` when it cannot be found\n * unambiguously.\n *\n * `revalidateTag(tag, profile)` asks for stale-while-revalidate: the entry is\n * served once more while a background render replaces it. A cache handler has\n * no field to say \"stale\" in - `lastModified: -1` means expired, which blocks -\n * so this sets the tag's `stale` timestamp where Next.js already looks for it,\n * which is exactly what its own `FileSystemCache.revalidateTag` does. The module\n * is read from the loaded-module cache rather than `require`d: the handler is\n * bundled apart from the app, and resolving `next` from here could reach a\n * different copy than the server loaded, whose manifest nothing reads. A stale\n * mark written there would serve the entry as fresh, so without exactly one\n * loaded copy the caller falls back to expiring the entry outright.\n */\nconst TAGS_MANIFEST_MODULE =\n  \"/next/dist/server/lib/incremental-cache/tags-manifest.external.js\";\nfunction nextTagsManifest():\n  Map<string, { stale?: number; expired?: number }> | undefined {\n  const cache = createRequire(join(process.cwd(), \"index.js\")).cache;\n  const loaded = Object.keys(cache).filter((path) =>\n    path.replace(/\\\\/g, \"/\").endsWith(TAGS_MANIFEST_MODULE),\n  );\n  if (loaded.length !== 1) {\n    return undefined;\n  }\n  const manifest = cache[loaded[0]]?.exports?.tagsManifest;\n  return manifest instanceof Map ? manifest : undefined;\n}\n\ninterface CloudFrontInvalidationConfig {\n  /**\n   * The distribution ID, when the compute's environment can carry it\n   * (`NextjsGlobalContainers`).\n   */\n  distributionId: string;\n  /**\n   * Otherwise, the name (not value) of the SSM Parameter holding it.\n   *\n   * On `NextjsGlobalFunctions` the distribution's origin is the function's\n   * URL, so the function's environment naming the distribution back would be\n   * a circular CloudFormation dependency. The parameter *name* is static and\n   * known at synth time; only its *value* depends on the distribution.\n   */\n  distributionIdParameterName: string;\n  /**\n   * The app's `basePath`, as the URI prefix CloudFront cached the responses\n   * under.\n   * @see cdnInvalidationPaths\n   */\n  basePath: string;\n}\n\nexport interface S3CacheHandlerOptions {\n  context: CacheHandlerContext;\n  /**\n   * The app's `basePath`, for tests: read from `required-server-files.json`\n   * otherwise.\n   */\n  basePath?: string;\n}\n\nexport class S3CacheHandler implements CacheHandler {\n  private s3Client: S3Client;\n  private dynamoClient: DynamoDBClient;\n  private cloudFrontClient: CloudFrontClient;\n  private ssmClient: SSMClient;\n  private bucket: CacheBucket;\n  private tags: TrackedTagMarkers;\n  private config: AwsCacheConfig;\n  private cloudFrontConfig: CloudFrontInvalidationConfig;\n  private debug = getDebug(\"cdk-nextjs:cache-handler:s3\");\n\n  // Cached for the lifetime of this instance (i.e. the compute instance) once\n  // resolved, since a deployment's distribution ID never changes at runtime.\n  private cachedDistributionId: string | null = null;\n\n  /**\n   * Cache keys this instance served stale because of a soft `revalidateTag`,\n   * whose regenerated entry `set` has yet to write.\n   *\n   * `revalidateTag(tag, profile)` invalidates CloudFront at once, but the next\n   * request is answered from the stale entry - stale-while-revalidate - and that\n   * response carries the entry's original `s-maxage`, so the edge caches the\n   * stale body again. The background render that replaces it runs in this same\n   * process, so `set` checks this set and invalidates the key's paths a second\n   * time once the fresh entry is in S3. Without that, the edge kept serving the\n   * pre-revalidation page for the whole `s-maxage`.\n   *\n   * Expiring soft-revalidated entries outright instead would also keep the edge\n   * right, but it turns every `revalidateTag(tag, \"max\")` into a blocking render\n   * at the origin, which is the thing a profile asks not to happen.\n   */\n  private softRevalidatedKeys = new Set<string>();\n\n  /** @see buildTagManifest */\n  private buildTags: Promise<Map<string, string[]>> | undefined;\n\n  constructor(options: S3CacheHandlerOptions) {\n    this.config = resolveAwsCacheConfig();\n\n    // Only set for CloudFront-fronted deployments (NextjsGlobalFunctions/Containers).\n    // When unset, on-demand revalidation skips CDN invalidation and relies on the\n    // distribution's cache policy TTL (driven by the origin's Cache-Control header)\n    // to eventually pick up fresh content.\n    this.cloudFrontConfig = {\n      distributionId: process.env.CDK_NEXTJS_DISTRIBUTION_ID || \"\",\n      distributionIdParameterName:\n        process.env.CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME || \"\",\n      basePath: basePathPrefix(options.basePath),\n    };\n    // Only invalidation needs it, so only a handler behind a distribution reads\n    // it, and a missing file there is worth a warning.\n    if (this.invalidatesCdn && options.basePath === undefined) {\n      this.cloudFrontConfig.basePath = basePathPrefix(\n        appBasePath(options.context.serverDistDir),\n      );\n    }\n\n    // Initialize AWS clients\n    const { region } = this.config;\n    this.s3Client = new S3Client({ region });\n    this.dynamoClient = new DynamoDBClient({ region });\n    this.cloudFrontClient = new CloudFrontClient({ region });\n    this.ssmClient = new SSMClient({ region });\n    this.bucket = new CacheBucket(this.s3Client, this.config.bucketName);\n    // The process's one copy of the tag markers, shared with the `'use cache'`\n    // handlers: one `revalidateTag` writes each tag's rows once, and one log\n    // `Query` per interval serves every handler.\n    this.tags = sharedTagManifest();\n\n    // `res.revalidate()` regenerates a page without going through\n    // `revalidateTag`, so the runtime asks for the CDN copies itself, through\n    // this hook (`invalidateRevalidatedPage` in `src/runtime/core.ts`). A global\n    // because the runtime and this handler are separate bundles in one process.\n    // Every instance registers the same thing, so the latest one winning is fine.\n    if (this.invalidatesCdn) {\n      (globalThis as Record<symbol, unknown>)[REVALIDATED_PAGE_HOOK] = (\n        routes: readonly string[],\n      ): Promise<void> => {\n        const { basePath } = this.cloudFrontConfig;\n        return this.invalidateCloudFrontPaths(\n          routes.flatMap((route) => cdnInvalidationPaths(route, basePath)),\n        );\n      };\n    }\n\n    if (!this.config.bucketName) {\n      console.warn(\n        \"CDK_NEXTJS_CACHE_BUCKET_NAME environment variable not set, S3 cache disabled\",\n      );\n    }\n\n    if (!this.config.tableName) {\n      console.warn(\n        \"CDK_NEXTJS_REVALIDATION_TABLE_NAME environment variable not set, revalidation tracking disabled\",\n      );\n    }\n\n    if (!process.env.CDK_NEXTJS_BUILD_ID) {\n      console.warn(\n        \"CDK_NEXTJS_BUILD_ID environment variable not set, cache isolation may not work correctly\",\n      );\n    }\n  }\n\n  async get(\n    cacheKey: string,\n    ctx: GetIncrementalFetchCacheContext | GetIncrementalResponseCacheContext,\n  ): Promise<CacheHandlerValue | null> {\n    try {\n      if (!this.config.bucketName) {\n        return null;\n      }\n\n      const s3Key = this.buildS3Key(cacheKey);\n\n      const response = await this.bucket.get(s3Key);\n\n      if (!response) {\n        this.debug(`S3 CACHE MISS: ${cacheKey}`);\n        return null;\n      }\n\n      // Every object is JSON (`putJson`, and the seeded `.json` files); one\n      // that does not parse is a miss, through the `catch` below.\n      const parsedValue = parseCacheValue(response);\n\n      if (await this.isRevalidated(parsedValue, ctx, cacheKey)) {\n        this.debug(`S3 CACHE INVALIDATED BY TAG: ${cacheKey}`);\n        // A revalidated `fetch` entry has to read as a miss so the request\n        // refetches instead of reusing the body - the same thing Next.js's\n        // own `FileSystemCache` does with `revalidatedTags`. Only a\n        // *response* entry gets handed back expired, because for those a\n        // miss is worse than stale: see `EXPIRED_LAST_MODIFIED`.\n        //\n        // Neither is deleted. The refetch or re-render this provokes\n        // overwrites the object through `set`, with a `lastModified` past the\n        // tag's marker; deleting it here as well raced that write, and a\n        // concurrent request's fresh entry could be the one removed. Keeping\n        // a response entry also means a render that fails is answered from\n        // the last good copy rather than from a shell.\n        return isFetchCacheGet(ctx)\n          ? null\n          : { lastModified: EXPIRED_LAST_MODIFIED, value: parsedValue.value };\n      }\n\n      this.debug(`S3 CACHE HIT: ${cacheKey} (${s3Key})`);\n\n      // Without the stored tags.\n      return {\n        lastModified: parsedValue.lastModified,\n        value: parsedValue.value,\n      };\n    } catch (error) {\n      // Log actual errors (a cache miss is not one: see `CacheBucket.get`)\n      console.error(`Error retrieving cache from S3:`, error);\n      return null;\n    }\n  }\n\n  /**\n   * Whether a tag revalidation has expired `entry`, for a `get` with `ctx`.\n   *\n   * Public because the in-memory layer in front of this handler has to ask too:\n   * a memory hit never reaches {@link get}, and without this check an instance\n   * other than the one that ran `revalidateTag` kept answering from memory for\n   * the whole memory TTL - long enough for CloudFront to cache the stale page\n   * again after the invalidation.\n   *\n   * Which tags to check depends on the kind, and Next.js's own\n   * `FileSystemCache.get` splits the same two ways: a response entry is checked\n   * against the tags *it* was stored with, but a `fetch` entry is checked\n   * against `[...ctx.tags, ...ctx.softTags]` — the tags of the request asking\n   * for it. That distinction is load-bearing, because a `fetch` entry is only\n   * ever stored with its *explicit* `cache: { tags }` and never with the\n   * implicit `_N_T_/<path>` chain, which arrives only as `ctx.softTags`.\n   * Reading the stored tags for a `fetch` too meant an untagged `force-cache`\n   * fetch had `[]`, skipped the check entirely, and no `revalidatePath` could\n   * ever evict it: a `force-dynamic` page whose data comes from such a fetch\n   * re-rendered on every request and still served the same body forever.\n   * Measured against next.js's `test/e2e/app-dir/revalidate-path-with-rewrites`.\n   *\n   * `cacheKey` is the key the entry was read under. A response entry found\n   * stale is remembered by it, for `set` to invalidate CloudFront again once\n   * its regeneration lands: see {@link softRevalidatedKeys}.\n   */\n  async isRevalidated(\n    entry: { lastModified?: number; tags?: string[]; value?: unknown },\n    ctx: GetIncrementalFetchCacheContext | GetIncrementalResponseCacheContext,\n    cacheKey: string,\n  ): Promise<boolean> {\n    if (!this.config.tableName) {\n      return false;\n    }\n    const checkTags = isFetchCacheGet(ctx)\n      ? [...(ctx.tags ?? []), ...(ctx.softTags ?? [])]\n      : entryTags(entry);\n    if (checkTags.length === 0) {\n      return false;\n    }\n    const state = await this.checkIfRevalidated(\n      entry.lastModified ?? 0,\n      checkTags,\n    );\n    if (state === \"stale\" && !isFetchCacheGet(ctx)) {\n      this.noteSoftRevalidated(cacheKey);\n    }\n    return state === \"expired\";\n  }\n\n  /**\n   * Remember that `cacheKey` was served stale, when there is a distribution\n   * whose copy of it will need invalidating again. See\n   * {@link softRevalidatedKeys}.\n   */\n  private noteSoftRevalidated(cacheKey: string): void {\n    if (!this.invalidatesCdn) {\n      return;\n    }\n    this.softRevalidatedKeys.delete(cacheKey);\n    if (this.softRevalidatedKeys.size >= MAX_SOFT_REVALIDATED_KEYS) {\n      // Insertion order: the first key is the one waiting longest.\n      const oldest = this.softRevalidatedKeys.values().next().value;\n      if (oldest !== undefined) {\n        this.softRevalidatedKeys.delete(oldest);\n      }\n    }\n    this.softRevalidatedKeys.add(cacheKey);\n  }\n\n  async set(\n    cacheKey: string,\n    data: IncrementalCacheValue | null,\n    ctx: SetIncrementalFetchCacheContext | SetIncrementalResponseCacheContext,\n  ): Promise<void> {\n    try {\n      if (!data) {\n        // Delete from S3 and DynamoDB\n        this.debug(`S3 CACHE DELETE: ${cacheKey}`);\n\n        if (!this.config.bucketName) {\n          return;\n        }\n\n        // The entry is gone, so there is no regeneration left to wait for.\n        this.softRevalidatedKeys.delete(cacheKey);\n\n        // Build S3 key without needing to know the kind\n        const s3Key = this.buildS3Key(cacheKey);\n\n        // Read the entry's tags before the object is gone: they are the only\n        // way to name its mapping rows, whose sort key is `tag#s3Key` and so\n        // cannot be queried from the key side. See `storedEntryTags`.\n        const tags = await this.storedEntryTags(s3Key, ctx);\n\n        await this.s3Client.send(\n          new DeleteObjectCommand({\n            Bucket: this.config.bucketName,\n            Key: s3Key,\n          }),\n        );\n        this.debug(`S3 CACHE DELETED: ${s3Key}`);\n\n        await this.deleteDynamoDBTagMappings(s3Key, tags);\n        return;\n      }\n\n      // `entryTags`, not `getTags(ctx)` alone: for a page or route response\n      // `ctx` carries only `{ cacheControl, isRoutePPREnabled, isFallback }` —\n      // `ResponseCache.set` builds it that way and `IncrementalCache.set`\n      // forwards it unchanged — so the tags live in the render's\n      // `x-next-cache-tags` header and nowhere else. Reading only `ctx` meant no\n      // runtime-rendered page ever got a mapping row, and a page that is not in\n      // the build's tag manifest names none either: a later\n      // `revalidateTag` found nothing to invalidate and CloudFront kept serving\n      // the stale HTML and RSC payload for the whole `s-maxage`. Same source the\n      // read path above already falls back to.\n      const tags = entryTags({ tags: getTags(ctx), value: data });\n      this.debug(\n        `S3 CACHE SET: Key: ${cacheKey}, tags: ${tags.length ? tags : \"none\"}`,\n      );\n\n      if (!this.config.bucketName) {\n        return;\n      }\n\n      const s3Key = this.buildS3Key(cacheKey);\n\n      // Create CacheHandlerValue structure for S3 storage with tags\n      const cacheHandlerValue: CacheHandlerValue = {\n        // On the marker clock, since that is what it is compared with.\n        lastModified: markerClock(),\n        value: data,\n      };\n\n      // Store tags with the cache entry for revalidation checking\n      const cacheEntryWithTags = {\n        ...cacheHandlerValue,\n        tags,\n      };\n\n      // Serialize with custom handling for Map and Buffer objects\n      const body = serializeCacheValue(cacheEntryWithTags);\n\n      // Always JSON since we store CacheHandlerValue\n      await this.bucket.putJson(s3Key, body);\n\n      this.debug(`S3 CACHE STORED: ${cacheKey} (${data.kind})`);\n\n      // The regeneration of an entry served stale: CloudFront may have cached\n      // that stale response after `revalidateTag`'s invalidation, so the key's\n      // paths go once more now that S3 holds the fresh one.\n      if (this.softRevalidatedKeys.delete(cacheKey)) {\n        const route = this.s3KeyToInvalidationPath(s3Key);\n        if (route !== undefined) {\n          this.debug(`SOFT REVALIDATION REGENERATED: ${cacheKey}`);\n          await this.invalidateCloudFrontPaths(\n            cdnInvalidationPaths(route, this.cloudFrontConfig.basePath),\n          );\n        }\n      }\n\n      // Store tag-to-cache-key mappings in DynamoDB for revalidation\n      if (tags.length > 0 && this.mapsTagsToPaths) {\n        this.debug(`STORING TAGS: ${cacheKey} -> [${tags.join(\", \")}]`);\n        await this.storeDynamoDBTagMappings(s3Key, tags);\n      }\n    } catch (error) {\n      console.error(\"Error storing cache to S3:\", error);\n    }\n  }\n\n  async revalidateTag(\n    tag: string | string[],\n    durations?: RevalidateDurations,\n  ): Promise<void> {\n    const tags = Array.isArray(tag) ? tag : [tag];\n    this.debug(`REVALIDATING TAGS: [${tags.join(\", \")}]`);\n\n    if (!this.config.tableName) {\n      return;\n    }\n\n    // Record the revalidation against each tag itself, not only against the\n    // cache keys already mapped to it: `checkIfRevalidated` reads these marker\n    // rows, and a build-time prerender has no mapping rows at all.\n    const recorded = await this.tags.update(tags, durations);\n\n    if (!this.mapsTagsToPaths) {\n      return;\n    }\n\n    const { basePath } = this.cloudFrontConfig;\n    if (!recorded) {\n      // Other instances may never learn of this revalidation, so no path list\n      // is enough: drop the whole app from CloudFront rather than serve stale\n      // pages until their TTL.\n      await this.invalidateCloudFrontPaths(wholeAppInvalidationPaths(basePath));\n      return;\n    }\n\n    // Settled rather than `all`: one tag's throttled Query must not drop the\n    // CloudFront paths every other tag resolved.\n    const results = await Promise.allSettled(\n      tags.map((t) => this.tagRoutes(t)),\n    );\n    const routes: string[] = [];\n    let wholeApp = false;\n    for (const result of results) {\n      if (result.status === \"rejected\") {\n        console.error(\"Error reading tag mappings:\", result.reason);\n        // The tag's entries are revalidated at the origin while nothing names\n        // their CloudFront paths. The same answer as a tag cut short by\n        // `MAX_TAG_QUERY_PAGES`: the whole app, never a stale page.\n        wholeApp = true;\n        continue;\n      }\n      routes.push(...result.value.routes);\n      wholeApp ||= result.value.truncated;\n    }\n\n    // Invalidate the CDN edge cache so CloudFront-fronted deployments don't\n    // keep serving stale responses until the cache policy's TTL naturally\n    // expires. One request for every tag at once: see\n    // `MAX_WILDCARD_PATHS_PER_INVALIDATION` for why never several.\n    await this.invalidateCloudFrontPaths(\n      wholeApp\n        ? wholeAppInvalidationPaths(basePath)\n        : routes.flatMap((route) => cdnInvalidationPaths(route, basePath)),\n    );\n  }\n\n  /**\n   * The routes CloudFront could be holding a response for `tag` under -\n   * `truncated` when they could not all be named: more mapping rows than\n   * {@link MAX_TAG_QUERY_PAGES}, or no build tag manifest to read.\n   */\n  private async tagRoutes(\n    tag: string,\n  ): Promise<{ routes: string[]; truncated: boolean }> {\n    const [{ items, truncated }, buildTags] = await Promise.all([\n      this.queryTagMappings(tag),\n      this.buildTagManifest(),\n    ]);\n    // Extract S3 keys from sort keys (format: \"tag#s3Key\"). Split at the tag's\n    // own length rather than at the first \"#\": a tag is app-defined and may\n    // contain one, and `revalidateTag(\"user#42\")` then yielded\n    // \"42#<buildId>/account.json\" — whose invalidation path\n    // (\"/42#<buildId>/account\") names nothing CloudFront cached, so the edge\n    // kept serving the stale page.\n    //\n    // The same `#` makes `begins_with(sk, \"user#\")` match rows that are not\n    // `user`'s at all: the marker row of tag `user#42` (sk `user#42`) and every\n    // mapping row of it (`user#42#<buildId>/…`). What is left after the prefix\n    // is an S3 key only if it starts with the build's own prefix, which is how\n    // `buildS3Key` writes every one.\n    const prefixLength = tag.length + 1;\n    const keyPrefix = this.config.buildId ? `${this.config.buildId}/` : \"\";\n    const s3Keys = items\n      .map((item) => item.sk?.S?.slice(prefixLength))\n      .filter((s3Key): s3Key is string =>\n        Boolean(s3Key && s3Key.startsWith(keyPrefix)),\n      );\n    // The build-time prerenders carrying the tag, which no `set` wrote a row\n    // for.\n    for (const cacheKey of buildTags?.get(tag) ?? []) {\n      s3Keys.push(this.buildS3Key(cacheKey));\n    }\n\n    this.debug(\n      `TAG ${tag}: Found ${s3Keys.length} cache entries to invalidate`,\n    );\n\n    // The mapping rows themselves are deliberately left alone. Stamping\n    // `revalidatedAt` on each `tag#cacheKey` row is what this used to do, and\n    // nothing has read that attribute since `checkIfRevalidated` began reading\n    // the bare-tag marker row written above — so the writes were dead, and they\n    // were dead *in front of* the invalidation. One throttled `UpdateItem`\n    // rejected the batch, the CloudFront invalidation never ran, and the only\n    // trace was a `console.error` while the edge kept serving the stale page.\n    //\n    // Deliberately not deleting the tag's S3 objects either. The marker row\n    // above is what invalidates them: `get` compares it against each entry's\n    // own `lastModified` and hands the entry back expired, which is the signal\n    // that makes Next.js re-render *this* route and store the result (see\n    // `EXPIRED_LAST_MODIFIED`). Deleting the object instead turned the next\n    // request into a hard miss, and a hard miss on a PPR route is answered from\n    // the route's fallback shell — uncacheable, and never upgraded back into a\n    // concrete entry, so one `revalidateTag` left the page resuming\n    // dynamically for good.\n    const routes = s3Keys\n      .map((s3Key) => this.s3KeyToInvalidationPath(s3Key))\n      .filter((route): route is string => route !== undefined);\n    // A `revalidatePath` names its path in the tag itself, which is the only\n    // way to reach a build-time prerender's CDN copy when it has no mapping\n    // row.\n    routes.push(...implicitTagPaths(tag));\n    return { routes, truncated: truncated || !buildTags };\n  }\n\n  /**\n   * The build-time prerenders' cache keys by tag ({@link INIT_CACHE_TAG_MANIFEST}),\n   * read from the cache bucket once per instance, or `undefined` when that\n   * failed, to be read again next time. A prerender is written by the adapter,\n   * never through `set`, so this is the only record of which tags name its\n   * CloudFront paths, and it is served with a year-long `s-maxage`.\n   */\n  private buildTagManifest(): Promise<Map<string, string[]> | undefined> {\n    this.buildTags ??= this.bucket\n      .get(`${this.config.buildId}/${INIT_CACHE_TAG_MANIFEST}`)\n      // None is normal: only tagged prerenders write one.\n      .then((object) => new Map(Object.entries(JSON.parse(object ?? \"{}\"))));\n    return this.buildTags.catch((error) => {\n      this.buildTags = undefined;\n      console.warn(\"Could not read the build's tag manifest:\", error);\n      return undefined;\n    });\n  }\n\n  /**\n   * Every mapping row for `tag`, following `LastEvaluatedKey`, and whether\n   * {@link MAX_TAG_QUERY_PAGES} cut the walk short.\n   *\n   * DynamoDB caps a Query at 1 MB of items regardless of how many match, and\n   * there is one row per tagged entry a runtime `set` wrote, so a large site\n   * passes 1 MB on a common tag. Stopping at the\n   * first page invalidates only that page's entries while still reporting\n   * success, which is indistinguishable from revalidation having worked.\n   */\n  private async queryTagMappings(\n    tag: string,\n  ): Promise<{ items: Record<string, AttributeValue>[]; truncated: boolean }> {\n    const items: Record<string, AttributeValue>[] = [];\n    let exclusiveStartKey: Record<string, AttributeValue> | undefined;\n    let pages = 0;\n\n    do {\n      const response = await this.dynamoClient.send(\n        new QueryCommand({\n          TableName: this.config.tableName,\n          KeyConditionExpression: \"pk = :pk AND begins_with(sk, :skPrefix)\",\n          ExpressionAttributeValues: {\n            \":pk\": { S: this.config.buildId },\n            \":skPrefix\": { S: `${tag}#` },\n          },\n          ExclusiveStartKey: exclusiveStartKey,\n        }),\n      );\n      items.push(...(response.Items ?? []));\n      exclusiveStartKey = response.LastEvaluatedKey;\n      pages++;\n    } while (exclusiveStartKey && pages < MAX_TAG_QUERY_PAGES);\n\n    const truncated = exclusiveStartKey !== undefined;\n    if (truncated) {\n      console.warn(\n        `Stopped paginating tag \"${tag}\" after ${pages} pages ` +\n          `(${items.length} entries); invalidating the whole app instead.`,\n      );\n    }\n    return { items, truncated };\n  }\n\n  /**\n   * Reverses `buildS3Key` to recover the route the response was cached for, for\n   * {@link cdnInvalidationPaths} to turn into the URIs CloudFront holds it under, or\n   * `undefined` for a key that names no cached URI.\n   *\n   * Two kinds of mapping row do not: a dynamic route template (`blog/[slug].json`,\n   * which the adapter's seeded entries include), and a fetch-cache entry, whose\n   * key is an opaque hash rather than a route. Both would invalidate a URI that\n   * cannot exist, and each one costs one of the fifteen wildcard paths an\n   * invalidation may carry — so they are dropped here rather than crowding out\n   * the real ones.\n   */\n  private s3KeyToInvalidationPath(s3Key: string): string | undefined {\n    const prefix = `${this.config.buildId}/`;\n    const withoutPrefix = s3Key.startsWith(prefix)\n      ? s3Key.slice(prefix.length)\n      : s3Key;\n    const withoutSuffix = withoutPrefix.endsWith(\".json\")\n      ? withoutPrefix.slice(0, -\".json\".length)\n      : withoutPrefix;\n\n    if (withoutSuffix.includes(\"[\") || isFetchCacheKey(withoutSuffix)) {\n      return undefined;\n    }\n    return withoutSuffix === \"index\" ? \"/\" : `/${withoutSuffix}`;\n  }\n\n  /**\n   * Invalidate `paths` in a single request, or the whole app\n   * ({@link wholeAppInvalidationPaths}) when they would not fit in one. See\n   * {@link MAX_WILDCARD_PATHS_PER_INVALIDATION}.\n   */\n  private async invalidateCloudFrontPaths(paths: string[]): Promise<void> {\n    let batch = Array.from(new Set(paths));\n    if (batch.length === 0) {\n      return;\n    }\n\n    const distributionId = await this.getDistributionId().catch((error) => {\n      console.warn(\"Could not resolve the distribution to invalidate:\", error);\n      return null;\n    });\n    if (!distributionId) {\n      return;\n    }\n\n    const wildcards = batch.filter(isWildcardPath).length;\n    if (\n      wildcards > MAX_WILDCARD_PATHS_PER_INVALIDATION ||\n      batch.length > MAX_PATHS_PER_INVALIDATION\n    ) {\n      const wholeApp = wholeAppInvalidationPaths(\n        this.cloudFrontConfig.basePath,\n      );\n      this.debug(\n        `CLOUDFRONT INVALIDATION: ${batch.length} paths (${wildcards} ` +\n          `wildcards) do not fit one request, collapsing to ` +\n          `[${wholeApp.join(\", \")}]`,\n      );\n      batch = wholeApp;\n    }\n\n    for (let attempt = 0; ; attempt++) {\n      this.debug(\n        `CLOUDFRONT INVALIDATION: [${batch.join(\", \")}] on distribution ${distributionId}`,\n      );\n      try {\n        await this.cloudFrontClient.send(\n          new CreateInvalidationCommand({\n            DistributionId: distributionId,\n            InvalidationBatch: {\n              CallerReference: randomUUID(),\n              Paths: {\n                Quantity: batch.length,\n                Items: batch,\n              },\n            },\n          }),\n        );\n        return;\n      } catch (error) {\n        if (isInvalidationQuotaError(error) && attempt < INVALIDATION_RETRIES) {\n          // See `INVALIDATION_RETRIES`.\n          batch = wholeAppInvalidationPaths(this.cloudFrontConfig.basePath);\n          await new Promise((resolve) =>\n            setTimeout(resolve, INVALIDATION_RETRY_DELAY_MS * 2 ** attempt),\n          );\n          continue;\n        }\n        // Log but don't fail - the S3/DynamoDB invalidation already succeeded,\n        // and the CloudFront cache policy TTL provides an eventual fallback.\n        console.warn(\n          `Failed to create CloudFront invalidation for [${batch.join(\", \")}]:`,\n          error,\n        );\n        return;\n      }\n    }\n  }\n\n  /**\n   * The distribution's physical ID, from the environment or else SSM Parameter\n   * Store, cached for the lifetime of this instance. See\n   * `CloudFrontInvalidationConfig` for why Functions need the indirection.\n   */\n  private async getDistributionId(): Promise<string | null> {\n    if (this.cloudFrontConfig.distributionId) {\n      return this.cloudFrontConfig.distributionId;\n    }\n    if (this.cachedDistributionId) {\n      return this.cachedDistributionId;\n    }\n\n    if (!this.cloudFrontConfig.distributionIdParameterName) {\n      return null;\n    }\n\n    const response = await this.ssmClient.send(\n      new GetParameterCommand({\n        Name: this.cloudFrontConfig.distributionIdParameterName,\n      }),\n    );\n\n    this.cachedDistributionId = response.Parameter?.Value || null;\n    return this.cachedDistributionId;\n  }\n\n  async resetRequestCache(): Promise<void> {\n    // This handler doesn't maintain request-level cache state\n    // The actual cache clearing is handled by the memory cache handler\n  }\n\n  /**\n   * Whether this deployment keeps `tag#s3Key` mapping rows at all.\n   *\n   * Their one reader is `revalidateTag`'s CloudFront invalidation, which needs\n   * the entries' paths - tag revalidation itself runs on the bare-tag marker\n   * rows. A deployment with no distribution (the Regional constructs) would pay\n   * a DynamoDB write per tag on every `set`, a Query per `revalidateTag`, and an\n   * extra S3 read before every delete, for rows nothing ever reads.\n   */\n  private get mapsTagsToPaths(): boolean {\n    return Boolean(this.config.tableName) && this.invalidatesCdn;\n  }\n\n  /** Whether there is a distribution to invalidate. */\n  private get invalidatesCdn(): boolean {\n    return Boolean(\n      this.cloudFrontConfig.distributionId ||\n      this.cloudFrontConfig.distributionIdParameterName,\n    );\n  }\n\n  /** `{buildId}/{cacheKey}.json`; see {@link buildS3Key}. */\n  private buildS3Key(cacheKey: string): string {\n    return buildS3Key(this.config.buildId, cacheKey);\n  }\n\n  private async storeDynamoDBTagMappings(\n    s3Key: string,\n    tags: string[],\n  ): Promise<void> {\n    try {\n      const updatePromises = tags.map(async (tag) => {\n        const tagCacheKey = `${tag}#${s3Key}`;\n        const updateCommand = new UpdateItemCommand({\n          TableName: this.config.tableName,\n          Key: {\n            pk: { S: this.config.buildId },\n            sk: { S: tagCacheKey },\n          },\n          // Deliberately no `revalidatedAt`: a mapping row records only that an\n          // entry carries the tag. Stamping it at write time made every tagged\n          // entry look revalidated one millisecond after it was stored — the\n          // row's timestamp is taken after the entry's `lastModified` — so\n          // `checkIfRevalidated` deleted healthy entries and the page\n          // re-rendered on every request.\n          UpdateExpression: \"SET createdAt = if_not_exists(createdAt, :now)\",\n          ExpressionAttributeValues: {\n            \":now\": { N: Date.now().toString() },\n          },\n        });\n\n        await this.dynamoClient.send(updateCommand);\n      });\n\n      await Promise.all(updatePromises);\n    } catch (error) {\n      console.error(\"Error storing DynamoDB tag mappings:\", error);\n      // Don't throw - cache storage should continue even if tag mapping fails\n    }\n  }\n\n  /**\n   * Drop the `tag#s3Key` mapping rows for an entry that no longer exists.\n   *\n   * The counterpart of {@link storeDynamoDBTagMappings}, and the reason its\n   * caller has to know the entry's tags: a mapping row's sort key starts with\n   * the tag, so the rows belonging to one cache key cannot be queried for - only\n   * a full scan of the build's partition would find them.\n   *\n   * Left behind, a row still resolves to a cache key on the next\n   * `revalidateTag`, which spends one of CloudFront's fifteen wildcard paths\n   * invalidating a URI whose entry was deleted - crowding out the paths that do\n   * need it, and past {@link MAX_WILDCARD_PATHS_PER_INVALIDATION} collapsing the\n   * whole app into one wildcard. The rows also count against the 1 MB a tag's Query returns, so\n   * enough of them push live entries onto a page\n   * {@link MAX_TAG_QUERY_PAGES} may not reach.\n   *\n   * Only the mapping rows: the bare-`tag` marker row `revalidateTag`\n   * writes belongs to the tag rather than to any entry, and `checkIfRevalidated`\n   * reads it for every *other* entry carrying that tag.\n   *\n   * Deliberately no CloudFront invalidation for the deleted path. The edge copy\n   * does outlive the object, but this runs on every revalidated `fetch` entry as\n   * well, where the key names no URI, and an invalidation request per deleted\n   * entry is a cost the TTL already bounds.\n   */\n  private async deleteDynamoDBTagMappings(\n    s3Key: string,\n    tags: string[],\n  ): Promise<void> {\n    if (!this.mapsTagsToPaths || tags.length === 0) {\n      return;\n    }\n    try {\n      await Promise.all(\n        // A page's tags can repeat - `ctx.tags` and the render's header are both\n        // read - and one delete per tag is enough.\n        Array.from(new Set(tags)).map(async (tag) => {\n          await this.dynamoClient.send(\n            new DeleteItemCommand({\n              TableName: this.config.tableName,\n              Key: {\n                pk: { S: this.config.buildId },\n                sk: { S: `${tag}#${s3Key}` },\n              },\n            }),\n          );\n        }),\n      );\n      this.debug(`DELETED TAG MAPPINGS: ${s3Key} -> [${tags.join(\", \")}]`);\n    } catch (error) {\n      // Log but don't fail: the entry itself is already gone, and a stale\n      // mapping row costs an invalidation path rather than a wrong response.\n      console.error(\"Error deleting DynamoDB tag mappings:\", error);\n    }\n  }\n\n  /**\n   * The tags an entry about to be deleted was stored with.\n   *\n   * `ctx` carries them for a `fetch` delete, but a response delete arrives as\n   * `{ cacheControl, isRoutePPREnabled, isFallback }` - `ResponseCache.set`\n   * builds it that way - so the entry itself is the only source, and it has to\n   * be read before it is removed. That is one extra GET on a path that runs when\n   * a cached route starts answering `notFound()`: `IncrementalCache.set`\n   * forwards `ResponseCache`'s null value through to here.\n   *\n   * A page is also the case worth paying it for, since it carries the whole\n   * implicit `_N_T_/…` chain and therefore the most rows.\n   */\n  private async storedEntryTags(\n    s3Key: string,\n    ctx: SetIncrementalFetchCacheContext | SetIncrementalResponseCacheContext,\n  ): Promise<string[]> {\n    const ctxTags = getTags(ctx);\n    if (ctxTags?.length) {\n      return ctxTags;\n    }\n    if (!this.mapsTagsToPaths) {\n      return [];\n    }\n    try {\n      const response = await this.bucket.get(s3Key);\n      if (!response) {\n        return [];\n      }\n      return entryTags(parseCacheValue(response));\n    } catch (error) {\n      console.warn(`Failed to read tags of ${s3Key} before deleting:`, error);\n      return [];\n    }\n  }\n\n  /**\n   * Whether any of `tags` was revalidated after this entry was stored, and how.\n   *\n   * Reads the per-tag marker rows `revalidateTag` writes, as this instance\n   * tracks them: see `TrackedTagMarkers` for when they are read.\n   * Scanning the tag's mapping rows instead would answer the wrong question:\n   * those rows exist per cache *key*, so which one a `Limit: 1` query returned\n   * depended on sort order, and an entry could be judged against another\n   * entry's timestamp.\n   *\n   * A tag revalidated with a profile only makes the entry *stale*: that is\n   * reported to Next.js through its tag manifest (see {@link nextTagsManifest})\n   * and answered `\"stale\"` here, so the entry is served while a background\n   * render replaces it. When the manifest cannot be reached a stale entry is\n   * reported expired instead - a blocking render, never a stale page presented\n   * as fresh.\n   */\n  private async checkIfRevalidated(\n    cacheLastModified: number,\n    tags: string[],\n  ): Promise<RevalidationState> {\n    await this.tags.refresh();\n    await this.tags.ensure(tags);\n    const state = this.tags.state(tags, cacheLastModified);\n    if (state !== \"stale\") {\n      if (state === \"expired\") {\n        this.debug(\n          `Tags [${tags}] expired entry created at ${cacheLastModified}`,\n        );\n      }\n      return state;\n    }\n\n    const manifest = nextTagsManifest();\n    if (!manifest) {\n      this.debug(\n        `Tags [${tags}] are stale and Next.js's tag manifest is ` +\n          `unreachable, expiring the entry instead`,\n      );\n      return \"expired\";\n    }\n    for (const tag of tags) {\n      const staleAt = this.tags.get(tag)?.staleAt;\n      const existing = manifest.get(tag);\n      if (\n        staleAt !== undefined &&\n        staleAt > cacheLastModified &&\n        (existing?.stale ?? 0) < staleAt\n      ) {\n        manifest.set(tag, { ...existing, stale: staleAt });\n      }\n    }\n    return \"stale\";\n  }\n}\n"]}