cdk-nextjs 0.7.5 → 0.7.7

package/lib/adapter/aws-cache-store.js

@@ -1,14 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CacheBucket = exports.TrackedTagMarkers = exports.DEFAULT_MAX_TRACKED_TAGS = exports.MAX_REVALIDATION_LOG_GAP_MS = exports.DEFAULT_TAG_RESYNC_MS = exports.REVALIDATION_LOG_LOOKBACK_MS = exports.RevalidationLog = exports.REVALIDATION_LOG_MAX_PAGES = exports.REVALIDATION_LOG_TTL_MS = exports.TagMarkerTable = exports.DEFAULT_TAG_REFRESH_MS = exports.BATCH_GET_MAX_KEYS = exports.USE_CACHE_KEY_PREFIX = void 0;
+exports.CacheBucket = exports.TrackedTagMarkers = exports.DEFAULT_MAX_TRACKED_TAGS = exports.MAX_REVALIDATION_LOG_GAP_MS = exports.DEFAULT_TAG_RESYNC_MS = exports.REVALIDATION_LOG_LOOKBACK_MS = exports.RevalidationLog = exports.REVALIDATION_LOG_MAX_PAGES = exports.REVALIDATION_LOG_TTL_MS = exports.TagMarkerTable = exports.MAX_TAG_BYTES = exports.MAX_SORT_KEY_BYTES = exports.TAG_REFRESH_GRACE_MS = exports.DEFAULT_TAG_REFRESH_MS = exports.BATCH_GET_MAX_KEYS = exports.USE_CACHE_KEY_PREFIX = void 0;
 exports.resolveAwsCacheConfig = resolveAwsCacheConfig;
 exports.buildS3Key = buildS3Key;
+exports.s3ObjectKey = s3ObjectKey;
 exports.useCacheS3Key = useCacheS3Key;
 exports.markerState = markerState;
 exports.markerClock = markerClock;
 exports.markerFor = markerFor;
 exports.applyMarker = applyMarker;
 exports.markerUpdate = markerUpdate;
+exports.hashedTag = hashedTag;
+exports.sortKeyTag = sortKeyTag;
 exports.mergeMarkers = mergeMarkers;
 /*
   The S3 / DynamoDB plumbing shared by every cdk-nextjs cache handler: the
@@ -21,9 +24,11 @@ exports.mergeMarkers = mergeMarkers;
   kinds of handler, and they must read each other's markers the same way.
 */
 /* eslint-disable import/no-extraneous-dependencies */
+const node_async_hooks_1 = require("node:async_hooks");
 const node_path_1 = require("node:path");
 const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
 const client_s3_1 = require("@aws-sdk/client-s3");
+const cache_utils_1 = require("./cache-utils");
 /** The configuration from the environment. */
 function resolveAwsCacheConfig() {
     return {
@@ -41,14 +46,11 @@ function resolveAwsCacheConfig() {
  * which is what keeps it disjoint from {@link useCacheS3Key}.
  */
 function buildS3Key(buildId, cacheKey) {
-    let cleanCacheKey = cacheKey;
-    if (cacheKey === "/" || cacheKey === "") {
-        cleanCacheKey = "index";
-    }
-    else if (cacheKey.startsWith("/")) {
-        cleanCacheKey = cacheKey.slice(1);
-    }
-    return (0, node_path_1.join)(buildId, `${cleanCacheKey}.json`);
+    return (0, node_path_1.join)(buildId, (0, cache_utils_1.cacheKeyFileName)(cacheKey));
+}
+/** `{buildId}/` + {@link cacheObjectName}: the S3 object an entry is stored in. */
+function s3ObjectKey(buildId, cacheKey) {
+    return (0, node_path_1.join)(buildId, (0, cache_utils_1.cacheObjectName)(cacheKey));
 }
 /**
  * The folder under the build prefix that `'use cache'` entries are stored in.
@@ -61,8 +63,9 @@ exports.USE_CACHE_KEY_PREFIX = "_use-cache";
  * Hashed because a `'use cache'` key is the serialized arguments of the call and
  * has no length limit, where an S3 key stops at 1024 bytes. The `.entry` suffix
  * rather than `.json` is what makes a collision with the incremental cache
- * impossible rather than unlikely: every key {@link buildS3Key} writes ends in
- * `.json`, including one for a route that happens to be named `/_use-cache/…`.
+ * impossible rather than unlikely: every object {@link s3ObjectKey} names ends
+ * in `.json` or `.long`, including one for a route that happens to be named
+ * `/_use-cache/…`.
  * Still under the build prefix, so post-deploy pruning drops them with the build.
  */
 function useCacheS3Key(buildId, keyHash) {
@@ -162,9 +165,40 @@ exports.BATCH_GET_MAX_KEYS = 100;
  * revalidation log, the reads scale with instances instead of requests or tags.
  */
 exports.DEFAULT_TAG_REFRESH_MS = 1000;
+/**
+ * How far past `refreshIntervalMs` the last refresh may have settled before a
+ * `'use cache'` request waits for the next one (see
+ * {@link TrackedTagMarkers.behind}). An instance serving steady traffic stays
+ * inside it; one that sat idle, or frozen between Lambda invocations, does not.
+ */
+exports.TAG_REFRESH_GRACE_MS = 1000;
+/** DynamoDB's limit on a sort key, in UTF-8 bytes. */
+exports.MAX_SORT_KEY_BYTES = 1024;
+/**
+ * `#<sha256(tag)>`, standing in for a tag in a sort key it would push past
+ * {@link MAX_SORT_KEY_BYTES}. Next.js caps the tags an app names, but not an
+ * implicit `_N_T_/…` tag, which is as long as its path, and a rejected write
+ * left `revalidatePath` on a long path recorded nowhere.
+ */
+function hashedTag(tag) {
+    return `#${(0, cache_utils_1.sha256Hex)(tag)}`;
+}
+/**
+ * The longest tag a sort key spells out; past it, {@link sortKeyTag} hashes
+ * it. One cap for every row the tag is in, so a row's writer and reader agree
+ * without each working out what else shares its key. It leaves room for the
+ * most any row puts beside the tag: a mapping row's `#<buildId>/#<sha256>`,
+ * with the build ID capped at `MAX_BUILD_ID_BYTES`.
+ */
+exports.MAX_TAG_BYTES = 768;
+/** `tag` as a sort key spells it: itself, or {@link hashedTag} past {@link MAX_TAG_BYTES}. */
+function sortKeyTag(tag) {
+    return Buffer.byteLength(tag) <= exports.MAX_TAG_BYTES ? tag : hashedTag(tag);
+}
 /**
  * The bare-tag marker rows of the revalidation table (`pk = buildId`,
- * `sk = tag`), which record when a tag was last revalidated and how.
+ * `sk = tag`, or {@link hashedTag} past {@link MAX_TAG_BYTES}), which record when a tag
+ * was last revalidated and how.
  *
  * The table also holds the incremental cache's `tag#s3Key` mapping rows, which
  * are its own business and stay in `S3CacheHandler`: only the markers mean the
@@ -192,7 +226,7 @@ class TagMarkerTable {
             TableName: this.tableName,
             Key: {
                 pk: { S: this.buildId },
-                sk: { S: tag },
+                sk: { S: sortKeyTag(tag) },
             },
             ...markerUpdate(now, durations),
             ReturnValues: "ALL_NEW",
@@ -211,9 +245,11 @@ class TagMarkerTable {
         const unique = Array.from(new Set(tags));
         const markers = new Map();
         for (let i = 0; i < unique.length; i += exports.BATCH_GET_MAX_KEYS) {
-            let keys = unique
+            // A hashed sort key names no tag, so each row is matched back by key.
+            const tagBySk = new Map(unique
                 .slice(i, i + exports.BATCH_GET_MAX_KEYS)
-                .map((tag) => ({ pk: { S: buildId }, sk: { S: tag } }));
+                .map((tag) => [sortKeyTag(tag), tag]));
+            let keys = Array.from(tagBySk.keys(), (sk) => ({ pk: { S: buildId }, sk: { S: sk } }));
             // `UnprocessedKeys` is DynamoDB declining part of the batch under load;
             // a marker left unread is a revalidation missed, so it is asked again.
             for (let attempt = 0; keys?.length && attempt < 3; attempt++) {
@@ -226,7 +262,7 @@ class TagMarkerTable {
                     },
                 }));
                 for (const item of response.Responses?.[tableName] ?? []) {
-                    const tag = item.sk?.S;
+                    const tag = tagBySk.get(item.sk?.S ?? "");
                     if (tag !== undefined) {
                         markers.set(tag, markerOf(item));
                     }
@@ -257,7 +293,8 @@ const LOG_SK_DIGITS = 15;
 /**
  * The revalidation log: one row per tag revalidation (`pk = <buildId>#log`,
  * `sk = <Date.now(), zero-padded>#<tag>`), which expires after
- * {@link REVALIDATION_LOG_TTL_MS}.
+ * {@link REVALIDATION_LOG_TTL_MS}. A tag past {@link MAX_TAG_BYTES} is
+ * {@link hashedTag} there, and spelled out in the row's `longTag` instead.
  *
  * The marker rows stay the source of truth. The log exists so an instance
  * can ask "what was revalidated since I last looked?" in one `Query`, instead
@@ -288,11 +325,13 @@ class RevalidationLog {
      * to {@link LOG_PUT_ATTEMPTS} times.
      */
     async put(tag, at, marker) {
+        const skTag = sortKeyTag(tag);
         for (let attempt = 1;; attempt++) {
             const item = {
                 pk: { S: this.pk },
-                sk: { S: `${logSkPrefix(at)}#${tag}` },
+                sk: { S: `${logSkPrefix(at)}#${skTag}` },
                 ttl: { N: String(Math.ceil((at + exports.REVALIDATION_LOG_TTL_MS) / 1000)) },
+                ...(skTag !== tag && { longTag: { S: tag } }),
             };
             for (const field of MARKER_FIELDS) {
                 const value = marker[field];
@@ -337,7 +376,7 @@ class RevalidationLog {
                     ":pk": { S: this.pk },
                     ":since": { S: logSkPrefix(Math.max(0, since)) },
                 },
-                ProjectionExpression: "sk, revalidatedAt, staleAt, expiredAt",
+                ProjectionExpression: "sk, longTag, revalidatedAt, staleAt, expiredAt",
                 ExclusiveStartKey: startKey,
             }));
             for (const item of response.Items ?? []) {
@@ -350,7 +389,7 @@ class RevalidationLog {
                 rows.push({
                     sk,
                     at: Number(sk.slice(0, LOG_SK_DIGITS)),
-                    tag: sk.slice(LOG_SK_DIGITS + 1),
+                    tag: item.longTag?.S ?? sk.slice(LOG_SK_DIGITS + 1),
                     marker: markerOf(item),
                 });
             }
@@ -433,15 +472,19 @@ exports.DEFAULT_MAX_TRACKED_TAGS = 10_000;
  * The cost is bounded per instance, not per request:
  * - {@link ensure} reads a tag's marker the first time it is needed and not
  *   again until it is evicted, so a tag costs one read per instance, not one
- *   per request.
+ *   per request. An entry created since {@link completeSince} needs no read
+ *   at all.
  * - {@link refresh}, at most once per `refreshIntervalMs`, sends one `Query`
  *   for the log rows written since the last one, and applies those of tags
  *   this instance tracks. Concurrent callers share it. Alongside, it re-reads
  *   the markers of up to {@link BATCH_GET_MAX_KEYS} tags not read for
  *   {@link DEFAULT_TAG_RESYNC_MS}, in one `BatchGetItem`.
  * A revalidation on another instance is therefore seen within
- * `refreshIntervalMs` (plus the query itself). The instance that ran it applies
- * it itself, at once, with {@link set}.
+ * `refreshIntervalMs` (plus the query itself) - by `'use cache'`, from the
+ * first request after the query returns, since its `refreshTags` does not wait
+ * for it (see `tagMethods`) unless the instance is {@link behind}, which the
+ * runtime settles before a page render starts ({@link catchUp}). The instance
+ * that ran it applies it itself, at once, with {@link set}.
  */
 class TrackedTagMarkers {
     markers;
@@ -467,10 +510,64 @@ class TrackedTagMarkers {
      * result rather than dropped.
      */
     pendingRows = new Map();
+    /**
+     * Log rows for tags not tracked and not being read, merged by tag, oldest
+     * first: what the log has said about them since {@link completeSince}. Taken
+     * into a tag's marker when it is read or written.
+     */
+    logOnly = new Map();
+    /** See {@link completeSince}. */
+    floor;
+    /**
+     * The future `expiredAt`s of markers dropped since, as `[from, to]`, in
+     * order: once `from` is past, {@link completeSince} moves to `to`, and not
+     * before, since only then does it expire anything. `from` and `to` are the
+     * same until spans are merged for space ({@link laterFloor}).
+     */
+    laterFloors = [];
+    /** The in-memory entry stores judged by {@link completeSince}. */
+    entryStores = [];
+    /** How many times {@link forget} ran: a read started before one is made again. */
+    forgotten = 0;
     /** Tracked tags whose read failed, for the next refresh to read again. */
     unread = new Set();
+    /**
+     * Set inside a page render {@link catchUp} let go, for that render alone.
+     * See {@link behindInRender}.
+     */
+    caughtUpRender = new node_async_hooks_1.AsyncLocalStorage();
+    /** When `sync` last scanned the entry stores ({@link oldestEntry}). */
+    lastEntryScan = -Infinity;
+    /**
+     * No `logOnly` row is known by it or earlier, so a {@link pruneLogged}
+     * against it or earlier drops nothing: a marker is only ever known by later,
+     * as its `expiredAt` passes.
+     */
+    prunedAgainst = -Infinity;
+    /** When the last refresh started, or was skipped. */
     lastRefresh = -Infinity;
+    /**
+     * The refresh in flight. One left open across a freeze comes back after the
+     * thaw with what it read before, so {@link refresh} waits for it and then
+     * for a fresh one, rather than the runtime waiting for it before the freeze:
+     * that would bill every Lambda invocation for the query's tail.
+     */
     refreshing;
+    /**
+     * When {@link refreshing} last showed the process running: a timer ticks
+     * while it is in flight, and a tick that comes late, or none at all, means
+     * the process was paused - frozen - since it started.
+     */
+    lastTick = -Infinity;
+    /** Whether a tick came late since {@link refreshing} started. */
+    pausedWhileRefreshing = false;
+    ticker;
+    canFreeze;
+    /**
+     * When the last refresh settled, either way, unless it spanned a pause: what
+     * it knows is from then. See {@link behind}.
+     */
+    settledAt;
     /**
      * Where the next log query starts (`clock()`): the last successful one's
      * start, less {@link REVALIDATION_LOG_LOOKBACK_MS}.
@@ -494,22 +591,70 @@ class TrackedTagMarkers {
         this.clock = options.clock ?? (() => Date.now());
         this.random = options.random ?? Math.random;
         this.debug = options.debug ?? (() => { });
+        this.canFreeze = options.canFreeze ?? false;
         // Nothing is tracked yet, so nothing before this can be missed: every tag
         // is read from its marker the first time it is needed.
         const at = this.clock();
         this.cursor = at - exports.REVALIDATION_LOG_LOOKBACK_MS;
         this.lastLogRead = at;
+        this.settledAt = at;
+        this.floor = markerClock();
     }
     /** `tag`'s marker as this instance knows it, if it tracks `tag`. */
     get(tag) {
         return this.tags.get(tag);
     }
+    /**
+     * Since when (`markerClock()`) this instance knows of every revalidation of
+     * every tag, tracked or not: tracked ones from their markers and the log,
+     * the others from the log alone (`logOnly`). So an entry created at or after
+     * it can be judged by {@link state} and {@link expiration} without
+     * {@link ensure} reading anything - which matters inside a `'use cache'`
+     * lookup, where Next.js waits for the answer and a read pushes the entry out
+     * of the static stage of a staged render.
+     *
+     * Starts at construction: the log is followed from before it. Moves to now
+     * when the tracked markers are forgotten, and past the revalidations of
+     * whatever else it lets go of - a marker evicted for space, a log row
+     * pruned - which are no longer known: to its `expiredAt` only once that is
+     * past, since a profile's `expire` can be a year out, and moving there at
+     * once would turn the read-free path off for the instance's life.
+     *
+     * A row is pruned only once it is no later than every entry held, so that
+     * costs those entries nothing. An entry stored afterwards with an older
+     * `timestamp` - Next.js stamps the start of its generation, which can
+     * outlast a lookback - is older than this too, and is read first.
+     *
+     * It does not cover a revalidation older than the log's first lookback
+     * whose `expiredAt` is still to come, which would expire an entry created
+     * after it. So the `'use cache'` handler reads an entry's tags in the
+     * background as it stores it.
+     */
+    get completeSince() {
+        const at = markerClock();
+        while (this.laterFloors.length > 0 && this.laterFloors[0][0] <= at) {
+            this.floor = Math.max(this.floor, this.laterFloors.shift()[1]);
+        }
+        return this.floor;
+    }
+    /**
+     * Register an in-memory store whose entries are judged by
+     * {@link completeSince}, by the `timestamp` of the oldest entry it holds:
+     * `logOnly` keeps the rows that could still apply to one of them, and no
+     * others. With none registered it keeps nothing. Asked with `scan` false,
+     * `oldestTimestamp` may answer early, but never late, without a scan.
+     */
+    judgeEntriesOf(oldestTimestamp, holdsAny = () => oldestTimestamp(false) < Infinity) {
+        this.entryStores.push({ oldestTimestamp, holdsAny });
+    }
     /**
      * Track `tag` with `marker`: what this instance just wrote, which it knows
      * without reading it back.
      */
     set(tag, marker) {
-        this.remember(tag, marker);
+        const logged = this.logOnly.get(tag);
+        this.logOnly.delete(tag);
+        this.remember(tag, mergeMarkers(marker, logged));
         this.known(tag, this.clock());
     }
     /**
@@ -561,31 +706,117 @@ class TrackedTagMarkers {
         const waits = [];
         const unread = [];
         for (const tag of new Set(tags)) {
+            // Tracked first: a tracked tag in `reading` is only being re-read in
+            // the background (`sync`), which nothing needs to wait for.
             const inFlight = this.reading.get(tag);
-            if (inFlight) {
-                waits.push(inFlight);
-            }
-            else if (this.tags.has(tag)) {
+            if (this.tags.has(tag)) {
                 this.touch(tag);
             }
+            else if (inFlight) {
+                waits.push(inFlight);
+            }
             else {
                 unread.push(tag);
             }
         }
         if (unread.length > 0) {
-            // `readInto` never rejects: a failed read leaves the tags tracked.
-            const read = this.readInto(unread).then(() => {
-                for (const tag of unread) {
-                    this.reading.delete(tag);
-                }
-            });
-            for (const tag of unread) {
-                this.reading.set(tag, read);
-            }
-            waits.push(read);
+            waits.push(this.startRead(unread));
         }
         await Promise.all(waits);
     }
+    /**
+     * {@link readInto} `tags`, as the read of each that whoever needs one of
+     * them next waits on ({@link reading}). Never rejects: a failed read leaves
+     * the tags tracked.
+     */
+    startRead(tags) {
+        const read = this.readInto(tags).then(() => {
+            for (const tag of tags) {
+                this.reading.delete(tag);
+            }
+        });
+        for (const tag of tags) {
+            this.reading.set(tag, read);
+        }
+        return read;
+    }
+    /**
+     * Whether the last refresh settled more than `refreshIntervalMs` plus
+     * {@link TAG_REFRESH_GRACE_MS} ago - one that spanned a freeze counts from
+     * when it started: after the instance sat idle or frozen - or always, with
+     * a `refreshIntervalMs` of `0`. Answering from what it knows then could
+     * serve an entry revalidated elsewhere since, however long ago that was, so
+     * `refreshTags` waits for the refresh, and the runtime waits for it before
+     * a page render starts ({@link catchUp}).
+     *
+     * From when it settled, not when it started, so a slow query the runtime
+     * waited for before the render does not leave the instance behind inside
+     * it. A failed one counts too, so one request does not wait for two: the
+     * same "assume the entry is valid" a failed read answers with, until the
+     * next refresh, at most the interval and the grace later.
+     */
+    get behind() {
+        return (this.log !== undefined &&
+            // `0` asks before every check, so every check waits for the answer.
+            (this.refreshIntervalMs === 0 || this.overdue(this.settledAt)));
+    }
+    /**
+     * {@link behind}, as `refreshTags` asks it: never inside a page's render
+     * {@link catchUp} caught up, since the runtime settled it for that request
+     * before the render started, and a wait inside a `'use cache'` lookup is
+     * what it settled it to avoid - a render crossing the line partway through
+     * would otherwise wait after all. So a revalidation elsewhere can go unseen
+     * for a render's duration on top of the usual window.
+     *
+     * A route handler, which no catch-up precedes, waits at the plain line.
+     */
+    get behindInRender() {
+        return this.refreshIntervalMs !== 0 && this.caughtUpRender.getStore()
+            ? false
+            : this.behind;
+    }
+    /**
+     * Whether a registered store ({@link judgeEntriesOf}) holds any entry: one
+     * a refresh could expire. With none there is nothing to wait for even when
+     * the instance is {@link behind}, since whatever is stored from here on is
+     * newer than what the log would say - which covers the first `'use cache'`
+     * call of a process, which creates the handler inside the render.
+     */
+    get holdsEntries() {
+        return this.entryStores.some((store) => store.holdsAny());
+    }
+    /**
+     * {@link refresh}, waited for when the instance is {@link behind}. The
+     * runtime calls it before handing a page request to Next.js, outside the
+     * staged render whose static stage a wait inside a `'use cache'` lookup
+     * would cut short. Only for the `'use cache'` handler's entries
+     * ({@link judgeEntriesOf}): the other caches wait for the refresh where they
+     * read anyway. Not with a `refreshIntervalMs` of `0` either, where
+     * `refreshTags` asks again regardless. Then `render`, marked as caught up
+     * for ({@link behindInRender}). Rejects only as `render` does.
+     */
+    async catchUp(render) {
+        const log = (error) => console.error("Error refreshing cache tags:", error);
+        if (this.refreshIntervalMs > 0 && this.behind) {
+            if (!this.holdsEntries) {
+                // Not caught up, so no grace: an entry stored meanwhile, by another
+                // request, makes the render's lookups wait at the plain line.
+                return render();
+            }
+            await this.refresh().catch(log);
+        }
+        else if (this.refreshIntervalMs > 0) {
+            // Started, not waited for, as `refreshTags` would: a page that reads
+            // no cache keeps the instance current too, rather than falling behind
+            // and making a later request wait.
+            void this.refresh().catch(log);
+        }
+        return this.caughtUpRender.run(true, render);
+    }
+    /** Whether `at` is more than the interval and the grace ago. */
+    overdue(at) {
+        return this.clock() - at > this.refreshIntervalMs + exports.TAG_REFRESH_GRACE_MS;
+    }
     /**
      * Catch up on revalidations other instances ran, at most once per
      * `refreshIntervalMs`. See {@link TrackedTagMarkers} for the cost.
@@ -596,6 +827,12 @@ class TrackedTagMarkers {
             return;
         }
         if (this.refreshing) {
+            // One started before a freeze read the log as it was then, and says
+            // nothing of what ran meanwhile: an instance behind waits for a fresh
+            // one, after it. One that is merely slow is as fresh as any.
+            if (this.behind && this.pausedSinceRefreshStarted()) {
+                return this.refreshing.then(() => this.refresh());
+            }
             return this.refreshing;
         }
         const at = this.clock();
@@ -604,15 +841,55 @@ class TrackedTagMarkers {
         }
         this.lastRefresh = at;
         // Whatever gets tracked before the next refresh is read from its marker,
-        // so there is nothing to catch up on yet.
-        if (this.tags.size === 0) {
+        // so there is nothing to catch up on yet - unless an entry is judged by
+        // `completeSince`, which relies on the log for every tag. Even with none
+        // held: a row let go of then moves `completeSince` past it, for an entry
+        // whose generation started before that revalidation and that is stored
+        // after it.
+        if (this.tags.size === 0 && this.entryStores.length === 0) {
             return;
         }
+        this.startTicking();
         this.refreshing = this.sync(at, log).finally(() => {
+            // One that spanned a pause knows the log as of its start at best. So
+            // does one that only looked paused, its event loop held up: it counts
+            // as no older than its start, as if it had not settled since.
+            this.settledAt = Math.max(this.settledAt, this.pausedSinceRefreshStarted() ? this.lastRefresh : this.clock());
+            this.stopTicking();
             this.refreshing = undefined;
         });
         return this.refreshing;
     }
+    startTicking() {
+        if (!this.canFreeze) {
+            return;
+        }
+        this.lastTick = this.clock();
+        this.pausedWhileRefreshing = false;
+        this.ticker = setInterval(() => {
+            const at = this.clock();
+            if (at - this.lastTick > REFRESH_PAUSE_MS) {
+                this.pausedWhileRefreshing = true;
+            }
+            this.lastTick = at;
+        }, REFRESH_TICK_MS);
+        // Never what keeps a process alive.
+        this.ticker.unref?.();
+    }
+    stopTicking() {
+        clearInterval(this.ticker);
+        this.ticker = undefined;
+    }
+    /**
+     * Whether the process was paused since {@link refreshing} started: a tick
+     * came late, or the next one is overdue (after a thaw, a request can run
+     * before the timer does).
+     */
+    pausedSinceRefreshStarted() {
+        return (this.canFreeze &&
+            (this.pausedWhileRefreshing ||
+                this.clock() - this.lastTick > REFRESH_PAUSE_MS));
+    }
     /**
      * Record a revalidation of `tags`: here at once, and in the revalidation
      * table for every other instance - the marker row plus a log row per tag.
@@ -650,7 +927,7 @@ class TrackedTagMarkers {
         const at = markerClock();
         let state = "fresh";
         for (const tag of tags) {
-            const marker = this.get(tag);
+            const marker = this.knownMarker(tag);
             if (!marker) {
                 continue;
             }
@@ -674,7 +951,7 @@ class TrackedTagMarkers {
         const at = markerClock();
         let latest = 0;
         for (const tag of tags) {
-            const marker = this.get(tag);
+            const marker = this.knownMarker(tag);
             if (!marker) {
                 continue;
             }
@@ -756,13 +1033,17 @@ class TrackedTagMarkers {
             this.forget(at, "the revalidation log may not cover the gap since it was last read");
             return;
         }
-        const [result] = await Promise.all([
-            log.query(this.cursor).catch((error) => {
-                console.error("Error reading tag revalidation log:", error);
-                return undefined;
-            }),
-            this.readInto(this.due(at)),
-        ]);
+        // The rolling re-read runs alongside, not waited for: catching up needs
+        // only the log, and a throttled `BatchGetItem` should not hold the
+        // request `catchUp` makes wait. A forget meanwhile reads it again.
+        const due = this.due(at);
+        if (due.length > 0) {
+            void this.startRead(due);
+        }
+        const result = await log.query(this.cursor).catch((error) => {
+            console.error("Error reading tag revalidation log:", error);
+            return undefined;
+        });
         if (!result) {
             return;
         }
@@ -770,6 +1051,15 @@ class TrackedTagMarkers {
             this.forget(at, "the revalidation log has more rows than one query reads");
             return;
         }
+        // A scan of every entry held, which also drops the expired ones, once in
+        // a while: so expired entries never read again don't pile up ahead of
+        // live ones. In between, the stores answer early without one, which only
+        // keeps rows in `logOnly` a little longer.
+        const scan = at - this.lastEntryScan > ENTRY_SCAN_INTERVAL_MS;
+        if (scan) {
+            this.lastEntryScan = at;
+        }
+        const oldest = this.oldestEntry(scan);
         let applied = 0;
         for (const row of result.rows) {
             if (this.applied.has(row.sk)) {
@@ -795,11 +1085,19 @@ class TrackedTagMarkers {
                 // rolling re-read. Left unmarked, the next refresh applies it to
                 // whatever that read found; it costs no read, only the row being
                 // looked at again while it is inside the lookback.
+                //
+                // Kept meanwhile in `logOnly`, which is all `completeSince` needs.
+                this.rememberLogged(row.tag, mergeMarkers(this.logOnly.get(row.tag), row.marker), oldest);
                 continue;
             }
             this.applied.set(row.sk, row.at);
             applied++;
         }
+        if (oldest > this.prunedAgainst) {
+            this.pruneLogged(oldest);
+        }
+        // The rows just kept are known by later than `oldest` too.
+        this.prunedAgainst = oldest;
         this.lastLogRead = at;
         this.advance(at - exports.REVALIDATION_LOG_LOOKBACK_MS);
         this.debug(`read ${result.rows.length} revalidation log rows (${applied} applied)`);
@@ -814,7 +1112,9 @@ class TrackedTagMarkers {
         for (const tag of this.unread) {
             if (due.length >= exports.BATCH_GET_MAX_KEYS)
                 return due;
-            due.push(tag);
+            if (!this.reading.has(tag)) {
+                due.push(tag);
+            }
         }
         // Known in time order, and each due at most `jitter` earlier than the
         // tags after it: past a tag due more than that from now, none is due.
@@ -823,7 +1123,7 @@ class TrackedTagMarkers {
             if (due.length >= exports.BATCH_GET_MAX_KEYS || dueAt - jitter > at) {
                 break;
             }
-            if (dueAt <= at && !this.unread.has(tag)) {
+            if (dueAt <= at && !this.unread.has(tag) && !this.reading.has(tag)) {
                 due.push(tag);
             }
         }
@@ -836,10 +1136,21 @@ class TrackedTagMarkers {
      */
     forget(at, why) {
         this.debug(`forgetting ${this.tags.size} tracked tags: ${why}`);
+        this.forgotten++;
+        // What the markers expire later is still to apply once it is past.
+        for (const marker of this.tags.values()) {
+            this.raiseFloor(marker);
+        }
+        for (const marker of this.logOnly.values()) {
+            this.raiseFloor(marker);
+        }
         this.tags.clear();
         this.dueAt.clear();
         this.unread.clear();
         this.applied.clear();
+        this.logOnly.clear();
+        // Never back: a marker dropped earlier may have expired entries later.
+        this.floor = Math.max(this.floor, markerClock());
         this.cursor = at - exports.REVALIDATION_LOG_LOOKBACK_MS;
         this.lastLogRead = at;
     }
@@ -865,13 +1176,23 @@ class TrackedTagMarkers {
      * always answered with, rather than a read on every request while DynamoDB
      * is unavailable.
      */
-    async readInto(tags) {
+    async readInto(tags, again = false) {
         if (tags.length === 0) {
             return true;
         }
         const at = this.clock();
+        const forgotten = this.forgotten;
         try {
             const read = await this.markers.read(tags);
+            if (this.forgotten !== forgotten && !again) {
+                // Read before a forget - across a freeze, as like as not - so as
+                // stale as what it forgot. Read again rather than leave the tags
+                // untracked: whoever waits on this read (`reading`) judges entries
+                // by it next, and an untracked tag counts for nothing. Once: a run
+                // of forgets (a truncated log, query after query) would otherwise
+                // keep them waiting, and the second read began after the first.
+                return await this.readInto(tags, true);
+            }
             for (const tag of tags) {
                 this.unread.delete(tag);
                 this.remember(tag, mergeMarkers(mergeMarkers(this.tags.get(tag), read.get(tag)), this.takePendingRows(tag)));
@@ -882,6 +1203,9 @@ class TrackedTagMarkers {
         }
         catch (error) {
             console.error("Error reading tag markers:", error);
+            if (this.forgotten !== forgotten && !again) {
+                return this.readInto(tags, true);
+            }
             this.trackUnread(tags);
             for (const tag of tags) {
                 this.unread.add(tag);
@@ -895,8 +1219,127 @@ class TrackedTagMarkers {
     }
     takePendingRows(tag) {
         const pending = this.pendingRows.get(tag);
+        const logged = this.logOnly.get(tag);
         this.pendingRows.delete(tag);
-        return pending;
+        this.logOnly.delete(tag);
+        return logged ? mergeMarkers(logged, pending) : pending;
+    }
+    /**
+     * What this instance knows of `tag`: tracked, or from the log alone -
+     * including rows that arrived while its first read is in flight.
+     */
+    knownMarker(tag) {
+        const tracked = this.tags.get(tag);
+        if (tracked) {
+            return tracked;
+        }
+        const logged = this.logOnly.get(tag);
+        const pending = this.pendingRows.get(tag);
+        return logged || pending ? mergeMarkers(logged, pending) : undefined;
+    }
+    /**
+     * Keep `tag`'s log rows in `logOnly`, unless they cannot apply to an entry
+     * held, `oldest` or newer (see {@link pruneLogged}), as bounded as the
+     * tracked tags. Either way a row let go of takes what it knew with it, so
+     * `completeSince` moves past it.
+     */
+    rememberLogged(tag, marker, oldest) {
+        this.logOnly.delete(tag);
+        if (knownBy(marker, markerClock()) <= oldest) {
+            this.raiseFloor(marker);
+            return;
+        }
+        this.logOnly.set(tag, marker);
+        for (const [first, dropped] of this.logOnly) {
+            if (this.logOnly.size <= this.maxTrackedTags) {
+                break;
+            }
+            this.logOnly.delete(first);
+            this.raiseFloor(dropped);
+        }
+    }
+    /**
+     * Drop the `logOnly` rows that cannot apply to an entry held, `oldest` or
+     * newer: every revalidation they name so far is no later than it. That
+     * moves `completeSince` no further than `oldest`, which costs the entries
+     * held nothing, and a profile's `expiredAt` still to come waits in
+     * `laterFloors`. Without this, a deployment revalidating many distinct tags
+     * filled `logOnly` with tags no entry here carries, and the evictions past
+     * its bound kept moving `completeSince` up to the present.
+     */
+    pruneLogged(oldest) {
+        const at = markerClock();
+        for (const [tag, marker] of this.logOnly) {
+            if (knownBy(marker, at) <= oldest) {
+                this.logOnly.delete(tag);
+                this.raiseFloor(marker);
+            }
+        }
+    }
+    /**
+     * The oldest entry timestamp of any registered store, `Infinity` with none:
+     * early, never late, unless `scan`.
+     */
+    oldestEntry(scan) {
+        let oldest = Infinity;
+        for (const { oldestTimestamp } of this.entryStores) {
+            oldest = Math.min(oldest, oldestTimestamp(scan));
+        }
+        return oldest;
+    }
+    /**
+     * Move `completeSince` past `marker`'s revalidations: what is no longer
+     * known about a tag once its marker is dropped. A future `expiredAt` waits
+     * in `laterFloors` until it is past.
+     */
+    raiseFloor(marker) {
+        const at = markerClock();
+        this.floor = Math.max(this.floor, knownBy(marker, at));
+        const { expiredAt } = marker;
+        if (expiredAt !== undefined && expiredAt > Math.max(at, this.floor)) {
+            this.laterFloor(expiredAt);
+        }
+    }
+    /**
+     * Add `time` to `laterFloors`, in order. Past the tracked-tag bound the two
+     * spans closest together are merged: from the first's start,
+     * `completeSince` is the second's end, early - which only costs reads, and
+     * for as short a time as any merge allows. Never later than its time, which
+     * would let an entry expire unseen.
+     */
+    laterFloor(time) {
+        const floors = this.laterFloors;
+        let low = 0;
+        let high = floors.length;
+        while (low < high) {
+            const mid = Math.floor((low + high) / 2);
+            if (floors[mid][0] < time) {
+                low = mid + 1;
+            }
+            else {
+                high = mid;
+            }
+        }
+        // Inside a merged span already: by its start, `completeSince` is past it.
+        // Or already there: a log row for an untracked tag is applied again by
+        // every query its lookback returns it to.
+        if ((low > 0 && floors[low - 1][1] >= time) || floors[low]?.[0] === time) {
+            return;
+        }
+        floors.splice(low, 0, [time, time]);
+        // A scan, but only once past the bound. Merging the new time into a
+        // neighbour instead could join an hour-out span with a year-out one, and
+        // hold `completeSince` a year early.
+        if (floors.length > this.maxTrackedTags) {
+            let merge = 0;
+            for (let i = 1; i < floors.length - 1; i++) {
+                if (floors[i + 1][1] - floors[i][0] <
+                    floors[merge + 1][1] - floors[merge][0]) {
+                    merge = i;
+                }
+            }
+            floors.splice(merge, 2, [floors[merge][0], floors[merge + 1][1]]);
+        }
     }
     /** Record that `tag`'s marker was known from the table at `at`. */
     known(tag, at) {
@@ -910,6 +1353,7 @@ class TrackedTagMarkers {
             if (this.tags.size <= this.maxTrackedTags) {
                 break;
             }
+            this.raiseFloor(this.tags.get(oldest));
             this.tags.delete(oldest);
             this.dueAt.delete(oldest);
             this.unread.delete(oldest);
@@ -923,12 +1367,34 @@ class TrackedTagMarkers {
     }
 }
 exports.TrackedTagMarkers = TrackedTagMarkers;
+/**
+ * The latest revalidation `marker` has made known by `at`, `-Infinity` with
+ * none: a future `expiredAt` is still to come.
+ */
+function knownBy(marker, at) {
+    const { revalidatedAt, staleAt, expiredAt } = marker;
+    return Math.max(revalidatedAt ?? -Infinity, staleAt ?? -Infinity, expiredAt !== undefined && expiredAt <= at ? expiredAt : -Infinity);
+}
 /**
  * The longest a log row's put may take and still be seen by every reader: half
  * the lookback, leaving the rest for writers' clocks and eventually consistent
  * queries.
  */
 const MAX_LOG_PUT_MS = exports.REVALIDATION_LOG_LOOKBACK_MS / 2;
+/**
+ * How often a refresh scans the entry stores for their oldest entry, dropping
+ * the expired ones no request reads again.
+ */
+const ENTRY_SCAN_INTERVAL_MS = 60_000;
+/** How often a refresh in flight checks the process is running. */
+const REFRESH_TICK_MS = 250;
+/**
+ * How late a tick may come before the process counts as paused (frozen)
+ * since the refresh in flight started. A busy event loop can delay one too:
+ * the refresh then counts as no fresher than its start, as before the pause
+ * check, so a request waits for the next one once that is past the grace.
+ */
+const REFRESH_PAUSE_MS = 1000;
 /**
  * A marker as read from the table or the log, keeping whatever this instance
  * already knows that the read does not show yet: reads are eventually
@@ -1001,4 +1467,4 @@ class CacheBucket {
     }
 }
 exports.CacheBucket = CacheBucket;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-cache-store.js","sourceRoot":"","sources":["../../src/adapter/aws-cache-store.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n  The S3 / DynamoDB plumbing shared by every cdk-nextjs cache handler: the\n  incremental `cacheHandler` (`S3CacheHandler`) and the `cacheHandlers` for\n  `'use cache'` / `'use cache: remote'`.\n\n  What lives here is what has to agree between them - where the configuration\n  comes from, how a cache key becomes an S3 key, and what a tag's marker row in\n  the revalidation table looks like and means. A `revalidateTag` reaches both\n  kinds of handler, and they must read each other's markers the same way.\n*/\n/* eslint-disable import/no-extraneous-dependencies */\nimport { join } from \"node:path\";\nimport {\n  AttributeValue,\n  BatchGetItemCommand,\n  BatchGetItemCommandOutput,\n  DynamoDBClient,\n  PutItemCommand,\n  QueryCommand,\n  QueryCommandOutput,\n  UpdateItemCommand,\n} from \"@aws-sdk/client-dynamodb\";\nimport {\n  GetObjectCommand,\n  NoSuchKey,\n  PutObjectCommand,\n  S3Client,\n} from \"@aws-sdk/client-s3\";\n\n/**\n * Where the cache lives, as the constructs pass it to the compute through the\n * environment (`NextjsFunctions`, `NextjsContainers`). Empty strings for what is\n * not configured, which each handler reads as \"that layer is disabled\".\n */\nexport interface AwsCacheConfig {\n  /** `CDK_NEXTJS_CACHE_BUCKET_NAME`. */\n  bucketName: string;\n  /** `CDK_NEXTJS_REVALIDATION_TABLE_NAME`. */\n  tableName: string;\n  /** `AWS_REGION`, `us-east-1` when unset. */\n  region: string;\n  /** `CDK_NEXTJS_BUILD_ID`: every S3 key and every marker row is scoped to it. */\n  buildId: string;\n}\n\n/** The configuration from the environment. */\nexport function resolveAwsCacheConfig(): AwsCacheConfig {\n  return {\n    bucketName: process.env.CDK_NEXTJS_CACHE_BUCKET_NAME || \"\",\n    tableName: process.env.CDK_NEXTJS_REVALIDATION_TABLE_NAME || \"\",\n    region: process.env.AWS_REGION || \"us-east-1\",\n    buildId: process.env.CDK_NEXTJS_BUILD_ID || \"\",\n  };\n}\n\n/**\n * `{buildId}/{cacheKey}.json`, the incremental cache's key convention.\n *\n * The root path becomes `index`, and a leading slash is dropped so there is no\n * empty folder under the build prefix. Everything this returns ends in `.json`,\n * which is what keeps it disjoint from {@link useCacheS3Key}.\n */\nexport function buildS3Key(buildId: string, cacheKey: string): string {\n  let cleanCacheKey = cacheKey;\n  if (cacheKey === \"/\" || cacheKey === \"\") {\n    cleanCacheKey = \"index\";\n  } else if (cacheKey.startsWith(\"/\")) {\n    cleanCacheKey = cacheKey.slice(1);\n  }\n  return join(buildId, `${cleanCacheKey}.json`);\n}\n\n/**\n * The folder under the build prefix that `'use cache'` entries are stored in.\n * @see useCacheS3Key\n */\nexport const USE_CACHE_KEY_PREFIX = \"_use-cache\";\n\n/**\n * `{buildId}/_use-cache/{hash}.entry`, where a `cacheHandlers` entry is stored.\n *\n * Hashed because a `'use cache'` key is the serialized arguments of the call and\n * has no length limit, where an S3 key stops at 1024 bytes. The `.entry` suffix\n * rather than `.json` is what makes a collision with the incremental cache\n * impossible rather than unlikely: every key {@link buildS3Key} writes ends in\n * `.json`, including one for a route that happens to be named `/_use-cache/…`.\n * Still under the build prefix, so post-deploy pruning drops them with the build.\n */\nexport function useCacheS3Key(buildId: string, keyHash: string): string {\n  return join(buildId, USE_CACHE_KEY_PREFIX, `${keyHash}.entry`);\n}\n\n/**\n * The `durations` Next.js 16 passes a tag revalidation for a profile:\n * `revalidateTag(\"posts\", \"max\")` arrives as `{ expire: <the profile's expire> }`.\n * Absent for `updateTag` and a bare `revalidateTag`, which expire immediately.\n */\nexport interface RevalidateDurations {\n  expire?: number;\n}\n\n/**\n * A tag's marker row, as timestamps in milliseconds. Written by\n * {@link markerUpdate}; each field is absent until a revalidation of that shape\n * has happened.\n */\nexport interface TagMarker {\n  /** Expired outright: `updateTag`, or `revalidateTag` with no profile. */\n  revalidatedAt?: number;\n  /** Stale from here: `revalidateTag(tag, profile)`. */\n  staleAt?: number;\n  /** When the profile's `expire` runs out, which may be in the future. */\n  expiredAt?: number;\n}\n\n/**\n * What the tag markers say about an entry: untouched, served stale while a\n * background render replaces it, or expired and re-rendered before answering.\n */\nexport type RevalidationState = \"fresh\" | \"stale\" | \"expired\";\n\n/**\n * What `marker` means for an entry created at `createdAt`, at `now`.\n *\n * `expiredAt` in the future is a profile's `expire` that has not come yet,\n * compared the way Next.js's `areTagsExpired` does.\n */\nexport function markerState(\n  marker: TagMarker,\n  createdAt: number,\n  now: number,\n): RevalidationState {\n  const { revalidatedAt, expiredAt, staleAt } = marker;\n  if (\n    (revalidatedAt !== undefined && revalidatedAt > createdAt) ||\n    (expiredAt !== undefined && expiredAt <= now && expiredAt > createdAt)\n  ) {\n    return \"expired\";\n  }\n  if (staleAt !== undefined && staleAt > createdAt) {\n    return \"stale\";\n  }\n  return \"fresh\";\n}\n\n/**\n * The clock every tag marker is stamped with, and every entry timestamp it is\n * compared against: the one Next.js stamps `CacheEntry.timestamp` with\n * (`performance.timeOrigin + performance.now()`, in `use-cache-wrapper.js` and\n * the default handler), rather than `Date.now()`. Both handlers write the same\n * marker rows, so both have to use it: two clocks on one row let the last writer\n * decide which clock the others compare against, and they drift apart for as\n * long as a Lambda sandbox or Fargate task lives.\n */\nexport function markerClock(): number {\n  return performance.timeOrigin + performance.now();\n}\n\n/**\n * The marker fields a tag revalidated at `now` sets.\n *\n * Without `durations` - `updateTag`, or `revalidateTag` with no profile - the\n * tag's entries expire immediately (`revalidatedAt`). With them the entries go\n * stale now and expire after the profile's `expire`, the same pair of\n * timestamps Next.js's `FileSystemCache.revalidateTag` records. A profile with\n * no `expire` sets only `staleAt`, and whatever `expiredAt` the tag had stays.\n */\nexport function markerFor(\n  now: number,\n  durations: RevalidateDurations | undefined,\n): TagMarker {\n  if (!durations) {\n    return { revalidatedAt: now };\n  }\n  if (durations.expire === undefined) {\n    return { staleAt: now };\n  }\n  return { staleAt: now, expiredAt: now + durations.expire * 1000 };\n}\n\nconst MARKER_FIELDS = [\"revalidatedAt\", \"staleAt\", \"expiredAt\"] as const;\n\n/**\n * `existing` with the fields `update` sets, as a {@link markerUpdate} leaves\n * the row: a field `update` does not set keeps its value.\n */\nexport function applyMarker(\n  existing: TagMarker | undefined,\n  update: TagMarker,\n): TagMarker {\n  const marker = { ...existing };\n  for (const field of MARKER_FIELDS) {\n    if (update[field] !== undefined) {\n      marker[field] = update[field];\n    }\n  }\n  return marker;\n}\n\n/** The marker-row update that sets {@link markerFor}'s fields. */\nexport function markerUpdate(\n  now: number,\n  durations: RevalidateDurations | undefined,\n): Pick<\n  ConstructorParameters<typeof UpdateItemCommand>[0],\n  \"UpdateExpression\" | \"ExpressionAttributeValues\"\n> {\n  const marker = markerFor(now, durations);\n  const fields = MARKER_FIELDS.filter((field) => marker[field] !== undefined);\n  return {\n    UpdateExpression: `SET ${fields.map((field) => `${field} = :${field}`).join(\", \")}`,\n    ExpressionAttributeValues: Object.fromEntries(\n      fields.map((field) => [`:${field}`, { N: String(marker[field]) }]),\n    ),\n  };\n}\n\n/** A DynamoDB number attribute as a number, or `undefined` when absent. */\nfunction numberAttribute(\n  value: AttributeValue | undefined,\n): number | undefined {\n  return value?.N === undefined ? undefined : Number(value.N);\n}\n\n/** The marker fields of a marker or log row. */\nfunction markerOf(item: Record<string, AttributeValue>): TagMarker {\n  return {\n    revalidatedAt: numberAttribute(item.revalidatedAt),\n    staleAt: numberAttribute(item.staleAt),\n    expiredAt: numberAttribute(item.expiredAt),\n  };\n}\n\n/** DynamoDB's cap on keys in one `BatchGetItem`. */\nexport const BATCH_GET_MAX_KEYS = 100;\n\n/**\n * How often, at most, an instance catches up on revalidations other instances\n * ran, unless `CDK_NEXTJS_TAG_REFRESH_MS` says otherwise: the staleness window\n * for a `revalidateTag` run elsewhere. Every cache hit checks its tags'\n * markers, and every marker of a deployment shares one partition key, so\n * reading them per request capped a route's cache hits at the partition's read\n * throughput (~1,900 req/s on NextjsRegionalFunctions). Once a second, from the\n * revalidation log, the reads scale with instances instead of requests or tags.\n */\nexport const DEFAULT_TAG_REFRESH_MS = 1000;\n\n/**\n * The bare-tag marker rows of the revalidation table (`pk = buildId`,\n * `sk = tag`), which record when a tag was last revalidated and how.\n *\n * The table also holds the incremental cache's `tag#s3Key` mapping rows, which\n * are its own business and stay in `S3CacheHandler`: only the markers mean the\n * same thing to every handler. What an instance keeps of them between reads is\n * {@link TrackedTagMarkers}.\n */\nexport class TagMarkerTable {\n  constructor(\n    private readonly client: DynamoDBClient,\n    private readonly tableName: string,\n    private readonly buildId: string,\n  ) {}\n\n  /**\n   * Record `tag`'s revalidation at `now`. See {@link markerUpdate}.\n   *\n   * Returns the row as this write left it, so the instance that wrote it can\n   * track it rather than read it back: reads are eventually consistent, and a\n   * read-back racing replication could return the marker from before the write.\n   */\n  async write(\n    tag: string,\n    now: number,\n    durations: RevalidateDurations | undefined,\n  ): Promise<TagMarker | undefined> {\n    const response = await this.client.send(\n      new UpdateItemCommand({\n        TableName: this.tableName,\n        Key: {\n          pk: { S: this.buildId },\n          sk: { S: tag },\n        },\n        ...markerUpdate(now, durations),\n        ReturnValues: \"ALL_NEW\",\n      }),\n    );\n    return response?.Attributes ? markerOf(response.Attributes) : undefined;\n  }\n\n  /**\n   * The marker rows for `tags` that exist, by tag, in one `BatchGetItem` per\n   * {@link BATCH_GET_MAX_KEYS} tags rather than a `GetItem` each: a page\n   * carries its whole implicit `_N_T_/…` chain plus the app's own tags, a\n   * page with a few fetches checks each of them too, and every one is on the\n   * request path. A tag with no row is absent from the result.\n   */\n  async read(tags: string[]): Promise<Map<string, TagMarker>> {\n    const { tableName, buildId } = this;\n    const unique = Array.from(new Set(tags));\n    const markers = new Map<string, TagMarker>();\n\n    for (let i = 0; i < unique.length; i += BATCH_GET_MAX_KEYS) {\n      let keys: Record<string, AttributeValue>[] | undefined = unique\n        .slice(i, i + BATCH_GET_MAX_KEYS)\n        .map((tag) => ({ pk: { S: buildId }, sk: { S: tag } }));\n      // `UnprocessedKeys` is DynamoDB declining part of the batch under load;\n      // a marker left unread is a revalidation missed, so it is asked again.\n      for (let attempt = 0; keys?.length && attempt < 3; attempt++) {\n        const response: BatchGetItemCommandOutput = await this.client.send(\n          new BatchGetItemCommand({\n            RequestItems: {\n              [tableName]: {\n                Keys: keys,\n                ProjectionExpression: \"sk, revalidatedAt, staleAt, expiredAt\",\n              },\n            },\n          }),\n        );\n        for (const item of response.Responses?.[tableName] ?? []) {\n          const tag = item.sk?.S;\n          if (tag !== undefined) {\n            markers.set(tag, markerOf(item));\n          }\n        }\n        keys = response.UnprocessedKeys?.[tableName]?.Keys;\n      }\n      if (keys?.length) {\n        throw new Error(\n          `DynamoDB left ${keys.length} tag markers unread after retrying`,\n        );\n      }\n    }\n    return markers;\n  }\n}\n\n/**\n * How long a revalidation log row is kept (`ttl`, epoch seconds). DynamoDB never\n * deletes an item before its TTL, only some time after, so a reader that last\n * queried less than this long ago (less a margin for writers' clocks) is sure\n * to find every row it has not seen yet.\n */\nexport const REVALIDATION_LOG_TTL_MS = 15 * 60 * 1000;\n\n/** The most `Query` pages one {@link RevalidationLog.query} reads. */\nexport const REVALIDATION_LOG_MAX_PAGES = 5;\n\n/** How many sort keys {@link RevalidationLog.put} tries before giving up. */\nconst LOG_PUT_ATTEMPTS = 5;\n\n/** Digits a log row's timestamp is zero-padded to, so sort keys sort by time. */\nconst LOG_SK_DIGITS = 15;\n\n/** A revalidation read back from the log. */\nexport interface RevalidationLogRow {\n  /** The row's sort key: unique per revalidation of a tag. */\n  sk: string;\n  /** When it was written, on the writer's `Date.now()`. */\n  at: number;\n  tag: string;\n  /** The marker fields the revalidation set, as {@link markerFor} returns them. */\n  marker: TagMarker;\n}\n\n/**\n * The revalidation log: one row per tag revalidation (`pk = <buildId>#log`,\n * `sk = <Date.now(), zero-padded>#<tag>`), which expires after\n * {@link REVALIDATION_LOG_TTL_MS}.\n *\n * The marker rows stay the source of truth. The log exists so an instance\n * can ask \"what was revalidated since I last looked?\" in one `Query`, instead\n * of re-reading every tag it tracks to find out that almost none changed. Every\n * marker row of a deployment shares one partition, and those re-reads from a\n * handful of busy instances were enough to throttle it.\n *\n * The sort key's timestamp is the writer's wall clock (`Date.now()`), not the\n * performance clock ({@link markerClock}) the marker values are stamped with by both\n * handlers: it only orders rows for readers' cursors, which are on their own\n * wall clocks, and is never compared with an entry's timestamp.\n */\nexport class RevalidationLog {\n  private readonly pk: string;\n\n  constructor(\n    private readonly client: DynamoDBClient,\n    private readonly tableName: string,\n    buildId: string,\n  ) {\n    this.pk = `${buildId}#log`;\n  }\n\n  /**\n   * Record that `tag` was revalidated at `at` (`Date.now()`), setting `marker`.\n   *\n   * Two revalidations of `tag` in the same millisecond would share a sort key,\n   * and the second would overwrite the first. So the row is only written where\n   * its key is free, and on a collision it moves to the next millisecond, up\n   * to {@link LOG_PUT_ATTEMPTS} times.\n   */\n  async put(tag: string, at: number, marker: TagMarker): Promise<void> {\n    for (let attempt = 1; ; attempt++) {\n      const item: Record<string, AttributeValue> = {\n        pk: { S: this.pk },\n        sk: { S: `${logSkPrefix(at)}#${tag}` },\n        ttl: { N: String(Math.ceil((at + REVALIDATION_LOG_TTL_MS) / 1000)) },\n      };\n      for (const field of MARKER_FIELDS) {\n        const value = marker[field];\n        if (value !== undefined) {\n          item[field] = { N: String(value) };\n        }\n      }\n      try {\n        await this.client.send(\n          new PutItemCommand({\n            TableName: this.tableName,\n            Item: item,\n            ConditionExpression: \"attribute_not_exists(sk)\",\n          }),\n        );\n        return;\n      } catch (error) {\n        if (\n          (error as Error | undefined)?.name !==\n            \"ConditionalCheckFailedException\" ||\n          attempt >= LOG_PUT_ATTEMPTS\n        ) {\n          throw error;\n        }\n        at = Math.floor(at) + 1;\n      }\n    }\n  }\n\n  /**\n   * The rows written at or after `since` (`Date.now()`), oldest first.\n   * `truncated` when there were more than {@link REVALIDATION_LOG_MAX_PAGES}\n   * pages of them, and `rows` is only the start.\n   *\n   * Eventually consistent: a row written a moment ago may not show yet, which\n   * is what the reader's lookback is for.\n   */\n  async query(\n    since: number,\n  ): Promise<{ rows: RevalidationLogRow[]; truncated: boolean }> {\n    const rows: RevalidationLogRow[] = [];\n    let startKey: Record<string, AttributeValue> | undefined;\n    for (let page = 0; page < REVALIDATION_LOG_MAX_PAGES; page++) {\n      const response: QueryCommandOutput = await this.client.send(\n        new QueryCommand({\n          TableName: this.tableName,\n          KeyConditionExpression: \"pk = :pk AND sk >= :since\",\n          ExpressionAttributeValues: {\n            \":pk\": { S: this.pk },\n            \":since\": { S: logSkPrefix(Math.max(0, since)) },\n          },\n          ProjectionExpression: \"sk, revalidatedAt, staleAt, expiredAt\",\n          ExclusiveStartKey: startKey,\n        }),\n      );\n      for (const item of response.Items ?? []) {\n        const sk = item.sk?.S;\n        // `<digits>#<tag>`: the tag is everything after the fixed-width\n        // timestamp, `#`s included.\n        if (sk === undefined || sk[LOG_SK_DIGITS] !== \"#\") {\n          continue;\n        }\n        rows.push({\n          sk,\n          at: Number(sk.slice(0, LOG_SK_DIGITS)),\n          tag: sk.slice(LOG_SK_DIGITS + 1),\n          marker: markerOf(item),\n        });\n      }\n      startKey = response.LastEvaluatedKey;\n      if (!startKey) {\n        return { rows, truncated: false };\n      }\n    }\n    return { rows, truncated: true };\n  }\n}\n\nfunction logSkPrefix(at: number): string {\n  return String(Math.floor(at)).padStart(LOG_SK_DIGITS, \"0\");\n}\n\n/**\n * How far behind the last query's start the next one starts reading the log:\n * the room for the `Query` being eventually consistent and for writers' clocks\n * running behind the reader's. Rows inside it are read again, and dropped as\n * already applied.\n */\nexport const REVALIDATION_LOG_LOOKBACK_MS = 5000;\n\n/**\n * The longest {@link TrackedTagMarkers} trusts the log alone for a tag before\n * reading its marker row again. The log is the fast path, but the marker rows\n * are the source of truth: a log row whose write failed would otherwise be\n * missed for as long as the tag stays tracked.\n *\n * Rolling, not all at once: each refresh re-reads at most\n * {@link BATCH_GET_MAX_KEYS} of the tags due, oldest first. Re-reading them all\n * together cost ~500 RCU at 1000 tags - a fleet started by one load test did it\n * in the same minute, 12,800 RCU, and throttled - and would be ~5,000 RCU at\n * {@link DEFAULT_MAX_TRACKED_TAGS}, past what the one partition serves in a\n * second. Spread out, 10,000 tracked tags cost ~8 RCU a second per instance.\n *\n * Each tag is due at a random 75-100% of this after it was last read, so tags\n * first read together - an instance warming up - do not all come due together\n * again every interval: the load test that measured the rolling re-read saw\n * its warm-up's reads return as a 30-36 RCU/s bump ten minutes later.\n */\nexport const DEFAULT_TAG_RESYNC_MS = 10 * 60 * 1000;\n\n/** The fraction of {@link DEFAULT_TAG_RESYNC_MS} a tag may come due early by. */\nconst TAG_RESYNC_JITTER = 0.25;\n\n/**\n * How long since the last successful log query the log can still be trusted to\n * hold every row not read yet: its TTL less a margin for writers' clocks. Past\n * it - a Lambda frozen between invocations, a run of failed queries - the\n * tracked markers are forgotten, to be read again as they are needed, and the\n * log is followed from there.\n */\nexport const MAX_REVALIDATION_LOG_GAP_MS =\n  REVALIDATION_LOG_TTL_MS - 5 * 60 * 1000;\n\n/**\n * The most tags one instance tracks. Past it the least recently used is\n * forgotten, which costs a read the next time it is needed: an untracked tag\n * is read before it is trusted.\n *\n * A tracked tag costs memory (~2 MB at this bound) and its share of the rolling\n * re-read, not a read every refresh, so the bound is set by how many tags an\n * instance really uses. Every path is a tag of its own (`_N_T_/<path>`), and at\n * 1000 an app of 1000 tagged pages kept evicting what it was about to need:\n * half its requests re-read a marker.\n */\nexport const DEFAULT_MAX_TRACKED_TAGS = 10_000;\n\n/**\n * The revalidation table's marker rows and its log, which are only ever used\n * together, or neither for tags local to this process.\n */\nexport type TagTable =\n  | { markers: TagMarkerTable; log: RevalidationLog }\n  | { markers?: undefined; log?: undefined };\n\n/** How {@link TrackedTagMarkers} is built. */\nexport type TrackedTagMarkersOptions = TagTable & {\n  /**\n   * How often, at most, {@link TrackedTagMarkers.refresh} reads anything.\n   * @default DEFAULT_TAG_REFRESH_MS\n   */\n  refreshIntervalMs?: number;\n  maxTrackedTags?: number;\n  /** @see DEFAULT_TAG_RESYNC_MS */\n  resyncIntervalMs?: number;\n  /** The wall clock the log's cursor and the intervals are kept on. */\n  clock?: () => number;\n  /** `Math.random`, for when each tag's re-read comes due. */\n  random?: () => number;\n  debug?: (message: string) => void;\n};\n\n/**\n * One instance's copy of the marker rows of the tags it has needed, kept\n * current through the {@link RevalidationLog}: the process's one tag manifest\n * (`sharedTagManifest`), for the `'use cache'` handlers and the incremental\n * cache alike.\n *\n * Next.js's built-in `'use cache'` handler keeps tags in a module-level map\n * (`tags-manifest.external.js`) that only its own `updateTags` writes, and its\n * `refreshTags` is a no-op, so a `revalidateTag` on one instance never reaches\n * the others: they keep serving the revalidated entry, including inside pages\n * that are being re-rendered *because* of that revalidation. The\n * `cacheHandlers` interface's answer is `refreshTags`, \"called before starting\n * a new request … to refresh the local tags manifest\", and this is that\n * manifest, backed by the same marker rows the incremental cache's\n * `revalidateTag` writes (`pk = buildId`, `sk = tag`).\n *\n * The cost is bounded per instance, not per request:\n * - {@link ensure} reads a tag's marker the first time it is needed and not\n *   again until it is evicted, so a tag costs one read per instance, not one\n *   per request.\n * - {@link refresh}, at most once per `refreshIntervalMs`, sends one `Query`\n *   for the log rows written since the last one, and applies those of tags\n *   this instance tracks. Concurrent callers share it. Alongside, it re-reads\n *   the markers of up to {@link BATCH_GET_MAX_KEYS} tags not read for\n *   {@link DEFAULT_TAG_RESYNC_MS}, in one `BatchGetItem`.\n * A revalidation on another instance is therefore seen within\n * `refreshIntervalMs` (plus the query itself). The instance that ran it applies\n * it itself, at once, with {@link set}.\n */\nexport class TrackedTagMarkers {\n  private readonly markers: TagMarkerTable | undefined;\n  private readonly log: RevalidationLog | undefined;\n  private readonly refreshIntervalMs: number;\n  private readonly maxTrackedTags: number;\n  private readonly resyncIntervalMs: number;\n  private readonly clock: () => number;\n  private readonly random: () => number;\n  private readonly debug: (message: string) => void;\n  /** By tag, least recently used first. */\n  private readonly tags = new Map<string, TagMarker>();\n  /**\n   * When each tracked tag's marker is due to be read again: a random 75-100%\n   * of `resyncIntervalMs` after it was last known from the table - read,\n   * written here, or new. In the order they became known, least recent first.\n   */\n  private readonly dueAt = new Map<string, number>();\n  private readonly reading = new Map<string, Promise<void>>();\n  /**\n   * Log rows for tags whose first read is in flight, merged by tag: the read\n   * may have been answered before the revalidation, so they are applied to its\n   * result rather than dropped.\n   */\n  private readonly pendingRows = new Map<string, TagMarker>();\n  /** Tracked tags whose read failed, for the next refresh to read again. */\n  private readonly unread = new Set<string>();\n  private lastRefresh = -Infinity;\n  private refreshing: Promise<void> | undefined;\n  /**\n   * Where the next log query starts (`clock()`): the last successful one's\n   * start, less {@link REVALIDATION_LOG_LOOKBACK_MS}.\n   */\n  private cursor: number;\n  /** When the last successful log query started, or the log was first read. */\n  private lastLogRead: number;\n  /** Log rows at or after the cursor already applied, by sort key. */\n  private readonly applied = new Map<string, number>();\n  /** {@link update}s of the current turn, by their arguments. */\n  private readonly updating = new Map<string, Promise<boolean>>();\n\n  constructor(options: TrackedTagMarkersOptions) {\n    this.markers = options.markers;\n    this.log = options.log;\n    this.refreshIntervalMs =\n      options.refreshIntervalMs ?? DEFAULT_TAG_REFRESH_MS;\n    this.maxTrackedTags = options.maxTrackedTags ?? DEFAULT_MAX_TRACKED_TAGS;\n    this.resyncIntervalMs = options.resyncIntervalMs ?? DEFAULT_TAG_RESYNC_MS;\n    // Looked up on each call rather than bound here, so a test's `Date.now`\n    // spy applies.\n    this.clock = options.clock ?? (() => Date.now());\n    this.random = options.random ?? Math.random;\n    this.debug = options.debug ?? (() => {});\n    // Nothing is tracked yet, so nothing before this can be missed: every tag\n    // is read from its marker the first time it is needed.\n    const at = this.clock();\n    this.cursor = at - REVALIDATION_LOG_LOOKBACK_MS;\n    this.lastLogRead = at;\n  }\n\n  /** `tag`'s marker as this instance knows it, if it tracks `tag`. */\n  get(tag: string): TagMarker | undefined {\n    return this.tags.get(tag);\n  }\n\n  /**\n   * Track `tag` with `marker`: what this instance just wrote, which it knows\n   * without reading it back.\n   */\n  set(tag: string, marker: TagMarker): void {\n    this.remember(tag, marker);\n    this.known(tag, this.clock());\n  }\n\n  /**\n   * Note a use of `tags`: those of an entry this instance just stored.\n   *\n   * With the table, a tag not tracked yet is left untracked, to be read by\n   * {@link ensure} the first time an entry needs it. Nothing revalidated before\n   * the new entry was created applies to *it*, but tracking is per tag, not per\n   * entry: tracking the tag with an empty marker would also vouch for every\n   * older entry that carries it - one another instance stored in S3, or one\n   * this instance kept in memory across a {@link forget} - and a revalidation\n   * from before the log's cursor would go unseen until the rolling re-read.\n   *\n   * Without the table every revalidation is this process's own, applied with\n   * {@link set}, so a tag is tracked at once.\n   */\n  track(tags: readonly string[]): void {\n    if (!this.markers) {\n      this.trackUnread(tags);\n      return;\n    }\n    for (const tag of tags) {\n      this.touch(tag);\n    }\n  }\n\n  /**\n   * Track `tags` as they are known now, without reading them, with an empty\n   * marker for any not tracked yet.\n   */\n  private trackUnread(tags: readonly string[]): void {\n    const at = this.clock();\n    for (const tag of tags) {\n      if (!this.tags.has(tag)) {\n        this.known(tag, at);\n      }\n      this.remember(tag, this.tags.get(tag) ?? {});\n    }\n  }\n\n  /**\n   * Read the markers of whichever of `tags` this instance does not track yet.\n   * Needed before judging an entry this instance did not create, since its\n   * tags may have been revalidated at any time before.\n   */\n  async ensure(tags: readonly string[]): Promise<void> {\n    if (!this.markers) {\n      this.trackUnread(tags);\n      return;\n    }\n    const waits: Promise<void>[] = [];\n    const unread: string[] = [];\n    for (const tag of new Set(tags)) {\n      const inFlight = this.reading.get(tag);\n      if (inFlight) {\n        waits.push(inFlight);\n      } else if (this.tags.has(tag)) {\n        this.touch(tag);\n      } else {\n        unread.push(tag);\n      }\n    }\n    if (unread.length > 0) {\n      // `readInto` never rejects: a failed read leaves the tags tracked.\n      const read = this.readInto(unread).then(() => {\n        for (const tag of unread) {\n          this.reading.delete(tag);\n        }\n      });\n      for (const tag of unread) {\n        this.reading.set(tag, read);\n      }\n      waits.push(read);\n    }\n    await Promise.all(waits);\n  }\n\n  /**\n   * Catch up on revalidations other instances ran, at most once per\n   * `refreshIntervalMs`. See {@link TrackedTagMarkers} for the cost.\n   */\n  async refresh(): Promise<void> {\n    const log = this.log;\n    if (!log) {\n      return;\n    }\n    if (this.refreshing) {\n      return this.refreshing;\n    }\n    const at = this.clock();\n    if (at - this.lastRefresh < this.refreshIntervalMs) {\n      return;\n    }\n    this.lastRefresh = at;\n    // Whatever gets tracked before the next refresh is read from its marker,\n    // so there is nothing to catch up on yet.\n    if (this.tags.size === 0) {\n      return;\n    }\n    this.refreshing = this.sync(at, log).finally(() => {\n      this.refreshing = undefined;\n    });\n    return this.refreshing;\n  }\n\n  /**\n   * Record a revalidation of `tags`: here at once, and in the revalidation\n   * table for every other instance - the marker row plus a log row per tag.\n   *\n   * Next.js calls `revalidateTag` on the incremental cache and `updateTags` on\n   * every distinct `cacheHandlers` entry, all in one synchronous loop\n   * (`revalidation-utils`), and all of them share this manifest. So an\n   * identical call in the same turn joins the first instead of writing the\n   * rows again. One in a later turn is a revalidation of its own, even while\n   * the first one's writes are in flight, and gets its own, later, marker.\n   * Never rejects: resolves `false` when a row failed to write (the error is\n   * logged), so other instances may not see it.\n   */\n  async update(\n    tags: readonly string[],\n    durations: RevalidateDurations | undefined,\n  ): Promise<boolean> {\n    const key = JSON.stringify([tags, durations ?? null]);\n    const inFlight = this.updating.get(key);\n    if (inFlight) {\n      return inFlight;\n    }\n    const update = this.write(tags, durations);\n    this.updating.set(key, update);\n    // Forgotten as soon as the current turn's calls have been made.\n    void Promise.resolve().then(() => this.updating.delete(key));\n    return update;\n  }\n\n  /**\n   * What the tracked markers say about an entry carrying `tags`, created at\n   * `createdAt`: the most severe answer of any of them.\n   */\n  state(tags: readonly string[], createdAt: number): RevalidationState {\n    // `markerClock()`, not `Date.now()`, here and wherever a marker is stamped:\n    // `createdAt` is on Next.js's clock, and a marker on the wall clock would be\n    // compared across the two, so an entry regenerated just after a\n    // revalidation could still read as older than it wherever they drift.\n    const at = markerClock();\n    let state: RevalidationState = \"fresh\";\n    for (const tag of tags) {\n      const marker = this.get(tag);\n      if (!marker) {\n        continue;\n      }\n      const tagState = markerState(marker, createdAt, at);\n      if (tagState === \"expired\") {\n        return \"expired\";\n      }\n      if (tagState === \"stale\") {\n        state = \"stale\";\n      }\n    }\n    return state;\n  }\n\n  /**\n   * `getExpiration`'s answer: the latest time any of `tags` expired, `0` if\n   * none has. Only expirations already past count - a profile's future\n   * `expire` is not an expiration yet - and a stale mark does not, matching\n   * Next.js's default handler, which reads only `expired` for implicit tags.\n   */\n  expiration(tags: readonly string[]): number {\n    const at = markerClock();\n    let latest = 0;\n    for (const tag of tags) {\n      const marker = this.get(tag);\n      if (!marker) {\n        continue;\n      }\n      if (marker.revalidatedAt !== undefined) {\n        latest = Math.max(latest, marker.revalidatedAt);\n      }\n      if (marker.expiredAt !== undefined && marker.expiredAt <= at) {\n        latest = Math.max(latest, marker.expiredAt);\n      }\n    }\n    return latest;\n  }\n\n  private async write(\n    tags: readonly string[],\n    durations: RevalidateDurations | undefined,\n  ): Promise<boolean> {\n    const at = markerClock();\n    const marker = markerFor(at, durations);\n    for (const tag of tags) {\n      this.set(tag, applyMarker(this.get(tag), marker));\n    }\n    const { markers, log } = this;\n    if (!markers || !log) {\n      return true;\n    }\n    const writes: [string, Promise<unknown>][] = [];\n    for (const tag of new Set(tags)) {\n      writes.push([\n        \"Error writing tag revalidation marker:\",\n        // The row as it is now, which carries any earlier `revalidatedAt`\n        // another instance wrote: tracking only what this call set would\n        // hide that one until the rolling re-read, and an entry older than it\n        // would read as merely stale.\n        markers.write(tag, at, durations).then((row) => {\n          if (row) {\n            this.set(tag, mergeMarkers(this.get(tag), row));\n          }\n        }),\n      ]);\n      writes.push([\n        \"Error writing tag revalidation log row:\",\n        this.putLogRow(log, tag, marker),\n      ]);\n    }\n    const results = await Promise.allSettled(writes.map(([, write]) => write));\n    results.forEach((result, i) => {\n      if (result.status === \"rejected\") {\n        console.error(writes[i][0], result.reason);\n      }\n    });\n    return results.every((result) => result.status === \"fulfilled\");\n  }\n\n  /**\n   * Put `tag`'s log row, stamped on the wall clock (the marker values are on\n   * Next.js's: see {@link RevalidationLog}).\n   *\n   * Readers only look {@link REVALIDATION_LOG_LOOKBACK_MS} behind their last\n   * query, so a row that shows up much later than its timestamp - a slow\n   * connection, retries under throttling - is behind every cursor and never\n   * read. A slow put is therefore made again under a fresh timestamp, which\n   * readers will see; one slow twice is reported as a failure.\n   */\n  private async putLogRow(\n    log: RevalidationLog,\n    tag: string,\n    marker: TagMarker,\n  ): Promise<void> {\n    for (let attempt = 0; attempt < 2; attempt++) {\n      const at = this.clock();\n      await log.put(tag, at, marker);\n      if (this.clock() - at <= MAX_LOG_PUT_MS) {\n        return;\n      }\n    }\n    throw new Error(\n      `The revalidation log row for ${tag} took longer than readers look back`,\n    );\n  }\n\n  /**\n   * One refresh started at `at`: the log rows since the cursor, and the next\n   * slice of the rolling re-read.\n   *\n   * A failed query changes nothing but the log: the tags stay tracked as they\n   * were, and the next refresh asks again from the same cursor.\n   */\n  private async sync(at: number, log: RevalidationLog): Promise<void> {\n    if (at - this.lastLogRead > MAX_REVALIDATION_LOG_GAP_MS) {\n      this.forget(\n        at,\n        \"the revalidation log may not cover the gap since it was last read\",\n      );\n      return;\n    }\n    const [result] = await Promise.all([\n      log.query(this.cursor).catch((error) => {\n        console.error(\"Error reading tag revalidation log:\", error);\n        return undefined;\n      }),\n      this.readInto(this.due(at)),\n    ]);\n    if (!result) {\n      return;\n    }\n    if (result.truncated) {\n      this.forget(\n        at,\n        \"the revalidation log has more rows than one query reads\",\n      );\n      return;\n    }\n    let applied = 0;\n    for (const row of result.rows) {\n      if (this.applied.has(row.sk)) {\n        continue;\n      }\n      const marker = this.tags.get(row.tag);\n      if (marker) {\n        // `set` on a key already there keeps its place in the LRU order: being\n        // revalidated elsewhere is not a use.\n        this.tags.set(row.tag, mergeMarkers(marker, row.marker));\n      } else if (this.reading.has(row.tag)) {\n        this.pendingRows.set(\n          row.tag,\n          mergeMarkers(this.pendingRows.get(row.tag), row.marker),\n        );\n      } else {\n        // A tag this instance does not track is read from its marker when it\n        // is next needed - but not yet marked applied, because that read may\n        // miss this very revalidation: the writer puts the log row and the\n        // marker at the same time, and the read is an eventually consistent\n        // `BatchGetItem` that can land milliseconds after the row showed here.\n        // Marked applied, the row was skipped by every query the lookback\n        // returned it to, and the pre-revalidation marker stood until the\n        // rolling re-read. Left unmarked, the next refresh applies it to\n        // whatever that read found; it costs no read, only the row being\n        // looked at again while it is inside the lookback.\n        continue;\n      }\n      this.applied.set(row.sk, row.at);\n      applied++;\n    }\n    this.lastLogRead = at;\n    this.advance(at - REVALIDATION_LOG_LOOKBACK_MS);\n    this.debug(\n      `read ${result.rows.length} revalidation log rows (${applied} applied)`,\n    );\n  }\n\n  /**\n   * The tags to read on this refresh, at most one `BatchGetItem`'s worth:\n   * those whose read failed, then those whose re-read has come due, in the\n   * order they were last read.\n   */\n  private due(at: number): string[] {\n    const due: string[] = [];\n    for (const tag of this.unread) {\n      if (due.length >= BATCH_GET_MAX_KEYS) return due;\n      due.push(tag);\n    }\n    // Known in time order, and each due at most `jitter` earlier than the\n    // tags after it: past a tag due more than that from now, none is due.\n    const jitter = this.resyncIntervalMs * TAG_RESYNC_JITTER;\n    for (const [tag, dueAt] of this.dueAt) {\n      if (due.length >= BATCH_GET_MAX_KEYS || dueAt - jitter > at) {\n        break;\n      }\n      if (dueAt <= at && !this.unread.has(tag)) {\n        due.push(tag);\n      }\n    }\n    return due;\n  }\n\n  /**\n   * Forget every tracked marker, and follow the log from `at`: what is needed\n   * next is read from its marker as it is needed, spread over the requests\n   * that need it, rather than every tracked tag re-read at once.\n   */\n  private forget(at: number, why: string): void {\n    this.debug(`forgetting ${this.tags.size} tracked tags: ${why}`);\n    this.tags.clear();\n    this.dueAt.clear();\n    this.unread.clear();\n    this.applied.clear();\n    this.cursor = at - REVALIDATION_LOG_LOOKBACK_MS;\n    this.lastLogRead = at;\n  }\n\n  /**\n   * Move the cursor forward to `cursor`, forgetting applied rows before it:\n   * no query returns them again.\n   */\n  private advance(cursor: number): void {\n    if (cursor <= this.cursor) {\n      return;\n    }\n    this.cursor = cursor;\n    for (const [sk, at] of this.applied) {\n      if (at < cursor) {\n        this.applied.delete(sk);\n      }\n    }\n  }\n\n  /**\n   * Read `tags` from the table, and report whether that worked. A read that\n   * fails leaves them tracked as they were, and the next refresh reads them\n   * again: the same \"assume the entry is valid\" the incremental cache has\n   * always answered with, rather than a read on every request while DynamoDB\n   * is unavailable.\n   */\n  private async readInto(tags: string[]): Promise<boolean> {\n    if (tags.length === 0) {\n      return true;\n    }\n    const at = this.clock();\n    try {\n      const read = await this.markers!.read(tags);\n      for (const tag of tags) {\n        this.unread.delete(tag);\n        this.remember(\n          tag,\n          mergeMarkers(\n            mergeMarkers(this.tags.get(tag), read.get(tag)),\n            this.takePendingRows(tag),\n          ),\n        );\n        this.known(tag, at);\n      }\n      this.debug(`read ${tags.length} tag markers (${read.size} set)`);\n      return true;\n    } catch (error) {\n      console.error(\"Error reading tag markers:\", error);\n      this.trackUnread(tags);\n      for (const tag of tags) {\n        this.unread.add(tag);\n        const pending = this.takePendingRows(tag);\n        if (pending) {\n          this.remember(tag, mergeMarkers(this.tags.get(tag), pending));\n        }\n      }\n      return false;\n    }\n  }\n\n  private takePendingRows(tag: string): TagMarker | undefined {\n    const pending = this.pendingRows.get(tag);\n    this.pendingRows.delete(tag);\n    return pending;\n  }\n\n  /** Record that `tag`'s marker was known from the table at `at`. */\n  private known(tag: string, at: number): void {\n    this.dueAt.delete(tag);\n    this.dueAt.set(\n      tag,\n      at + this.resyncIntervalMs * (1 - TAG_RESYNC_JITTER * this.random()),\n    );\n  }\n\n  private remember(tag: string, marker: TagMarker): void {\n    this.tags.delete(tag);\n    this.tags.set(tag, marker);\n    for (const oldest of this.tags.keys()) {\n      if (this.tags.size <= this.maxTrackedTags) {\n        break;\n      }\n      this.tags.delete(oldest);\n      this.dueAt.delete(oldest);\n      this.unread.delete(oldest);\n    }\n  }\n\n  private touch(tag: string): void {\n    const marker = this.tags.get(tag);\n    if (marker) {\n      this.remember(tag, marker);\n    }\n  }\n}\n\n/**\n * The longest a log row's put may take and still be seen by every reader: half\n * the lookback, leaving the rest for writers' clocks and eventually consistent\n * queries.\n */\nconst MAX_LOG_PUT_MS = REVALIDATION_LOG_LOOKBACK_MS / 2;\n\n/**\n * A marker as read from the table or the log, keeping whatever this instance\n * already knows that the read does not show yet: reads are eventually\n * consistent, and a read straight after this instance's own revalidation could\n * otherwise take it back.\n */\nexport function mergeMarkers(\n  local: TagMarker | undefined,\n  remote: TagMarker | undefined,\n): TagMarker {\n  if (!local) {\n    return remote ?? {};\n  }\n  if (!remote) {\n    return local;\n  }\n  // `expiredAt` is written with `staleAt`, so it belongs to whichever is\n  // newer - unless that revalidation's profile had no `expire` and left it.\n  const [older, newer] =\n    (local.staleAt ?? -1) > (remote.staleAt ?? -1)\n      ? [remote, local]\n      : [local, remote];\n  return {\n    ...applyMarker(older, newer),\n    revalidatedAt: maxDefined(local.revalidatedAt, remote.revalidatedAt),\n  };\n}\n\nfunction maxDefined(a: number | undefined, b: number | undefined) {\n  if (a === undefined) return b;\n  if (b === undefined) return a;\n  return Math.max(a, b);\n}\n\n/**\n * The cache bucket, as the handlers use it: whole objects read and written as\n * UTF-8 text under the keys above.\n */\nexport class CacheBucket {\n  constructor(\n    private readonly client: S3Client,\n    private readonly bucketName: string,\n  ) {}\n\n  /**\n   * The body of the object at `key`, or `undefined` when there is none (`NoSuchKey`, or an\n   * empty response body). Any other error is thrown: the handlers disagree on\n   * whether one is worth logging.\n   */\n  async get(key: string): Promise<string | undefined> {\n    try {\n      const response = await this.client.send(\n        new GetObjectCommand({ Bucket: this.bucketName, Key: key }),\n      );\n      if (!response.Body) {\n        return undefined;\n      }\n      return await response.Body.transformToString(\"utf-8\");\n    } catch (error) {\n      if (error instanceof NoSuchKey) {\n        return undefined;\n      }\n      throw error;\n    }\n  }\n\n  /** Write `body` as a JSON object at `key`. */\n  async putJson(key: string, body: string): Promise<void> {\n    await this.client.send(\n      new PutObjectCommand({\n        Bucket: this.bucketName,\n        Key: key,\n        Body: body,\n        ContentType: \"application/json; charset=utf-8\",\n      }),\n    );\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-cache-store.js","sourceRoot":"","sources":["../../src/adapter/aws-cache-store.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n  The S3 / DynamoDB plumbing shared by every cdk-nextjs cache handler: the\n  incremental `cacheHandler` (`S3CacheHandler`) and the `cacheHandlers` for\n  `'use cache'` / `'use cache: remote'`.\n\n  What lives here is what has to agree between them - where the configuration\n  comes from, how a cache key becomes an S3 key, and what a tag's marker row in\n  the revalidation table looks like and means. A `revalidateTag` reaches both\n  kinds of handler, and they must read each other's markers the same way.\n*/\n/* eslint-disable import/no-extraneous-dependencies */\nimport { AsyncLocalStorage } from \"node:async_hooks\";\nimport { join } from \"node:path\";\nimport {\n  AttributeValue,\n  BatchGetItemCommand,\n  BatchGetItemCommandOutput,\n  DynamoDBClient,\n  PutItemCommand,\n  QueryCommand,\n  QueryCommandOutput,\n  UpdateItemCommand,\n} from \"@aws-sdk/client-dynamodb\";\nimport {\n  GetObjectCommand,\n  NoSuchKey,\n  PutObjectCommand,\n  S3Client,\n} from \"@aws-sdk/client-s3\";\nimport { cacheKeyFileName, cacheObjectName, sha256Hex } from \"./cache-utils\";\n\n/**\n * Where the cache lives, as the constructs pass it to the compute through the\n * environment (`NextjsFunctions`, `NextjsContainers`). Empty strings for what is\n * not configured, which each handler reads as \"that layer is disabled\".\n */\nexport interface AwsCacheConfig {\n  /** `CDK_NEXTJS_CACHE_BUCKET_NAME`. */\n  bucketName: string;\n  /** `CDK_NEXTJS_REVALIDATION_TABLE_NAME`. */\n  tableName: string;\n  /** `AWS_REGION`, `us-east-1` when unset. */\n  region: string;\n  /** `CDK_NEXTJS_BUILD_ID`: every S3 key and every marker row is scoped to it. */\n  buildId: string;\n}\n\n/** The configuration from the environment. */\nexport function resolveAwsCacheConfig(): AwsCacheConfig {\n  return {\n    bucketName: process.env.CDK_NEXTJS_CACHE_BUCKET_NAME || \"\",\n    tableName: process.env.CDK_NEXTJS_REVALIDATION_TABLE_NAME || \"\",\n    region: process.env.AWS_REGION || \"us-east-1\",\n    buildId: process.env.CDK_NEXTJS_BUILD_ID || \"\",\n  };\n}\n\n/**\n * `{buildId}/{cacheKey}.json`, the incremental cache's key convention.\n *\n * The root path becomes `index`, and a leading slash is dropped so there is no\n * empty folder under the build prefix. Everything this returns ends in `.json`,\n * which is what keeps it disjoint from {@link useCacheS3Key}.\n */\nexport function buildS3Key(buildId: string, cacheKey: string): string {\n  return join(buildId, cacheKeyFileName(cacheKey));\n}\n\n/** `{buildId}/` + {@link cacheObjectName}: the S3 object an entry is stored in. */\nexport function s3ObjectKey(buildId: string, cacheKey: string): string {\n  return join(buildId, cacheObjectName(cacheKey));\n}\n\n/**\n * The folder under the build prefix that `'use cache'` entries are stored in.\n * @see useCacheS3Key\n */\nexport const USE_CACHE_KEY_PREFIX = \"_use-cache\";\n\n/**\n * `{buildId}/_use-cache/{hash}.entry`, where a `cacheHandlers` entry is stored.\n *\n * Hashed because a `'use cache'` key is the serialized arguments of the call and\n * has no length limit, where an S3 key stops at 1024 bytes. The `.entry` suffix\n * rather than `.json` is what makes a collision with the incremental cache\n * impossible rather than unlikely: every object {@link s3ObjectKey} names ends\n * in `.json` or `.long`, including one for a route that happens to be named\n * `/_use-cache/…`.\n * Still under the build prefix, so post-deploy pruning drops them with the build.\n */\nexport function useCacheS3Key(buildId: string, keyHash: string): string {\n  return join(buildId, USE_CACHE_KEY_PREFIX, `${keyHash}.entry`);\n}\n\n/**\n * The `durations` Next.js 16 passes a tag revalidation for a profile:\n * `revalidateTag(\"posts\", \"max\")` arrives as `{ expire: <the profile's expire> }`.\n * Absent for `updateTag` and a bare `revalidateTag`, which expire immediately.\n */\nexport interface RevalidateDurations {\n  expire?: number;\n}\n\n/**\n * A tag's marker row, as timestamps in milliseconds. Written by\n * {@link markerUpdate}; each field is absent until a revalidation of that shape\n * has happened.\n */\nexport interface TagMarker {\n  /** Expired outright: `updateTag`, or `revalidateTag` with no profile. */\n  revalidatedAt?: number;\n  /** Stale from here: `revalidateTag(tag, profile)`. */\n  staleAt?: number;\n  /** When the profile's `expire` runs out, which may be in the future. */\n  expiredAt?: number;\n}\n\n/**\n * What the tag markers say about an entry: untouched, served stale while a\n * background render replaces it, or expired and re-rendered before answering.\n */\nexport type RevalidationState = \"fresh\" | \"stale\" | \"expired\";\n\n/**\n * What `marker` means for an entry created at `createdAt`, at `now`.\n *\n * `expiredAt` in the future is a profile's `expire` that has not come yet,\n * compared the way Next.js's `areTagsExpired` does.\n */\nexport function markerState(\n  marker: TagMarker,\n  createdAt: number,\n  now: number,\n): RevalidationState {\n  const { revalidatedAt, expiredAt, staleAt } = marker;\n  if (\n    (revalidatedAt !== undefined && revalidatedAt > createdAt) ||\n    (expiredAt !== undefined && expiredAt <= now && expiredAt > createdAt)\n  ) {\n    return \"expired\";\n  }\n  if (staleAt !== undefined && staleAt > createdAt) {\n    return \"stale\";\n  }\n  return \"fresh\";\n}\n\n/**\n * The clock every tag marker is stamped with, and every entry timestamp it is\n * compared against: the one Next.js stamps `CacheEntry.timestamp` with\n * (`performance.timeOrigin + performance.now()`, in `use-cache-wrapper.js` and\n * the default handler), rather than `Date.now()`. Both handlers write the same\n * marker rows, so both have to use it: two clocks on one row let the last writer\n * decide which clock the others compare against, and they drift apart for as\n * long as a Lambda sandbox or Fargate task lives.\n */\nexport function markerClock(): number {\n  return performance.timeOrigin + performance.now();\n}\n\n/**\n * The marker fields a tag revalidated at `now` sets.\n *\n * Without `durations` - `updateTag`, or `revalidateTag` with no profile - the\n * tag's entries expire immediately (`revalidatedAt`). With them the entries go\n * stale now and expire after the profile's `expire`, the same pair of\n * timestamps Next.js's `FileSystemCache.revalidateTag` records. A profile with\n * no `expire` sets only `staleAt`, and whatever `expiredAt` the tag had stays.\n */\nexport function markerFor(\n  now: number,\n  durations: RevalidateDurations | undefined,\n): TagMarker {\n  if (!durations) {\n    return { revalidatedAt: now };\n  }\n  if (durations.expire === undefined) {\n    return { staleAt: now };\n  }\n  return { staleAt: now, expiredAt: now + durations.expire * 1000 };\n}\n\nconst MARKER_FIELDS = [\"revalidatedAt\", \"staleAt\", \"expiredAt\"] as const;\n\n/**\n * `existing` with the fields `update` sets, as a {@link markerUpdate} leaves\n * the row: a field `update` does not set keeps its value.\n */\nexport function applyMarker(\n  existing: TagMarker | undefined,\n  update: TagMarker,\n): TagMarker {\n  const marker = { ...existing };\n  for (const field of MARKER_FIELDS) {\n    if (update[field] !== undefined) {\n      marker[field] = update[field];\n    }\n  }\n  return marker;\n}\n\n/** The marker-row update that sets {@link markerFor}'s fields. */\nexport function markerUpdate(\n  now: number,\n  durations: RevalidateDurations | undefined,\n): Pick<\n  ConstructorParameters<typeof UpdateItemCommand>[0],\n  \"UpdateExpression\" | \"ExpressionAttributeValues\"\n> {\n  const marker = markerFor(now, durations);\n  const fields = MARKER_FIELDS.filter((field) => marker[field] !== undefined);\n  return {\n    UpdateExpression: `SET ${fields.map((field) => `${field} = :${field}`).join(\", \")}`,\n    ExpressionAttributeValues: Object.fromEntries(\n      fields.map((field) => [`:${field}`, { N: String(marker[field]) }]),\n    ),\n  };\n}\n\n/** A DynamoDB number attribute as a number, or `undefined` when absent. */\nfunction numberAttribute(\n  value: AttributeValue | undefined,\n): number | undefined {\n  return value?.N === undefined ? undefined : Number(value.N);\n}\n\n/** The marker fields of a marker or log row. */\nfunction markerOf(item: Record<string, AttributeValue>): TagMarker {\n  return {\n    revalidatedAt: numberAttribute(item.revalidatedAt),\n    staleAt: numberAttribute(item.staleAt),\n    expiredAt: numberAttribute(item.expiredAt),\n  };\n}\n\n/** DynamoDB's cap on keys in one `BatchGetItem`. */\nexport const BATCH_GET_MAX_KEYS = 100;\n\n/**\n * How often, at most, an instance catches up on revalidations other instances\n * ran, unless `CDK_NEXTJS_TAG_REFRESH_MS` says otherwise: the staleness window\n * for a `revalidateTag` run elsewhere. Every cache hit checks its tags'\n * markers, and every marker of a deployment shares one partition key, so\n * reading them per request capped a route's cache hits at the partition's read\n * throughput (~1,900 req/s on NextjsRegionalFunctions). Once a second, from the\n * revalidation log, the reads scale with instances instead of requests or tags.\n */\nexport const DEFAULT_TAG_REFRESH_MS = 1000;\n\n/**\n * How far past `refreshIntervalMs` the last refresh may have settled before a\n * `'use cache'` request waits for the next one (see\n * {@link TrackedTagMarkers.behind}). An instance serving steady traffic stays\n * inside it; one that sat idle, or frozen between Lambda invocations, does not.\n */\nexport const TAG_REFRESH_GRACE_MS = 1000;\n\n/** DynamoDB's limit on a sort key, in UTF-8 bytes. */\nexport const MAX_SORT_KEY_BYTES = 1024;\n\n/**\n * `#<sha256(tag)>`, standing in for a tag in a sort key it would push past\n * {@link MAX_SORT_KEY_BYTES}. Next.js caps the tags an app names, but not an\n * implicit `_N_T_/…` tag, which is as long as its path, and a rejected write\n * left `revalidatePath` on a long path recorded nowhere.\n */\nexport function hashedTag(tag: string): string {\n  return `#${sha256Hex(tag)}`;\n}\n\n/**\n * The longest tag a sort key spells out; past it, {@link sortKeyTag} hashes\n * it. One cap for every row the tag is in, so a row's writer and reader agree\n * without each working out what else shares its key. It leaves room for the\n * most any row puts beside the tag: a mapping row's `#<buildId>/#<sha256>`,\n * with the build ID capped at `MAX_BUILD_ID_BYTES`.\n */\nexport const MAX_TAG_BYTES = 768;\n\n/** `tag` as a sort key spells it: itself, or {@link hashedTag} past {@link MAX_TAG_BYTES}. */\nexport function sortKeyTag(tag: string): string {\n  return Buffer.byteLength(tag) <= MAX_TAG_BYTES ? tag : hashedTag(tag);\n}\n\n/**\n * The bare-tag marker rows of the revalidation table (`pk = buildId`,\n * `sk = tag`, or {@link hashedTag} past {@link MAX_TAG_BYTES}), which record when a tag\n * was last revalidated and how.\n *\n * The table also holds the incremental cache's `tag#s3Key` mapping rows, which\n * are its own business and stay in `S3CacheHandler`: only the markers mean the\n * same thing to every handler. What an instance keeps of them between reads is\n * {@link TrackedTagMarkers}.\n */\nexport class TagMarkerTable {\n  constructor(\n    private readonly client: DynamoDBClient,\n    private readonly tableName: string,\n    private readonly buildId: string,\n  ) {}\n\n  /**\n   * Record `tag`'s revalidation at `now`. See {@link markerUpdate}.\n   *\n   * Returns the row as this write left it, so the instance that wrote it can\n   * track it rather than read it back: reads are eventually consistent, and a\n   * read-back racing replication could return the marker from before the write.\n   */\n  async write(\n    tag: string,\n    now: number,\n    durations: RevalidateDurations | undefined,\n  ): Promise<TagMarker | undefined> {\n    const response = await this.client.send(\n      new UpdateItemCommand({\n        TableName: this.tableName,\n        Key: {\n          pk: { S: this.buildId },\n          sk: { S: sortKeyTag(tag) },\n        },\n        ...markerUpdate(now, durations),\n        ReturnValues: \"ALL_NEW\",\n      }),\n    );\n    return response?.Attributes ? markerOf(response.Attributes) : undefined;\n  }\n\n  /**\n   * The marker rows for `tags` that exist, by tag, in one `BatchGetItem` per\n   * {@link BATCH_GET_MAX_KEYS} tags rather than a `GetItem` each: a page\n   * carries its whole implicit `_N_T_/…` chain plus the app's own tags, a\n   * page with a few fetches checks each of them too, and every one is on the\n   * request path. A tag with no row is absent from the result.\n   */\n  async read(tags: string[]): Promise<Map<string, TagMarker>> {\n    const { tableName, buildId } = this;\n    const unique = Array.from(new Set(tags));\n    const markers = new Map<string, TagMarker>();\n\n    for (let i = 0; i < unique.length; i += BATCH_GET_MAX_KEYS) {\n      // A hashed sort key names no tag, so each row is matched back by key.\n      const tagBySk = new Map(\n        unique\n          .slice(i, i + BATCH_GET_MAX_KEYS)\n          .map((tag) => [sortKeyTag(tag), tag]),\n      );\n      let keys: Record<string, AttributeValue>[] | undefined = Array.from(\n        tagBySk.keys(),\n        (sk) => ({ pk: { S: buildId }, sk: { S: sk } }),\n      );\n      // `UnprocessedKeys` is DynamoDB declining part of the batch under load;\n      // a marker left unread is a revalidation missed, so it is asked again.\n      for (let attempt = 0; keys?.length && attempt < 3; attempt++) {\n        const response: BatchGetItemCommandOutput = await this.client.send(\n          new BatchGetItemCommand({\n            RequestItems: {\n              [tableName]: {\n                Keys: keys,\n                ProjectionExpression: \"sk, revalidatedAt, staleAt, expiredAt\",\n              },\n            },\n          }),\n        );\n        for (const item of response.Responses?.[tableName] ?? []) {\n          const tag = tagBySk.get(item.sk?.S ?? \"\");\n          if (tag !== undefined) {\n            markers.set(tag, markerOf(item));\n          }\n        }\n        keys = response.UnprocessedKeys?.[tableName]?.Keys;\n      }\n      if (keys?.length) {\n        throw new Error(\n          `DynamoDB left ${keys.length} tag markers unread after retrying`,\n        );\n      }\n    }\n    return markers;\n  }\n}\n\n/**\n * How long a revalidation log row is kept (`ttl`, epoch seconds). DynamoDB never\n * deletes an item before its TTL, only some time after, so a reader that last\n * queried less than this long ago (less a margin for writers' clocks) is sure\n * to find every row it has not seen yet.\n */\nexport const REVALIDATION_LOG_TTL_MS = 15 * 60 * 1000;\n\n/** The most `Query` pages one {@link RevalidationLog.query} reads. */\nexport const REVALIDATION_LOG_MAX_PAGES = 5;\n\n/** How many sort keys {@link RevalidationLog.put} tries before giving up. */\nconst LOG_PUT_ATTEMPTS = 5;\n\n/** Digits a log row's timestamp is zero-padded to, so sort keys sort by time. */\nconst LOG_SK_DIGITS = 15;\n\n/** A revalidation read back from the log. */\nexport interface RevalidationLogRow {\n  /** The row's sort key: unique per revalidation of a tag. */\n  sk: string;\n  /** When it was written, on the writer's `Date.now()`. */\n  at: number;\n  tag: string;\n  /** The marker fields the revalidation set, as {@link markerFor} returns them. */\n  marker: TagMarker;\n}\n\n/**\n * The revalidation log: one row per tag revalidation (`pk = <buildId>#log`,\n * `sk = <Date.now(), zero-padded>#<tag>`), which expires after\n * {@link REVALIDATION_LOG_TTL_MS}. A tag past {@link MAX_TAG_BYTES} is\n * {@link hashedTag} there, and spelled out in the row's `longTag` instead.\n *\n * The marker rows stay the source of truth. The log exists so an instance\n * can ask \"what was revalidated since I last looked?\" in one `Query`, instead\n * of re-reading every tag it tracks to find out that almost none changed. Every\n * marker row of a deployment shares one partition, and those re-reads from a\n * handful of busy instances were enough to throttle it.\n *\n * The sort key's timestamp is the writer's wall clock (`Date.now()`), not the\n * performance clock ({@link markerClock}) the marker values are stamped with by both\n * handlers: it only orders rows for readers' cursors, which are on their own\n * wall clocks, and is never compared with an entry's timestamp.\n */\nexport class RevalidationLog {\n  private readonly pk: string;\n\n  constructor(\n    private readonly client: DynamoDBClient,\n    private readonly tableName: string,\n    buildId: string,\n  ) {\n    this.pk = `${buildId}#log`;\n  }\n\n  /**\n   * Record that `tag` was revalidated at `at` (`Date.now()`), setting `marker`.\n   *\n   * Two revalidations of `tag` in the same millisecond would share a sort key,\n   * and the second would overwrite the first. So the row is only written where\n   * its key is free, and on a collision it moves to the next millisecond, up\n   * to {@link LOG_PUT_ATTEMPTS} times.\n   */\n  async put(tag: string, at: number, marker: TagMarker): Promise<void> {\n    const skTag = sortKeyTag(tag);\n    for (let attempt = 1; ; attempt++) {\n      const item: Record<string, AttributeValue> = {\n        pk: { S: this.pk },\n        sk: { S: `${logSkPrefix(at)}#${skTag}` },\n        ttl: { N: String(Math.ceil((at + REVALIDATION_LOG_TTL_MS) / 1000)) },\n        ...(skTag !== tag && { longTag: { S: tag } }),\n      };\n      for (const field of MARKER_FIELDS) {\n        const value = marker[field];\n        if (value !== undefined) {\n          item[field] = { N: String(value) };\n        }\n      }\n      try {\n        await this.client.send(\n          new PutItemCommand({\n            TableName: this.tableName,\n            Item: item,\n            ConditionExpression: \"attribute_not_exists(sk)\",\n          }),\n        );\n        return;\n      } catch (error) {\n        if (\n          (error as Error | undefined)?.name !==\n            \"ConditionalCheckFailedException\" ||\n          attempt >= LOG_PUT_ATTEMPTS\n        ) {\n          throw error;\n        }\n        at = Math.floor(at) + 1;\n      }\n    }\n  }\n\n  /**\n   * The rows written at or after `since` (`Date.now()`), oldest first.\n   * `truncated` when there were more than {@link REVALIDATION_LOG_MAX_PAGES}\n   * pages of them, and `rows` is only the start.\n   *\n   * Eventually consistent: a row written a moment ago may not show yet, which\n   * is what the reader's lookback is for.\n   */\n  async query(\n    since: number,\n  ): Promise<{ rows: RevalidationLogRow[]; truncated: boolean }> {\n    const rows: RevalidationLogRow[] = [];\n    let startKey: Record<string, AttributeValue> | undefined;\n    for (let page = 0; page < REVALIDATION_LOG_MAX_PAGES; page++) {\n      const response: QueryCommandOutput = await this.client.send(\n        new QueryCommand({\n          TableName: this.tableName,\n          KeyConditionExpression: \"pk = :pk AND sk >= :since\",\n          ExpressionAttributeValues: {\n            \":pk\": { S: this.pk },\n            \":since\": { S: logSkPrefix(Math.max(0, since)) },\n          },\n          ProjectionExpression:\n            \"sk, longTag, revalidatedAt, staleAt, expiredAt\",\n          ExclusiveStartKey: startKey,\n        }),\n      );\n      for (const item of response.Items ?? []) {\n        const sk = item.sk?.S;\n        // `<digits>#<tag>`: the tag is everything after the fixed-width\n        // timestamp, `#`s included.\n        if (sk === undefined || sk[LOG_SK_DIGITS] !== \"#\") {\n          continue;\n        }\n        rows.push({\n          sk,\n          at: Number(sk.slice(0, LOG_SK_DIGITS)),\n          tag: item.longTag?.S ?? sk.slice(LOG_SK_DIGITS + 1),\n          marker: markerOf(item),\n        });\n      }\n      startKey = response.LastEvaluatedKey;\n      if (!startKey) {\n        return { rows, truncated: false };\n      }\n    }\n    return { rows, truncated: true };\n  }\n}\n\nfunction logSkPrefix(at: number): string {\n  return String(Math.floor(at)).padStart(LOG_SK_DIGITS, \"0\");\n}\n\n/**\n * How far behind the last query's start the next one starts reading the log:\n * the room for the `Query` being eventually consistent and for writers' clocks\n * running behind the reader's. Rows inside it are read again, and dropped as\n * already applied.\n */\nexport const REVALIDATION_LOG_LOOKBACK_MS = 5000;\n\n/**\n * The longest {@link TrackedTagMarkers} trusts the log alone for a tag before\n * reading its marker row again. The log is the fast path, but the marker rows\n * are the source of truth: a log row whose write failed would otherwise be\n * missed for as long as the tag stays tracked.\n *\n * Rolling, not all at once: each refresh re-reads at most\n * {@link BATCH_GET_MAX_KEYS} of the tags due, oldest first. Re-reading them all\n * together cost ~500 RCU at 1000 tags - a fleet started by one load test did it\n * in the same minute, 12,800 RCU, and throttled - and would be ~5,000 RCU at\n * {@link DEFAULT_MAX_TRACKED_TAGS}, past what the one partition serves in a\n * second. Spread out, 10,000 tracked tags cost ~8 RCU a second per instance.\n *\n * Each tag is due at a random 75-100% of this after it was last read, so tags\n * first read together - an instance warming up - do not all come due together\n * again every interval: the load test that measured the rolling re-read saw\n * its warm-up's reads return as a 30-36 RCU/s bump ten minutes later.\n */\nexport const DEFAULT_TAG_RESYNC_MS = 10 * 60 * 1000;\n\n/** The fraction of {@link DEFAULT_TAG_RESYNC_MS} a tag may come due early by. */\nconst TAG_RESYNC_JITTER = 0.25;\n\n/**\n * How long since the last successful log query the log can still be trusted to\n * hold every row not read yet: its TTL less a margin for writers' clocks. Past\n * it - a Lambda frozen between invocations, a run of failed queries - the\n * tracked markers are forgotten, to be read again as they are needed, and the\n * log is followed from there.\n */\nexport const MAX_REVALIDATION_LOG_GAP_MS =\n  REVALIDATION_LOG_TTL_MS - 5 * 60 * 1000;\n\n/**\n * The most tags one instance tracks. Past it the least recently used is\n * forgotten, which costs a read the next time it is needed: an untracked tag\n * is read before it is trusted.\n *\n * A tracked tag costs memory (~2 MB at this bound) and its share of the rolling\n * re-read, not a read every refresh, so the bound is set by how many tags an\n * instance really uses. Every path is a tag of its own (`_N_T_/<path>`), and at\n * 1000 an app of 1000 tagged pages kept evicting what it was about to need:\n * half its requests re-read a marker.\n */\nexport const DEFAULT_MAX_TRACKED_TAGS = 10_000;\n\n/**\n * The revalidation table's marker rows and its log, which are only ever used\n * together, or neither for tags local to this process.\n */\nexport type TagTable =\n  | { markers: TagMarkerTable; log: RevalidationLog }\n  | { markers?: undefined; log?: undefined };\n\n/** How {@link TrackedTagMarkers} is built. */\nexport type TrackedTagMarkersOptions = TagTable & {\n  /**\n   * How often, at most, {@link TrackedTagMarkers.refresh} reads anything.\n   * @default DEFAULT_TAG_REFRESH_MS\n   */\n  refreshIntervalMs?: number;\n  maxTrackedTags?: number;\n  /** @see DEFAULT_TAG_RESYNC_MS */\n  resyncIntervalMs?: number;\n  /** The wall clock the log's cursor and the intervals are kept on. */\n  clock?: () => number;\n  /** `Math.random`, for when each tag's re-read comes due. */\n  random?: () => number;\n  debug?: (message: string) => void;\n  /**\n   * Whether the process can be frozen with a refresh in flight, as a Lambda\n   * sandbox is between invocations: then a timer checks it kept running, and\n   * one that spanned a freeze does not count. A container is never frozen,\n   * so it skips the timer and waits for the refresh in flight, however slow.\n   * @default false\n   */\n  canFreeze?: boolean;\n};\n\n/**\n * One instance's copy of the marker rows of the tags it has needed, kept\n * current through the {@link RevalidationLog}: the process's one tag manifest\n * (`sharedTagManifest`), for the `'use cache'` handlers and the incremental\n * cache alike.\n *\n * Next.js's built-in `'use cache'` handler keeps tags in a module-level map\n * (`tags-manifest.external.js`) that only its own `updateTags` writes, and its\n * `refreshTags` is a no-op, so a `revalidateTag` on one instance never reaches\n * the others: they keep serving the revalidated entry, including inside pages\n * that are being re-rendered *because* of that revalidation. The\n * `cacheHandlers` interface's answer is `refreshTags`, \"called before starting\n * a new request … to refresh the local tags manifest\", and this is that\n * manifest, backed by the same marker rows the incremental cache's\n * `revalidateTag` writes (`pk = buildId`, `sk = tag`).\n *\n * The cost is bounded per instance, not per request:\n * - {@link ensure} reads a tag's marker the first time it is needed and not\n *   again until it is evicted, so a tag costs one read per instance, not one\n *   per request. An entry created since {@link completeSince} needs no read\n *   at all.\n * - {@link refresh}, at most once per `refreshIntervalMs`, sends one `Query`\n *   for the log rows written since the last one, and applies those of tags\n *   this instance tracks. Concurrent callers share it. Alongside, it re-reads\n *   the markers of up to {@link BATCH_GET_MAX_KEYS} tags not read for\n *   {@link DEFAULT_TAG_RESYNC_MS}, in one `BatchGetItem`.\n * A revalidation on another instance is therefore seen within\n * `refreshIntervalMs` (plus the query itself) - by `'use cache'`, from the\n * first request after the query returns, since its `refreshTags` does not wait\n * for it (see `tagMethods`) unless the instance is {@link behind}, which the\n * runtime settles before a page render starts ({@link catchUp}). The instance\n * that ran it applies it itself, at once, with {@link set}.\n */\nexport class TrackedTagMarkers {\n  private readonly markers: TagMarkerTable | undefined;\n  private readonly log: RevalidationLog | undefined;\n  private readonly refreshIntervalMs: number;\n  private readonly maxTrackedTags: number;\n  private readonly resyncIntervalMs: number;\n  private readonly clock: () => number;\n  private readonly random: () => number;\n  private readonly debug: (message: string) => void;\n  /** By tag, least recently used first. */\n  private readonly tags = new Map<string, TagMarker>();\n  /**\n   * When each tracked tag's marker is due to be read again: a random 75-100%\n   * of `resyncIntervalMs` after it was last known from the table - read,\n   * written here, or new. In the order they became known, least recent first.\n   */\n  private readonly dueAt = new Map<string, number>();\n  private readonly reading = new Map<string, Promise<void>>();\n  /**\n   * Log rows for tags whose first read is in flight, merged by tag: the read\n   * may have been answered before the revalidation, so they are applied to its\n   * result rather than dropped.\n   */\n  private readonly pendingRows = new Map<string, TagMarker>();\n  /**\n   * Log rows for tags not tracked and not being read, merged by tag, oldest\n   * first: what the log has said about them since {@link completeSince}. Taken\n   * into a tag's marker when it is read or written.\n   */\n  private readonly logOnly = new Map<string, TagMarker>();\n  /** See {@link completeSince}. */\n  private floor: number;\n  /**\n   * The future `expiredAt`s of markers dropped since, as `[from, to]`, in\n   * order: once `from` is past, {@link completeSince} moves to `to`, and not\n   * before, since only then does it expire anything. `from` and `to` are the\n   * same until spans are merged for space ({@link laterFloor}).\n   */\n  private readonly laterFloors: [number, number][] = [];\n  /** The in-memory entry stores judged by {@link completeSince}. */\n  private readonly entryStores: {\n    oldestTimestamp: (scan: boolean) => number;\n    holdsAny: () => boolean;\n  }[] = [];\n  /** How many times {@link forget} ran: a read started before one is made again. */\n  private forgotten = 0;\n  /** Tracked tags whose read failed, for the next refresh to read again. */\n  private readonly unread = new Set<string>();\n  /**\n   * Set inside a page render {@link catchUp} let go, for that render alone.\n   * See {@link behindInRender}.\n   */\n  private readonly caughtUpRender = new AsyncLocalStorage<true>();\n  /** When `sync` last scanned the entry stores ({@link oldestEntry}). */\n  private lastEntryScan = -Infinity;\n  /**\n   * No `logOnly` row is known by it or earlier, so a {@link pruneLogged}\n   * against it or earlier drops nothing: a marker is only ever known by later,\n   * as its `expiredAt` passes.\n   */\n  private prunedAgainst = -Infinity;\n  /** When the last refresh started, or was skipped. */\n  private lastRefresh = -Infinity;\n  /**\n   * The refresh in flight. One left open across a freeze comes back after the\n   * thaw with what it read before, so {@link refresh} waits for it and then\n   * for a fresh one, rather than the runtime waiting for it before the freeze:\n   * that would bill every Lambda invocation for the query's tail.\n   */\n  private refreshing: Promise<void> | undefined;\n  /**\n   * When {@link refreshing} last showed the process running: a timer ticks\n   * while it is in flight, and a tick that comes late, or none at all, means\n   * the process was paused - frozen - since it started.\n   */\n  private lastTick = -Infinity;\n  /** Whether a tick came late since {@link refreshing} started. */\n  private pausedWhileRefreshing = false;\n  private ticker: ReturnType<typeof setInterval> | undefined;\n  private readonly canFreeze: boolean;\n  /**\n   * When the last refresh settled, either way, unless it spanned a pause: what\n   * it knows is from then. See {@link behind}.\n   */\n  private settledAt: number;\n  /**\n   * Where the next log query starts (`clock()`): the last successful one's\n   * start, less {@link REVALIDATION_LOG_LOOKBACK_MS}.\n   */\n  private cursor: number;\n  /** When the last successful log query started, or the log was first read. */\n  private lastLogRead: number;\n  /** Log rows at or after the cursor already applied, by sort key. */\n  private readonly applied = new Map<string, number>();\n  /** {@link update}s of the current turn, by their arguments. */\n  private readonly updating = new Map<string, Promise<boolean>>();\n\n  constructor(options: TrackedTagMarkersOptions) {\n    this.markers = options.markers;\n    this.log = options.log;\n    this.refreshIntervalMs =\n      options.refreshIntervalMs ?? DEFAULT_TAG_REFRESH_MS;\n    this.maxTrackedTags = options.maxTrackedTags ?? DEFAULT_MAX_TRACKED_TAGS;\n    this.resyncIntervalMs = options.resyncIntervalMs ?? DEFAULT_TAG_RESYNC_MS;\n    // Looked up on each call rather than bound here, so a test's `Date.now`\n    // spy applies.\n    this.clock = options.clock ?? (() => Date.now());\n    this.random = options.random ?? Math.random;\n    this.debug = options.debug ?? (() => {});\n    this.canFreeze = options.canFreeze ?? false;\n    // Nothing is tracked yet, so nothing before this can be missed: every tag\n    // is read from its marker the first time it is needed.\n    const at = this.clock();\n    this.cursor = at - REVALIDATION_LOG_LOOKBACK_MS;\n    this.lastLogRead = at;\n    this.settledAt = at;\n    this.floor = markerClock();\n  }\n\n  /** `tag`'s marker as this instance knows it, if it tracks `tag`. */\n  get(tag: string): TagMarker | undefined {\n    return this.tags.get(tag);\n  }\n\n  /**\n   * Since when (`markerClock()`) this instance knows of every revalidation of\n   * every tag, tracked or not: tracked ones from their markers and the log,\n   * the others from the log alone (`logOnly`). So an entry created at or after\n   * it can be judged by {@link state} and {@link expiration} without\n   * {@link ensure} reading anything - which matters inside a `'use cache'`\n   * lookup, where Next.js waits for the answer and a read pushes the entry out\n   * of the static stage of a staged render.\n   *\n   * Starts at construction: the log is followed from before it. Moves to now\n   * when the tracked markers are forgotten, and past the revalidations of\n   * whatever else it lets go of - a marker evicted for space, a log row\n   * pruned - which are no longer known: to its `expiredAt` only once that is\n   * past, since a profile's `expire` can be a year out, and moving there at\n   * once would turn the read-free path off for the instance's life.\n   *\n   * A row is pruned only once it is no later than every entry held, so that\n   * costs those entries nothing. An entry stored afterwards with an older\n   * `timestamp` - Next.js stamps the start of its generation, which can\n   * outlast a lookback - is older than this too, and is read first.\n   *\n   * It does not cover a revalidation older than the log's first lookback\n   * whose `expiredAt` is still to come, which would expire an entry created\n   * after it. So the `'use cache'` handler reads an entry's tags in the\n   * background as it stores it.\n   */\n  get completeSince(): number {\n    const at = markerClock();\n    while (this.laterFloors.length > 0 && this.laterFloors[0][0] <= at) {\n      this.floor = Math.max(this.floor, this.laterFloors.shift()![1]);\n    }\n    return this.floor;\n  }\n\n  /**\n   * Register an in-memory store whose entries are judged by\n   * {@link completeSince}, by the `timestamp` of the oldest entry it holds:\n   * `logOnly` keeps the rows that could still apply to one of them, and no\n   * others. With none registered it keeps nothing. Asked with `scan` false,\n   * `oldestTimestamp` may answer early, but never late, without a scan.\n   */\n  judgeEntriesOf(\n    oldestTimestamp: (scan: boolean) => number,\n    holdsAny: () => boolean = () => oldestTimestamp(false) < Infinity,\n  ): void {\n    this.entryStores.push({ oldestTimestamp, holdsAny });\n  }\n\n  /**\n   * Track `tag` with `marker`: what this instance just wrote, which it knows\n   * without reading it back.\n   */\n  set(tag: string, marker: TagMarker): void {\n    const logged = this.logOnly.get(tag);\n    this.logOnly.delete(tag);\n    this.remember(tag, mergeMarkers(marker, logged));\n    this.known(tag, this.clock());\n  }\n\n  /**\n   * Note a use of `tags`: those of an entry this instance just stored.\n   *\n   * With the table, a tag not tracked yet is left untracked, to be read by\n   * {@link ensure} the first time an entry needs it. Nothing revalidated before\n   * the new entry was created applies to *it*, but tracking is per tag, not per\n   * entry: tracking the tag with an empty marker would also vouch for every\n   * older entry that carries it - one another instance stored in S3, or one\n   * this instance kept in memory across a {@link forget} - and a revalidation\n   * from before the log's cursor would go unseen until the rolling re-read.\n   *\n   * Without the table every revalidation is this process's own, applied with\n   * {@link set}, so a tag is tracked at once.\n   */\n  track(tags: readonly string[]): void {\n    if (!this.markers) {\n      this.trackUnread(tags);\n      return;\n    }\n    for (const tag of tags) {\n      this.touch(tag);\n    }\n  }\n\n  /**\n   * Track `tags` as they are known now, without reading them, with an empty\n   * marker for any not tracked yet.\n   */\n  private trackUnread(tags: readonly string[]): void {\n    const at = this.clock();\n    for (const tag of tags) {\n      if (!this.tags.has(tag)) {\n        this.known(tag, at);\n      }\n      this.remember(tag, this.tags.get(tag) ?? {});\n    }\n  }\n\n  /**\n   * Read the markers of whichever of `tags` this instance does not track yet.\n   * Needed before judging an entry this instance did not create, since its\n   * tags may have been revalidated at any time before.\n   */\n  async ensure(tags: readonly string[]): Promise<void> {\n    if (!this.markers) {\n      this.trackUnread(tags);\n      return;\n    }\n    const waits: Promise<void>[] = [];\n    const unread: string[] = [];\n    for (const tag of new Set(tags)) {\n      // Tracked first: a tracked tag in `reading` is only being re-read in\n      // the background (`sync`), which nothing needs to wait for.\n      const inFlight = this.reading.get(tag);\n      if (this.tags.has(tag)) {\n        this.touch(tag);\n      } else if (inFlight) {\n        waits.push(inFlight);\n      } else {\n        unread.push(tag);\n      }\n    }\n    if (unread.length > 0) {\n      waits.push(this.startRead(unread));\n    }\n    await Promise.all(waits);\n  }\n\n  /**\n   * {@link readInto} `tags`, as the read of each that whoever needs one of\n   * them next waits on ({@link reading}). Never rejects: a failed read leaves\n   * the tags tracked.\n   */\n  private startRead(tags: string[]): Promise<void> {\n    const read = this.readInto(tags).then(() => {\n      for (const tag of tags) {\n        this.reading.delete(tag);\n      }\n    });\n    for (const tag of tags) {\n      this.reading.set(tag, read);\n    }\n    return read;\n  }\n\n  /**\n   * Whether the last refresh settled more than `refreshIntervalMs` plus\n   * {@link TAG_REFRESH_GRACE_MS} ago - one that spanned a freeze counts from\n   * when it started: after the instance sat idle or frozen - or always, with\n   * a `refreshIntervalMs` of `0`. Answering from what it knows then could\n   * serve an entry revalidated elsewhere since, however long ago that was, so\n   * `refreshTags` waits for the refresh, and the runtime waits for it before\n   * a page render starts ({@link catchUp}).\n   *\n   * From when it settled, not when it started, so a slow query the runtime\n   * waited for before the render does not leave the instance behind inside\n   * it. A failed one counts too, so one request does not wait for two: the\n   * same \"assume the entry is valid\" a failed read answers with, until the\n   * next refresh, at most the interval and the grace later.\n   */\n  get behind(): boolean {\n    return (\n      this.log !== undefined &&\n      // `0` asks before every check, so every check waits for the answer.\n      (this.refreshIntervalMs === 0 || this.overdue(this.settledAt))\n    );\n  }\n\n  /**\n   * {@link behind}, as `refreshTags` asks it: never inside a page's render\n   * {@link catchUp} caught up, since the runtime settled it for that request\n   * before the render started, and a wait inside a `'use cache'` lookup is\n   * what it settled it to avoid - a render crossing the line partway through\n   * would otherwise wait after all. So a revalidation elsewhere can go unseen\n   * for a render's duration on top of the usual window.\n   *\n   * A route handler, which no catch-up precedes, waits at the plain line.\n   */\n  get behindInRender(): boolean {\n    return this.refreshIntervalMs !== 0 && this.caughtUpRender.getStore()\n      ? false\n      : this.behind;\n  }\n\n  /**\n   * Whether a registered store ({@link judgeEntriesOf}) holds any entry: one\n   * a refresh could expire. With none there is nothing to wait for even when\n   * the instance is {@link behind}, since whatever is stored from here on is\n   * newer than what the log would say - which covers the first `'use cache'`\n   * call of a process, which creates the handler inside the render.\n   */\n  get holdsEntries(): boolean {\n    return this.entryStores.some((store) => store.holdsAny());\n  }\n\n  /**\n   * {@link refresh}, waited for when the instance is {@link behind}. The\n   * runtime calls it before handing a page request to Next.js, outside the\n   * staged render whose static stage a wait inside a `'use cache'` lookup\n   * would cut short. Only for the `'use cache'` handler's entries\n   * ({@link judgeEntriesOf}): the other caches wait for the refresh where they\n   * read anyway. Not with a `refreshIntervalMs` of `0` either, where\n   * `refreshTags` asks again regardless. Then `render`, marked as caught up\n   * for ({@link behindInRender}). Rejects only as `render` does.\n   */\n  async catchUp<T>(render: () => Promise<T>): Promise<T> {\n    const log = (error: unknown) =>\n      console.error(\"Error refreshing cache tags:\", error);\n    if (this.refreshIntervalMs > 0 && this.behind) {\n      if (!this.holdsEntries) {\n        // Not caught up, so no grace: an entry stored meanwhile, by another\n        // request, makes the render's lookups wait at the plain line.\n        return render();\n      }\n      await this.refresh().catch(log);\n    } else if (this.refreshIntervalMs > 0) {\n      // Started, not waited for, as `refreshTags` would: a page that reads\n      // no cache keeps the instance current too, rather than falling behind\n      // and making a later request wait.\n      void this.refresh().catch(log);\n    }\n    return this.caughtUpRender.run(true, render);\n  }\n\n  /** Whether `at` is more than the interval and the grace ago. */\n  private overdue(at: number): boolean {\n    return this.clock() - at > this.refreshIntervalMs + TAG_REFRESH_GRACE_MS;\n  }\n\n  /**\n   * Catch up on revalidations other instances ran, at most once per\n   * `refreshIntervalMs`. See {@link TrackedTagMarkers} for the cost.\n   */\n  async refresh(): Promise<void> {\n    const log = this.log;\n    if (!log) {\n      return;\n    }\n    if (this.refreshing) {\n      // One started before a freeze read the log as it was then, and says\n      // nothing of what ran meanwhile: an instance behind waits for a fresh\n      // one, after it. One that is merely slow is as fresh as any.\n      if (this.behind && this.pausedSinceRefreshStarted()) {\n        return this.refreshing.then(() => this.refresh());\n      }\n      return this.refreshing;\n    }\n    const at = this.clock();\n    if (at - this.lastRefresh < this.refreshIntervalMs) {\n      return;\n    }\n    this.lastRefresh = at;\n    // Whatever gets tracked before the next refresh is read from its marker,\n    // so there is nothing to catch up on yet - unless an entry is judged by\n    // `completeSince`, which relies on the log for every tag. Even with none\n    // held: a row let go of then moves `completeSince` past it, for an entry\n    // whose generation started before that revalidation and that is stored\n    // after it.\n    if (this.tags.size === 0 && this.entryStores.length === 0) {\n      return;\n    }\n    this.startTicking();\n    this.refreshing = this.sync(at, log).finally(() => {\n      // One that spanned a pause knows the log as of its start at best. So\n      // does one that only looked paused, its event loop held up: it counts\n      // as no older than its start, as if it had not settled since.\n      this.settledAt = Math.max(\n        this.settledAt,\n        this.pausedSinceRefreshStarted() ? this.lastRefresh : this.clock(),\n      );\n      this.stopTicking();\n      this.refreshing = undefined;\n    });\n    return this.refreshing;\n  }\n\n  private startTicking(): void {\n    if (!this.canFreeze) {\n      return;\n    }\n    this.lastTick = this.clock();\n    this.pausedWhileRefreshing = false;\n    this.ticker = setInterval(() => {\n      const at = this.clock();\n      if (at - this.lastTick > REFRESH_PAUSE_MS) {\n        this.pausedWhileRefreshing = true;\n      }\n      this.lastTick = at;\n    }, REFRESH_TICK_MS);\n    // Never what keeps a process alive.\n    this.ticker.unref?.();\n  }\n\n  private stopTicking(): void {\n    clearInterval(this.ticker);\n    this.ticker = undefined;\n  }\n\n  /**\n   * Whether the process was paused since {@link refreshing} started: a tick\n   * came late, or the next one is overdue (after a thaw, a request can run\n   * before the timer does).\n   */\n  private pausedSinceRefreshStarted(): boolean {\n    return (\n      this.canFreeze &&\n      (this.pausedWhileRefreshing ||\n        this.clock() - this.lastTick > REFRESH_PAUSE_MS)\n    );\n  }\n\n  /**\n   * Record a revalidation of `tags`: here at once, and in the revalidation\n   * table for every other instance - the marker row plus a log row per tag.\n   *\n   * Next.js calls `revalidateTag` on the incremental cache and `updateTags` on\n   * every distinct `cacheHandlers` entry, all in one synchronous loop\n   * (`revalidation-utils`), and all of them share this manifest. So an\n   * identical call in the same turn joins the first instead of writing the\n   * rows again. One in a later turn is a revalidation of its own, even while\n   * the first one's writes are in flight, and gets its own, later, marker.\n   * Never rejects: resolves `false` when a row failed to write (the error is\n   * logged), so other instances may not see it.\n   */\n  async update(\n    tags: readonly string[],\n    durations: RevalidateDurations | undefined,\n  ): Promise<boolean> {\n    const key = JSON.stringify([tags, durations ?? null]);\n    const inFlight = this.updating.get(key);\n    if (inFlight) {\n      return inFlight;\n    }\n    const update = this.write(tags, durations);\n    this.updating.set(key, update);\n    // Forgotten as soon as the current turn's calls have been made.\n    void Promise.resolve().then(() => this.updating.delete(key));\n    return update;\n  }\n\n  /**\n   * What the tracked markers say about an entry carrying `tags`, created at\n   * `createdAt`: the most severe answer of any of them.\n   */\n  state(tags: readonly string[], createdAt: number): RevalidationState {\n    // `markerClock()`, not `Date.now()`, here and wherever a marker is stamped:\n    // `createdAt` is on Next.js's clock, and a marker on the wall clock would be\n    // compared across the two, so an entry regenerated just after a\n    // revalidation could still read as older than it wherever they drift.\n    const at = markerClock();\n    let state: RevalidationState = \"fresh\";\n    for (const tag of tags) {\n      const marker = this.knownMarker(tag);\n      if (!marker) {\n        continue;\n      }\n      const tagState = markerState(marker, createdAt, at);\n      if (tagState === \"expired\") {\n        return \"expired\";\n      }\n      if (tagState === \"stale\") {\n        state = \"stale\";\n      }\n    }\n    return state;\n  }\n\n  /**\n   * `getExpiration`'s answer: the latest time any of `tags` expired, `0` if\n   * none has. Only expirations already past count - a profile's future\n   * `expire` is not an expiration yet - and a stale mark does not, matching\n   * Next.js's default handler, which reads only `expired` for implicit tags.\n   */\n  expiration(tags: readonly string[]): number {\n    const at = markerClock();\n    let latest = 0;\n    for (const tag of tags) {\n      const marker = this.knownMarker(tag);\n      if (!marker) {\n        continue;\n      }\n      if (marker.revalidatedAt !== undefined) {\n        latest = Math.max(latest, marker.revalidatedAt);\n      }\n      if (marker.expiredAt !== undefined && marker.expiredAt <= at) {\n        latest = Math.max(latest, marker.expiredAt);\n      }\n    }\n    return latest;\n  }\n\n  private async write(\n    tags: readonly string[],\n    durations: RevalidateDurations | undefined,\n  ): Promise<boolean> {\n    const at = markerClock();\n    const marker = markerFor(at, durations);\n    for (const tag of tags) {\n      this.set(tag, applyMarker(this.get(tag), marker));\n    }\n    const { markers, log } = this;\n    if (!markers || !log) {\n      return true;\n    }\n    const writes: [string, Promise<unknown>][] = [];\n    for (const tag of new Set(tags)) {\n      writes.push([\n        \"Error writing tag revalidation marker:\",\n        // The row as it is now, which carries any earlier `revalidatedAt`\n        // another instance wrote: tracking only what this call set would\n        // hide that one until the rolling re-read, and an entry older than it\n        // would read as merely stale.\n        markers.write(tag, at, durations).then((row) => {\n          if (row) {\n            this.set(tag, mergeMarkers(this.get(tag), row));\n          }\n        }),\n      ]);\n      writes.push([\n        \"Error writing tag revalidation log row:\",\n        this.putLogRow(log, tag, marker),\n      ]);\n    }\n    const results = await Promise.allSettled(writes.map(([, write]) => write));\n    results.forEach((result, i) => {\n      if (result.status === \"rejected\") {\n        console.error(writes[i][0], result.reason);\n      }\n    });\n    return results.every((result) => result.status === \"fulfilled\");\n  }\n\n  /**\n   * Put `tag`'s log row, stamped on the wall clock (the marker values are on\n   * Next.js's: see {@link RevalidationLog}).\n   *\n   * Readers only look {@link REVALIDATION_LOG_LOOKBACK_MS} behind their last\n   * query, so a row that shows up much later than its timestamp - a slow\n   * connection, retries under throttling - is behind every cursor and never\n   * read. A slow put is therefore made again under a fresh timestamp, which\n   * readers will see; one slow twice is reported as a failure.\n   */\n  private async putLogRow(\n    log: RevalidationLog,\n    tag: string,\n    marker: TagMarker,\n  ): Promise<void> {\n    for (let attempt = 0; attempt < 2; attempt++) {\n      const at = this.clock();\n      await log.put(tag, at, marker);\n      if (this.clock() - at <= MAX_LOG_PUT_MS) {\n        return;\n      }\n    }\n    throw new Error(\n      `The revalidation log row for ${tag} took longer than readers look back`,\n    );\n  }\n\n  /**\n   * One refresh started at `at`: the log rows since the cursor, and the next\n   * slice of the rolling re-read.\n   *\n   * A failed query changes nothing but the log: the tags stay tracked as they\n   * were, and the next refresh asks again from the same cursor.\n   */\n  private async sync(at: number, log: RevalidationLog): Promise<void> {\n    if (at - this.lastLogRead > MAX_REVALIDATION_LOG_GAP_MS) {\n      this.forget(\n        at,\n        \"the revalidation log may not cover the gap since it was last read\",\n      );\n      return;\n    }\n    // The rolling re-read runs alongside, not waited for: catching up needs\n    // only the log, and a throttled `BatchGetItem` should not hold the\n    // request `catchUp` makes wait. A forget meanwhile reads it again.\n    const due = this.due(at);\n    if (due.length > 0) {\n      void this.startRead(due);\n    }\n    const result = await log.query(this.cursor).catch((error) => {\n      console.error(\"Error reading tag revalidation log:\", error);\n      return undefined;\n    });\n    if (!result) {\n      return;\n    }\n    if (result.truncated) {\n      this.forget(\n        at,\n        \"the revalidation log has more rows than one query reads\",\n      );\n      return;\n    }\n    // A scan of every entry held, which also drops the expired ones, once in\n    // a while: so expired entries never read again don't pile up ahead of\n    // live ones. In between, the stores answer early without one, which only\n    // keeps rows in `logOnly` a little longer.\n    const scan = at - this.lastEntryScan > ENTRY_SCAN_INTERVAL_MS;\n    if (scan) {\n      this.lastEntryScan = at;\n    }\n    const oldest = this.oldestEntry(scan);\n    let applied = 0;\n    for (const row of result.rows) {\n      if (this.applied.has(row.sk)) {\n        continue;\n      }\n      const marker = this.tags.get(row.tag);\n      if (marker) {\n        // `set` on a key already there keeps its place in the LRU order: being\n        // revalidated elsewhere is not a use.\n        this.tags.set(row.tag, mergeMarkers(marker, row.marker));\n      } else if (this.reading.has(row.tag)) {\n        this.pendingRows.set(\n          row.tag,\n          mergeMarkers(this.pendingRows.get(row.tag), row.marker),\n        );\n      } else {\n        // A tag this instance does not track is read from its marker when it\n        // is next needed - but not yet marked applied, because that read may\n        // miss this very revalidation: the writer puts the log row and the\n        // marker at the same time, and the read is an eventually consistent\n        // `BatchGetItem` that can land milliseconds after the row showed here.\n        // Marked applied, the row was skipped by every query the lookback\n        // returned it to, and the pre-revalidation marker stood until the\n        // rolling re-read. Left unmarked, the next refresh applies it to\n        // whatever that read found; it costs no read, only the row being\n        // looked at again while it is inside the lookback.\n        //\n        // Kept meanwhile in `logOnly`, which is all `completeSince` needs.\n        this.rememberLogged(\n          row.tag,\n          mergeMarkers(this.logOnly.get(row.tag), row.marker),\n          oldest,\n        );\n        continue;\n      }\n      this.applied.set(row.sk, row.at);\n      applied++;\n    }\n    if (oldest > this.prunedAgainst) {\n      this.pruneLogged(oldest);\n    }\n    // The rows just kept are known by later than `oldest` too.\n    this.prunedAgainst = oldest;\n    this.lastLogRead = at;\n    this.advance(at - REVALIDATION_LOG_LOOKBACK_MS);\n    this.debug(\n      `read ${result.rows.length} revalidation log rows (${applied} applied)`,\n    );\n  }\n\n  /**\n   * The tags to read on this refresh, at most one `BatchGetItem`'s worth:\n   * those whose read failed, then those whose re-read has come due, in the\n   * order they were last read.\n   */\n  private due(at: number): string[] {\n    const due: string[] = [];\n    for (const tag of this.unread) {\n      if (due.length >= BATCH_GET_MAX_KEYS) return due;\n      if (!this.reading.has(tag)) {\n        due.push(tag);\n      }\n    }\n    // Known in time order, and each due at most `jitter` earlier than the\n    // tags after it: past a tag due more than that from now, none is due.\n    const jitter = this.resyncIntervalMs * TAG_RESYNC_JITTER;\n    for (const [tag, dueAt] of this.dueAt) {\n      if (due.length >= BATCH_GET_MAX_KEYS || dueAt - jitter > at) {\n        break;\n      }\n      if (dueAt <= at && !this.unread.has(tag) && !this.reading.has(tag)) {\n        due.push(tag);\n      }\n    }\n    return due;\n  }\n\n  /**\n   * Forget every tracked marker, and follow the log from `at`: what is needed\n   * next is read from its marker as it is needed, spread over the requests\n   * that need it, rather than every tracked tag re-read at once.\n   */\n  private forget(at: number, why: string): void {\n    this.debug(`forgetting ${this.tags.size} tracked tags: ${why}`);\n    this.forgotten++;\n    // What the markers expire later is still to apply once it is past.\n    for (const marker of this.tags.values()) {\n      this.raiseFloor(marker);\n    }\n    for (const marker of this.logOnly.values()) {\n      this.raiseFloor(marker);\n    }\n    this.tags.clear();\n    this.dueAt.clear();\n    this.unread.clear();\n    this.applied.clear();\n    this.logOnly.clear();\n    // Never back: a marker dropped earlier may have expired entries later.\n    this.floor = Math.max(this.floor, markerClock());\n    this.cursor = at - REVALIDATION_LOG_LOOKBACK_MS;\n    this.lastLogRead = at;\n  }\n\n  /**\n   * Move the cursor forward to `cursor`, forgetting applied rows before it:\n   * no query returns them again.\n   */\n  private advance(cursor: number): void {\n    if (cursor <= this.cursor) {\n      return;\n    }\n    this.cursor = cursor;\n    for (const [sk, at] of this.applied) {\n      if (at < cursor) {\n        this.applied.delete(sk);\n      }\n    }\n  }\n\n  /**\n   * Read `tags` from the table, and report whether that worked. A read that\n   * fails leaves them tracked as they were, and the next refresh reads them\n   * again: the same \"assume the entry is valid\" the incremental cache has\n   * always answered with, rather than a read on every request while DynamoDB\n   * is unavailable.\n   */\n  private async readInto(tags: string[], again = false): Promise<boolean> {\n    if (tags.length === 0) {\n      return true;\n    }\n    const at = this.clock();\n    const forgotten = this.forgotten;\n    try {\n      const read = await this.markers!.read(tags);\n      if (this.forgotten !== forgotten && !again) {\n        // Read before a forget - across a freeze, as like as not - so as\n        // stale as what it forgot. Read again rather than leave the tags\n        // untracked: whoever waits on this read (`reading`) judges entries\n        // by it next, and an untracked tag counts for nothing. Once: a run\n        // of forgets (a truncated log, query after query) would otherwise\n        // keep them waiting, and the second read began after the first.\n        return await this.readInto(tags, true);\n      }\n      for (const tag of tags) {\n        this.unread.delete(tag);\n        this.remember(\n          tag,\n          mergeMarkers(\n            mergeMarkers(this.tags.get(tag), read.get(tag)),\n            this.takePendingRows(tag),\n          ),\n        );\n        this.known(tag, at);\n      }\n      this.debug(`read ${tags.length} tag markers (${read.size} set)`);\n      return true;\n    } catch (error) {\n      console.error(\"Error reading tag markers:\", error);\n      if (this.forgotten !== forgotten && !again) {\n        return this.readInto(tags, true);\n      }\n      this.trackUnread(tags);\n      for (const tag of tags) {\n        this.unread.add(tag);\n        const pending = this.takePendingRows(tag);\n        if (pending) {\n          this.remember(tag, mergeMarkers(this.tags.get(tag), pending));\n        }\n      }\n      return false;\n    }\n  }\n\n  private takePendingRows(tag: string): TagMarker | undefined {\n    const pending = this.pendingRows.get(tag);\n    const logged = this.logOnly.get(tag);\n    this.pendingRows.delete(tag);\n    this.logOnly.delete(tag);\n    return logged ? mergeMarkers(logged, pending) : pending;\n  }\n\n  /**\n   * What this instance knows of `tag`: tracked, or from the log alone -\n   * including rows that arrived while its first read is in flight.\n   */\n  private knownMarker(tag: string): TagMarker | undefined {\n    const tracked = this.tags.get(tag);\n    if (tracked) {\n      return tracked;\n    }\n    const logged = this.logOnly.get(tag);\n    const pending = this.pendingRows.get(tag);\n    return logged || pending ? mergeMarkers(logged, pending) : undefined;\n  }\n\n  /**\n   * Keep `tag`'s log rows in `logOnly`, unless they cannot apply to an entry\n   * held, `oldest` or newer (see {@link pruneLogged}), as bounded as the\n   * tracked tags. Either way a row let go of takes what it knew with it, so\n   * `completeSince` moves past it.\n   */\n  private rememberLogged(tag: string, marker: TagMarker, oldest: number): void {\n    this.logOnly.delete(tag);\n    if (knownBy(marker, markerClock()) <= oldest) {\n      this.raiseFloor(marker);\n      return;\n    }\n    this.logOnly.set(tag, marker);\n    for (const [first, dropped] of this.logOnly) {\n      if (this.logOnly.size <= this.maxTrackedTags) {\n        break;\n      }\n      this.logOnly.delete(first);\n      this.raiseFloor(dropped);\n    }\n  }\n\n  /**\n   * Drop the `logOnly` rows that cannot apply to an entry held, `oldest` or\n   * newer: every revalidation they name so far is no later than it. That\n   * moves `completeSince` no further than `oldest`, which costs the entries\n   * held nothing, and a profile's `expiredAt` still to come waits in\n   * `laterFloors`. Without this, a deployment revalidating many distinct tags\n   * filled `logOnly` with tags no entry here carries, and the evictions past\n   * its bound kept moving `completeSince` up to the present.\n   */\n  private pruneLogged(oldest: number): void {\n    const at = markerClock();\n    for (const [tag, marker] of this.logOnly) {\n      if (knownBy(marker, at) <= oldest) {\n        this.logOnly.delete(tag);\n        this.raiseFloor(marker);\n      }\n    }\n  }\n\n  /**\n   * The oldest entry timestamp of any registered store, `Infinity` with none:\n   * early, never late, unless `scan`.\n   */\n  private oldestEntry(scan: boolean): number {\n    let oldest = Infinity;\n    for (const { oldestTimestamp } of this.entryStores) {\n      oldest = Math.min(oldest, oldestTimestamp(scan));\n    }\n    return oldest;\n  }\n\n  /**\n   * Move `completeSince` past `marker`'s revalidations: what is no longer\n   * known about a tag once its marker is dropped. A future `expiredAt` waits\n   * in `laterFloors` until it is past.\n   */\n  private raiseFloor(marker: TagMarker): void {\n    const at = markerClock();\n    this.floor = Math.max(this.floor, knownBy(marker, at));\n    const { expiredAt } = marker;\n    if (expiredAt !== undefined && expiredAt > Math.max(at, this.floor)) {\n      this.laterFloor(expiredAt);\n    }\n  }\n\n  /**\n   * Add `time` to `laterFloors`, in order. Past the tracked-tag bound the two\n   * spans closest together are merged: from the first's start,\n   * `completeSince` is the second's end, early - which only costs reads, and\n   * for as short a time as any merge allows. Never later than its time, which\n   * would let an entry expire unseen.\n   */\n  private laterFloor(time: number): void {\n    const floors = this.laterFloors;\n    let low = 0;\n    let high = floors.length;\n    while (low < high) {\n      const mid = Math.floor((low + high) / 2);\n      if (floors[mid][0] < time) {\n        low = mid + 1;\n      } else {\n        high = mid;\n      }\n    }\n    // Inside a merged span already: by its start, `completeSince` is past it.\n    // Or already there: a log row for an untracked tag is applied again by\n    // every query its lookback returns it to.\n    if ((low > 0 && floors[low - 1][1] >= time) || floors[low]?.[0] === time) {\n      return;\n    }\n    floors.splice(low, 0, [time, time]);\n    // A scan, but only once past the bound. Merging the new time into a\n    // neighbour instead could join an hour-out span with a year-out one, and\n    // hold `completeSince` a year early.\n    if (floors.length > this.maxTrackedTags) {\n      let merge = 0;\n      for (let i = 1; i < floors.length - 1; i++) {\n        if (\n          floors[i + 1][1] - floors[i][0] <\n          floors[merge + 1][1] - floors[merge][0]\n        ) {\n          merge = i;\n        }\n      }\n      floors.splice(merge, 2, [floors[merge][0], floors[merge + 1][1]]);\n    }\n  }\n\n  /** Record that `tag`'s marker was known from the table at `at`. */\n  private known(tag: string, at: number): void {\n    this.dueAt.delete(tag);\n    this.dueAt.set(\n      tag,\n      at + this.resyncIntervalMs * (1 - TAG_RESYNC_JITTER * this.random()),\n    );\n  }\n\n  private remember(tag: string, marker: TagMarker): void {\n    this.tags.delete(tag);\n    this.tags.set(tag, marker);\n    for (const oldest of this.tags.keys()) {\n      if (this.tags.size <= this.maxTrackedTags) {\n        break;\n      }\n      this.raiseFloor(this.tags.get(oldest)!);\n      this.tags.delete(oldest);\n      this.dueAt.delete(oldest);\n      this.unread.delete(oldest);\n    }\n  }\n\n  private touch(tag: string): void {\n    const marker = this.tags.get(tag);\n    if (marker) {\n      this.remember(tag, marker);\n    }\n  }\n}\n\n/**\n * The latest revalidation `marker` has made known by `at`, `-Infinity` with\n * none: a future `expiredAt` is still to come.\n */\nfunction knownBy(marker: TagMarker, at: number): number {\n  const { revalidatedAt, staleAt, expiredAt } = marker;\n  return Math.max(\n    revalidatedAt ?? -Infinity,\n    staleAt ?? -Infinity,\n    expiredAt !== undefined && expiredAt <= at ? expiredAt : -Infinity,\n  );\n}\n\n/**\n * The longest a log row's put may take and still be seen by every reader: half\n * the lookback, leaving the rest for writers' clocks and eventually consistent\n * queries.\n */\nconst MAX_LOG_PUT_MS = REVALIDATION_LOG_LOOKBACK_MS / 2;\n\n/**\n * How often a refresh scans the entry stores for their oldest entry, dropping\n * the expired ones no request reads again.\n */\nconst ENTRY_SCAN_INTERVAL_MS = 60_000;\n\n/** How often a refresh in flight checks the process is running. */\nconst REFRESH_TICK_MS = 250;\n\n/**\n * How late a tick may come before the process counts as paused (frozen)\n * since the refresh in flight started. A busy event loop can delay one too:\n * the refresh then counts as no fresher than its start, as before the pause\n * check, so a request waits for the next one once that is past the grace.\n */\nconst REFRESH_PAUSE_MS = 1000;\n\n/**\n * A marker as read from the table or the log, keeping whatever this instance\n * already knows that the read does not show yet: reads are eventually\n * consistent, and a read straight after this instance's own revalidation could\n * otherwise take it back.\n */\nexport function mergeMarkers(\n  local: TagMarker | undefined,\n  remote: TagMarker | undefined,\n): TagMarker {\n  if (!local) {\n    return remote ?? {};\n  }\n  if (!remote) {\n    return local;\n  }\n  // `expiredAt` is written with `staleAt`, so it belongs to whichever is\n  // newer - unless that revalidation's profile had no `expire` and left it.\n  const [older, newer] =\n    (local.staleAt ?? -1) > (remote.staleAt ?? -1)\n      ? [remote, local]\n      : [local, remote];\n  return {\n    ...applyMarker(older, newer),\n    revalidatedAt: maxDefined(local.revalidatedAt, remote.revalidatedAt),\n  };\n}\n\nfunction maxDefined(a: number | undefined, b: number | undefined) {\n  if (a === undefined) return b;\n  if (b === undefined) return a;\n  return Math.max(a, b);\n}\n\n/**\n * The cache bucket, as the handlers use it: whole objects read and written as\n * UTF-8 text under the keys above.\n */\nexport class CacheBucket {\n  constructor(\n    private readonly client: S3Client,\n    private readonly bucketName: string,\n  ) {}\n\n  /**\n   * The body of the object at `key`, or `undefined` when there is none (`NoSuchKey`, or an\n   * empty response body). Any other error is thrown: the handlers disagree on\n   * whether one is worth logging.\n   */\n  async get(key: string): Promise<string | undefined> {\n    try {\n      const response = await this.client.send(\n        new GetObjectCommand({ Bucket: this.bucketName, Key: key }),\n      );\n      if (!response.Body) {\n        return undefined;\n      }\n      return await response.Body.transformToString(\"utf-8\");\n    } catch (error) {\n      if (error instanceof NoSuchKey) {\n        return undefined;\n      }\n      throw error;\n    }\n  }\n\n  /** Write `body` as a JSON object at `key`. */\n  async putJson(key: string, body: string): Promise<void> {\n    await this.client.send(\n      new PutObjectCommand({\n        Bucket: this.bucketName,\n        Key: key,\n        Body: body,\n        ContentType: \"application/json; charset=utf-8\",\n      }),\n    );\n  }\n}\n"]}