cdk-nextjs 0.6.2 → 0.7.1

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

@@ -0,0 +1,1004 @@
+"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.resolveAwsCacheConfig = resolveAwsCacheConfig;
+exports.buildS3Key = buildS3Key;
+exports.useCacheS3Key = useCacheS3Key;
+exports.markerState = markerState;
+exports.markerClock = markerClock;
+exports.markerFor = markerFor;
+exports.applyMarker = applyMarker;
+exports.markerUpdate = markerUpdate;
+exports.mergeMarkers = mergeMarkers;
+/*
+  The S3 / DynamoDB plumbing shared by every cdk-nextjs cache handler: the
+  incremental `cacheHandler` (`S3CacheHandler`) and the `cacheHandlers` for
+  `'use cache'` / `'use cache: remote'`.
+
+  What lives here is what has to agree between them - where the configuration
+  comes from, how a cache key becomes an S3 key, and what a tag's marker row in
+  the revalidation table looks like and means. A `revalidateTag` reaches both
+  kinds of handler, and they must read each other's markers the same way.
+*/
+/* eslint-disable import/no-extraneous-dependencies */
+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");
+/** The configuration from the environment. */
+function resolveAwsCacheConfig() {
+    return {
+        bucketName: process.env.CDK_NEXTJS_CACHE_BUCKET_NAME || "",
+        tableName: process.env.CDK_NEXTJS_REVALIDATION_TABLE_NAME || "",
+        region: process.env.AWS_REGION || "us-east-1",
+        buildId: process.env.CDK_NEXTJS_BUILD_ID || "",
+    };
+}
+/**
+ * `{buildId}/{cacheKey}.json`, the incremental cache's key convention.
+ *
+ * The root path becomes `index`, and a leading slash is dropped so there is no
+ * empty folder under the build prefix. Everything this returns ends in `.json`,
+ * 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`);
+}
+/**
+ * The folder under the build prefix that `'use cache'` entries are stored in.
+ * @see useCacheS3Key
+ */
+exports.USE_CACHE_KEY_PREFIX = "_use-cache";
+/**
+ * `{buildId}/_use-cache/{hash}.entry`, where a `cacheHandlers` entry is stored.
+ *
+ * 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/…`.
+ * Still under the build prefix, so post-deploy pruning drops them with the build.
+ */
+function useCacheS3Key(buildId, keyHash) {
+    return (0, node_path_1.join)(buildId, exports.USE_CACHE_KEY_PREFIX, `${keyHash}.entry`);
+}
+/**
+ * What `marker` means for an entry created at `createdAt`, at `now`.
+ *
+ * `expiredAt` in the future is a profile's `expire` that has not come yet,
+ * compared the way Next.js's `areTagsExpired` does.
+ */
+function markerState(marker, createdAt, now) {
+    const { revalidatedAt, expiredAt, staleAt } = marker;
+    if ((revalidatedAt !== undefined && revalidatedAt > createdAt) ||
+        (expiredAt !== undefined && expiredAt <= now && expiredAt > createdAt)) {
+        return "expired";
+    }
+    if (staleAt !== undefined && staleAt > createdAt) {
+        return "stale";
+    }
+    return "fresh";
+}
+/**
+ * The clock every tag marker is stamped with, and every entry timestamp it is
+ * compared against: the one Next.js stamps `CacheEntry.timestamp` with
+ * (`performance.timeOrigin + performance.now()`, in `use-cache-wrapper.js` and
+ * the default handler), rather than `Date.now()`. Both handlers write the same
+ * marker rows, so both have to use it: two clocks on one row let the last writer
+ * decide which clock the others compare against, and they drift apart for as
+ * long as a Lambda sandbox or Fargate task lives.
+ */
+function markerClock() {
+    return performance.timeOrigin + performance.now();
+}
+/**
+ * The marker fields a tag revalidated at `now` sets.
+ *
+ * Without `durations` - `updateTag`, or `revalidateTag` with no profile - the
+ * tag's entries expire immediately (`revalidatedAt`). With them the entries go
+ * stale now and expire after the profile's `expire`, the same pair of
+ * timestamps Next.js's `FileSystemCache.revalidateTag` records. A profile with
+ * no `expire` sets only `staleAt`, and whatever `expiredAt` the tag had stays.
+ */
+function markerFor(now, durations) {
+    if (!durations) {
+        return { revalidatedAt: now };
+    }
+    if (durations.expire === undefined) {
+        return { staleAt: now };
+    }
+    return { staleAt: now, expiredAt: now + durations.expire * 1000 };
+}
+const MARKER_FIELDS = ["revalidatedAt", "staleAt", "expiredAt"];
+/**
+ * `existing` with the fields `update` sets, as a {@link markerUpdate} leaves
+ * the row: a field `update` does not set keeps its value.
+ */
+function applyMarker(existing, update) {
+    const marker = { ...existing };
+    for (const field of MARKER_FIELDS) {
+        if (update[field] !== undefined) {
+            marker[field] = update[field];
+        }
+    }
+    return marker;
+}
+/** The marker-row update that sets {@link markerFor}'s fields. */
+function markerUpdate(now, durations) {
+    const marker = markerFor(now, durations);
+    const fields = MARKER_FIELDS.filter((field) => marker[field] !== undefined);
+    return {
+        UpdateExpression: `SET ${fields.map((field) => `${field} = :${field}`).join(", ")}`,
+        ExpressionAttributeValues: Object.fromEntries(fields.map((field) => [`:${field}`, { N: String(marker[field]) }])),
+    };
+}
+/** A DynamoDB number attribute as a number, or `undefined` when absent. */
+function numberAttribute(value) {
+    return value?.N === undefined ? undefined : Number(value.N);
+}
+/** The marker fields of a marker or log row. */
+function markerOf(item) {
+    return {
+        revalidatedAt: numberAttribute(item.revalidatedAt),
+        staleAt: numberAttribute(item.staleAt),
+        expiredAt: numberAttribute(item.expiredAt),
+    };
+}
+/** DynamoDB's cap on keys in one `BatchGetItem`. */
+exports.BATCH_GET_MAX_KEYS = 100;
+/**
+ * How often, at most, an instance catches up on revalidations other instances
+ * ran, unless `CDK_NEXTJS_TAG_REFRESH_MS` says otherwise: the staleness window
+ * for a `revalidateTag` run elsewhere. Every cache hit checks its tags'
+ * markers, and every marker of a deployment shares one partition key, so
+ * reading them per request capped a route's cache hits at the partition's read
+ * throughput (~1,900 req/s on NextjsRegionalFunctions). Once a second, from the
+ * revalidation log, the reads scale with instances instead of requests or tags.
+ */
+exports.DEFAULT_TAG_REFRESH_MS = 1000;
+/**
+ * The bare-tag marker rows of the revalidation table (`pk = buildId`,
+ * `sk = tag`), 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
+ * same thing to every handler. What an instance keeps of them between reads is
+ * {@link TrackedTagMarkers}.
+ */
+class TagMarkerTable {
+    client;
+    tableName;
+    buildId;
+    constructor(client, tableName, buildId) {
+        this.client = client;
+        this.tableName = tableName;
+        this.buildId = buildId;
+    }
+    /**
+     * Record `tag`'s revalidation at `now`. See {@link markerUpdate}.
+     *
+     * Returns the row as this write left it, so the instance that wrote it can
+     * track it rather than read it back: reads are eventually consistent, and a
+     * read-back racing replication could return the marker from before the write.
+     */
+    async write(tag, now, durations) {
+        const response = await this.client.send(new client_dynamodb_1.UpdateItemCommand({
+            TableName: this.tableName,
+            Key: {
+                pk: { S: this.buildId },
+                sk: { S: tag },
+            },
+            ...markerUpdate(now, durations),
+            ReturnValues: "ALL_NEW",
+        }));
+        return response?.Attributes ? markerOf(response.Attributes) : undefined;
+    }
+    /**
+     * The marker rows for `tags` that exist, by tag, in one `BatchGetItem` per
+     * {@link BATCH_GET_MAX_KEYS} tags rather than a `GetItem` each: a page
+     * carries its whole implicit `_N_T_/…` chain plus the app's own tags, a
+     * page with a few fetches checks each of them too, and every one is on the
+     * request path. A tag with no row is absent from the result.
+     */
+    async read(tags) {
+        const { tableName, buildId } = this;
+        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
+                .slice(i, i + exports.BATCH_GET_MAX_KEYS)
+                .map((tag) => ({ pk: { S: buildId }, sk: { S: tag } }));
+            // `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++) {
+                const response = await this.client.send(new client_dynamodb_1.BatchGetItemCommand({
+                    RequestItems: {
+                        [tableName]: {
+                            Keys: keys,
+                            ProjectionExpression: "sk, revalidatedAt, staleAt, expiredAt",
+                        },
+                    },
+                }));
+                for (const item of response.Responses?.[tableName] ?? []) {
+                    const tag = item.sk?.S;
+                    if (tag !== undefined) {
+                        markers.set(tag, markerOf(item));
+                    }
+                }
+                keys = response.UnprocessedKeys?.[tableName]?.Keys;
+            }
+            if (keys?.length) {
+                throw new Error(`DynamoDB left ${keys.length} tag markers unread after retrying`);
+            }
+        }
+        return markers;
+    }
+}
+exports.TagMarkerTable = TagMarkerTable;
+/**
+ * How long a revalidation log row is kept (`ttl`, epoch seconds). DynamoDB never
+ * deletes an item before its TTL, only some time after, so a reader that last
+ * queried less than this long ago (less a margin for writers' clocks) is sure
+ * to find every row it has not seen yet.
+ */
+exports.REVALIDATION_LOG_TTL_MS = 15 * 60 * 1000;
+/** The most `Query` pages one {@link RevalidationLog.query} reads. */
+exports.REVALIDATION_LOG_MAX_PAGES = 5;
+/** How many sort keys {@link RevalidationLog.put} tries before giving up. */
+const LOG_PUT_ATTEMPTS = 5;
+/** Digits a log row's timestamp is zero-padded to, so sort keys sort by time. */
+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}.
+ *
+ * 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
+ * of re-reading every tag it tracks to find out that almost none changed. Every
+ * marker row of a deployment shares one partition, and those re-reads from a
+ * handful of busy instances were enough to throttle it.
+ *
+ * The sort key's timestamp is the writer's wall clock (`Date.now()`), not the
+ * performance clock ({@link markerClock}) the marker values are stamped with by both
+ * handlers: it only orders rows for readers' cursors, which are on their own
+ * wall clocks, and is never compared with an entry's timestamp.
+ */
+class RevalidationLog {
+    client;
+    tableName;
+    pk;
+    constructor(client, tableName, buildId) {
+        this.client = client;
+        this.tableName = tableName;
+        this.pk = `${buildId}#log`;
+    }
+    /**
+     * Record that `tag` was revalidated at `at` (`Date.now()`), setting `marker`.
+     *
+     * Two revalidations of `tag` in the same millisecond would share a sort key,
+     * and the second would overwrite the first. So the row is only written where
+     * its key is free, and on a collision it moves to the next millisecond, up
+     * to {@link LOG_PUT_ATTEMPTS} times.
+     */
+    async put(tag, at, marker) {
+        for (let attempt = 1;; attempt++) {
+            const item = {
+                pk: { S: this.pk },
+                sk: { S: `${logSkPrefix(at)}#${tag}` },
+                ttl: { N: String(Math.ceil((at + exports.REVALIDATION_LOG_TTL_MS) / 1000)) },
+            };
+            for (const field of MARKER_FIELDS) {
+                const value = marker[field];
+                if (value !== undefined) {
+                    item[field] = { N: String(value) };
+                }
+            }
+            try {
+                await this.client.send(new client_dynamodb_1.PutItemCommand({
+                    TableName: this.tableName,
+                    Item: item,
+                    ConditionExpression: "attribute_not_exists(sk)",
+                }));
+                return;
+            }
+            catch (error) {
+                if (error?.name !==
+                    "ConditionalCheckFailedException" ||
+                    attempt >= LOG_PUT_ATTEMPTS) {
+                    throw error;
+                }
+                at = Math.floor(at) + 1;
+            }
+        }
+    }
+    /**
+     * The rows written at or after `since` (`Date.now()`), oldest first.
+     * `truncated` when there were more than {@link REVALIDATION_LOG_MAX_PAGES}
+     * pages of them, and `rows` is only the start.
+     *
+     * Eventually consistent: a row written a moment ago may not show yet, which
+     * is what the reader's lookback is for.
+     */
+    async query(since) {
+        const rows = [];
+        let startKey;
+        for (let page = 0; page < exports.REVALIDATION_LOG_MAX_PAGES; page++) {
+            const response = await this.client.send(new client_dynamodb_1.QueryCommand({
+                TableName: this.tableName,
+                KeyConditionExpression: "pk = :pk AND sk >= :since",
+                ExpressionAttributeValues: {
+                    ":pk": { S: this.pk },
+                    ":since": { S: logSkPrefix(Math.max(0, since)) },
+                },
+                ProjectionExpression: "sk, revalidatedAt, staleAt, expiredAt",
+                ExclusiveStartKey: startKey,
+            }));
+            for (const item of response.Items ?? []) {
+                const sk = item.sk?.S;
+                // `<digits>#<tag>`: the tag is everything after the fixed-width
+                // timestamp, `#`s included.
+                if (sk === undefined || sk[LOG_SK_DIGITS] !== "#") {
+                    continue;
+                }
+                rows.push({
+                    sk,
+                    at: Number(sk.slice(0, LOG_SK_DIGITS)),
+                    tag: sk.slice(LOG_SK_DIGITS + 1),
+                    marker: markerOf(item),
+                });
+            }
+            startKey = response.LastEvaluatedKey;
+            if (!startKey) {
+                return { rows, truncated: false };
+            }
+        }
+        return { rows, truncated: true };
+    }
+}
+exports.RevalidationLog = RevalidationLog;
+function logSkPrefix(at) {
+    return String(Math.floor(at)).padStart(LOG_SK_DIGITS, "0");
+}
+/**
+ * How far behind the last query's start the next one starts reading the log:
+ * the room for the `Query` being eventually consistent and for writers' clocks
+ * running behind the reader's. Rows inside it are read again, and dropped as
+ * already applied.
+ */
+exports.REVALIDATION_LOG_LOOKBACK_MS = 5000;
+/**
+ * The longest {@link TrackedTagMarkers} trusts the log alone for a tag before
+ * reading its marker row again. The log is the fast path, but the marker rows
+ * are the source of truth: a log row whose write failed would otherwise be
+ * missed for as long as the tag stays tracked.
+ *
+ * Rolling, not all at once: each refresh re-reads at most
+ * {@link BATCH_GET_MAX_KEYS} of the tags due, oldest first. Re-reading them all
+ * together cost ~500 RCU at 1000 tags - a fleet started by one load test did it
+ * in the same minute, 12,800 RCU, and throttled - and would be ~5,000 RCU at
+ * {@link DEFAULT_MAX_TRACKED_TAGS}, past what the one partition serves in a
+ * second. Spread out, 10,000 tracked tags cost ~8 RCU a second per instance.
+ *
+ * Each tag is due at a random 75-100% of this after it was last read, so tags
+ * first read together - an instance warming up - do not all come due together
+ * again every interval: the load test that measured the rolling re-read saw
+ * its warm-up's reads return as a 30-36 RCU/s bump ten minutes later.
+ */
+exports.DEFAULT_TAG_RESYNC_MS = 10 * 60 * 1000;
+/** The fraction of {@link DEFAULT_TAG_RESYNC_MS} a tag may come due early by. */
+const TAG_RESYNC_JITTER = 0.25;
+/**
+ * How long since the last successful log query the log can still be trusted to
+ * hold every row not read yet: its TTL less a margin for writers' clocks. Past
+ * it - a Lambda frozen between invocations, a run of failed queries - the
+ * tracked markers are forgotten, to be read again as they are needed, and the
+ * log is followed from there.
+ */
+exports.MAX_REVALIDATION_LOG_GAP_MS = exports.REVALIDATION_LOG_TTL_MS - 5 * 60 * 1000;
+/**
+ * The most tags one instance tracks. Past it the least recently used is
+ * forgotten, which costs a read the next time it is needed: an untracked tag
+ * is read before it is trusted.
+ *
+ * A tracked tag costs memory (~2 MB at this bound) and its share of the rolling
+ * re-read, not a read every refresh, so the bound is set by how many tags an
+ * instance really uses. Every path is a tag of its own (`_N_T_/<path>`), and at
+ * 1000 an app of 1000 tagged pages kept evicting what it was about to need:
+ * half its requests re-read a marker.
+ */
+exports.DEFAULT_MAX_TRACKED_TAGS = 10_000;
+/**
+ * One instance's copy of the marker rows of the tags it has needed, kept
+ * current through the {@link RevalidationLog}: the process's one tag manifest
+ * (`sharedTagManifest`), for the `'use cache'` handlers and the incremental
+ * cache alike.
+ *
+ * Next.js's built-in `'use cache'` handler keeps tags in a module-level map
+ * (`tags-manifest.external.js`) that only its own `updateTags` writes, and its
+ * `refreshTags` is a no-op, so a `revalidateTag` on one instance never reaches
+ * the others: they keep serving the revalidated entry, including inside pages
+ * that are being re-rendered *because* of that revalidation. The
+ * `cacheHandlers` interface's answer is `refreshTags`, "called before starting
+ * a new request … to refresh the local tags manifest", and this is that
+ * manifest, backed by the same marker rows the incremental cache's
+ * `revalidateTag` writes (`pk = buildId`, `sk = tag`).
+ *
+ * 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.
+ * - {@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}.
+ */
+class TrackedTagMarkers {
+    markers;
+    log;
+    refreshIntervalMs;
+    maxTrackedTags;
+    resyncIntervalMs;
+    clock;
+    random;
+    debug;
+    /** By tag, least recently used first. */
+    tags = new Map();
+    /**
+     * When each tracked tag's marker is due to be read again: a random 75-100%
+     * of `resyncIntervalMs` after it was last known from the table - read,
+     * written here, or new. In the order they became known, least recent first.
+     */
+    dueAt = new Map();
+    reading = new Map();
+    /**
+     * Log rows for tags whose first read is in flight, merged by tag: the read
+     * may have been answered before the revalidation, so they are applied to its
+     * result rather than dropped.
+     */
+    pendingRows = new Map();
+    /** Tracked tags whose read failed, for the next refresh to read again. */
+    unread = new Set();
+    lastRefresh = -Infinity;
+    refreshing;
+    /**
+     * Where the next log query starts (`clock()`): the last successful one's
+     * start, less {@link REVALIDATION_LOG_LOOKBACK_MS}.
+     */
+    cursor;
+    /** When the last successful log query started, or the log was first read. */
+    lastLogRead;
+    /** Log rows at or after the cursor already applied, by sort key. */
+    applied = new Map();
+    /** {@link update}s of the current turn, by their arguments. */
+    updating = new Map();
+    constructor(options) {
+        this.markers = options.markers;
+        this.log = options.log;
+        this.refreshIntervalMs =
+            options.refreshIntervalMs ?? exports.DEFAULT_TAG_REFRESH_MS;
+        this.maxTrackedTags = options.maxTrackedTags ?? exports.DEFAULT_MAX_TRACKED_TAGS;
+        this.resyncIntervalMs = options.resyncIntervalMs ?? exports.DEFAULT_TAG_RESYNC_MS;
+        // Looked up on each call rather than bound here, so a test's `Date.now`
+        // spy applies.
+        this.clock = options.clock ?? (() => Date.now());
+        this.random = options.random ?? Math.random;
+        this.debug = options.debug ?? (() => { });
+        // 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;
+    }
+    /** `tag`'s marker as this instance knows it, if it tracks `tag`. */
+    get(tag) {
+        return this.tags.get(tag);
+    }
+    /**
+     * Track `tag` with `marker`: what this instance just wrote, which it knows
+     * without reading it back.
+     */
+    set(tag, marker) {
+        this.remember(tag, marker);
+        this.known(tag, this.clock());
+    }
+    /**
+     * Note a use of `tags`: those of an entry this instance just stored.
+     *
+     * With the table, a tag not tracked yet is left untracked, to be read by
+     * {@link ensure} the first time an entry needs it. Nothing revalidated before
+     * the new entry was created applies to *it*, but tracking is per tag, not per
+     * entry: tracking the tag with an empty marker would also vouch for every
+     * older entry that carries it - one another instance stored in S3, or one
+     * this instance kept in memory across a {@link forget} - and a revalidation
+     * from before the log's cursor would go unseen until the rolling re-read.
+     *
+     * Without the table every revalidation is this process's own, applied with
+     * {@link set}, so a tag is tracked at once.
+     */
+    track(tags) {
+        if (!this.markers) {
+            this.trackUnread(tags);
+            return;
+        }
+        for (const tag of tags) {
+            this.touch(tag);
+        }
+    }
+    /**
+     * Track `tags` as they are known now, without reading them, with an empty
+     * marker for any not tracked yet.
+     */
+    trackUnread(tags) {
+        const at = this.clock();
+        for (const tag of tags) {
+            if (!this.tags.has(tag)) {
+                this.known(tag, at);
+            }
+            this.remember(tag, this.tags.get(tag) ?? {});
+        }
+    }
+    /**
+     * Read the markers of whichever of `tags` this instance does not track yet.
+     * Needed before judging an entry this instance did not create, since its
+     * tags may have been revalidated at any time before.
+     */
+    async ensure(tags) {
+        if (!this.markers) {
+            this.trackUnread(tags);
+            return;
+        }
+        const waits = [];
+        const unread = [];
+        for (const tag of new Set(tags)) {
+            const inFlight = this.reading.get(tag);
+            if (inFlight) {
+                waits.push(inFlight);
+            }
+            else if (this.tags.has(tag)) {
+                this.touch(tag);
+            }
+            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);
+        }
+        await Promise.all(waits);
+    }
+    /**
+     * Catch up on revalidations other instances ran, at most once per
+     * `refreshIntervalMs`. See {@link TrackedTagMarkers} for the cost.
+     */
+    async refresh() {
+        const log = this.log;
+        if (!log) {
+            return;
+        }
+        if (this.refreshing) {
+            return this.refreshing;
+        }
+        const at = this.clock();
+        if (at - this.lastRefresh < this.refreshIntervalMs) {
+            return;
+        }
+        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) {
+            return;
+        }
+        this.refreshing = this.sync(at, log).finally(() => {
+            this.refreshing = undefined;
+        });
+        return this.refreshing;
+    }
+    /**
+     * 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.
+     *
+     * Next.js calls `revalidateTag` on the incremental cache and `updateTags` on
+     * every distinct `cacheHandlers` entry, all in one synchronous loop
+     * (`revalidation-utils`), and all of them share this manifest. So an
+     * identical call in the same turn joins the first instead of writing the
+     * rows again. One in a later turn is a revalidation of its own, even while
+     * the first one's writes are in flight, and gets its own, later, marker.
+     * Never rejects: resolves `false` when a row failed to write (the error is
+     * logged), so other instances may not see it.
+     */
+    async update(tags, durations) {
+        const key = JSON.stringify([tags, durations ?? null]);
+        const inFlight = this.updating.get(key);
+        if (inFlight) {
+            return inFlight;
+        }
+        const update = this.write(tags, durations);
+        this.updating.set(key, update);
+        // Forgotten as soon as the current turn's calls have been made.
+        void Promise.resolve().then(() => this.updating.delete(key));
+        return update;
+    }
+    /**
+     * What the tracked markers say about an entry carrying `tags`, created at
+     * `createdAt`: the most severe answer of any of them.
+     */
+    state(tags, createdAt) {
+        // `markerClock()`, not `Date.now()`, here and wherever a marker is stamped:
+        // `createdAt` is on Next.js's clock, and a marker on the wall clock would be
+        // compared across the two, so an entry regenerated just after a
+        // revalidation could still read as older than it wherever they drift.
+        const at = markerClock();
+        let state = "fresh";
+        for (const tag of tags) {
+            const marker = this.get(tag);
+            if (!marker) {
+                continue;
+            }
+            const tagState = markerState(marker, createdAt, at);
+            if (tagState === "expired") {
+                return "expired";
+            }
+            if (tagState === "stale") {
+                state = "stale";
+            }
+        }
+        return state;
+    }
+    /**
+     * `getExpiration`'s answer: the latest time any of `tags` expired, `0` if
+     * none has. Only expirations already past count - a profile's future
+     * `expire` is not an expiration yet - and a stale mark does not, matching
+     * Next.js's default handler, which reads only `expired` for implicit tags.
+     */
+    expiration(tags) {
+        const at = markerClock();
+        let latest = 0;
+        for (const tag of tags) {
+            const marker = this.get(tag);
+            if (!marker) {
+                continue;
+            }
+            if (marker.revalidatedAt !== undefined) {
+                latest = Math.max(latest, marker.revalidatedAt);
+            }
+            if (marker.expiredAt !== undefined && marker.expiredAt <= at) {
+                latest = Math.max(latest, marker.expiredAt);
+            }
+        }
+        return latest;
+    }
+    async write(tags, durations) {
+        const at = markerClock();
+        const marker = markerFor(at, durations);
+        for (const tag of tags) {
+            this.set(tag, applyMarker(this.get(tag), marker));
+        }
+        const { markers, log } = this;
+        if (!markers || !log) {
+            return true;
+        }
+        const writes = [];
+        for (const tag of new Set(tags)) {
+            writes.push([
+                "Error writing tag revalidation marker:",
+                // The row as it is now, which carries any earlier `revalidatedAt`
+                // another instance wrote: tracking only what this call set would
+                // hide that one until the rolling re-read, and an entry older than it
+                // would read as merely stale.
+                markers.write(tag, at, durations).then((row) => {
+                    if (row) {
+                        this.set(tag, mergeMarkers(this.get(tag), row));
+                    }
+                }),
+            ]);
+            writes.push([
+                "Error writing tag revalidation log row:",
+                this.putLogRow(log, tag, marker),
+            ]);
+        }
+        const results = await Promise.allSettled(writes.map(([, write]) => write));
+        results.forEach((result, i) => {
+            if (result.status === "rejected") {
+                console.error(writes[i][0], result.reason);
+            }
+        });
+        return results.every((result) => result.status === "fulfilled");
+    }
+    /**
+     * Put `tag`'s log row, stamped on the wall clock (the marker values are on
+     * Next.js's: see {@link RevalidationLog}).
+     *
+     * Readers only look {@link REVALIDATION_LOG_LOOKBACK_MS} behind their last
+     * query, so a row that shows up much later than its timestamp - a slow
+     * connection, retries under throttling - is behind every cursor and never
+     * read. A slow put is therefore made again under a fresh timestamp, which
+     * readers will see; one slow twice is reported as a failure.
+     */
+    async putLogRow(log, tag, marker) {
+        for (let attempt = 0; attempt < 2; attempt++) {
+            const at = this.clock();
+            await log.put(tag, at, marker);
+            if (this.clock() - at <= MAX_LOG_PUT_MS) {
+                return;
+            }
+        }
+        throw new Error(`The revalidation log row for ${tag} took longer than readers look back`);
+    }
+    /**
+     * One refresh started at `at`: the log rows since the cursor, and the next
+     * slice of the rolling re-read.
+     *
+     * A failed query changes nothing but the log: the tags stay tracked as they
+     * were, and the next refresh asks again from the same cursor.
+     */
+    async sync(at, log) {
+        if (at - this.lastLogRead > exports.MAX_REVALIDATION_LOG_GAP_MS) {
+            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)),
+        ]);
+        if (!result) {
+            return;
+        }
+        if (result.truncated) {
+            this.forget(at, "the revalidation log has more rows than one query reads");
+            return;
+        }
+        let applied = 0;
+        for (const row of result.rows) {
+            if (this.applied.has(row.sk)) {
+                continue;
+            }
+            const marker = this.tags.get(row.tag);
+            if (marker) {
+                // `set` on a key already there keeps its place in the LRU order: being
+                // revalidated elsewhere is not a use.
+                this.tags.set(row.tag, mergeMarkers(marker, row.marker));
+            }
+            else if (this.reading.has(row.tag)) {
+                this.pendingRows.set(row.tag, mergeMarkers(this.pendingRows.get(row.tag), row.marker));
+            }
+            else {
+                // A tag this instance does not track is read from its marker when it
+                // is next needed - but not yet marked applied, because that read may
+                // miss this very revalidation: the writer puts the log row and the
+                // marker at the same time, and the read is an eventually consistent
+                // `BatchGetItem` that can land milliseconds after the row showed here.
+                // Marked applied, the row was skipped by every query the lookback
+                // returned it to, and the pre-revalidation marker stood until the
+                // 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.
+                continue;
+            }
+            this.applied.set(row.sk, row.at);
+            applied++;
+        }
+        this.lastLogRead = at;
+        this.advance(at - exports.REVALIDATION_LOG_LOOKBACK_MS);
+        this.debug(`read ${result.rows.length} revalidation log rows (${applied} applied)`);
+    }
+    /**
+     * The tags to read on this refresh, at most one `BatchGetItem`'s worth:
+     * those whose read failed, then those whose re-read has come due, in the
+     * order they were last read.
+     */
+    due(at) {
+        const due = [];
+        for (const tag of this.unread) {
+            if (due.length >= exports.BATCH_GET_MAX_KEYS)
+                return due;
+            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.
+        const jitter = this.resyncIntervalMs * TAG_RESYNC_JITTER;
+        for (const [tag, dueAt] of this.dueAt) {
+            if (due.length >= exports.BATCH_GET_MAX_KEYS || dueAt - jitter > at) {
+                break;
+            }
+            if (dueAt <= at && !this.unread.has(tag)) {
+                due.push(tag);
+            }
+        }
+        return due;
+    }
+    /**
+     * Forget every tracked marker, and follow the log from `at`: what is needed
+     * next is read from its marker as it is needed, spread over the requests
+     * that need it, rather than every tracked tag re-read at once.
+     */
+    forget(at, why) {
+        this.debug(`forgetting ${this.tags.size} tracked tags: ${why}`);
+        this.tags.clear();
+        this.dueAt.clear();
+        this.unread.clear();
+        this.applied.clear();
+        this.cursor = at - exports.REVALIDATION_LOG_LOOKBACK_MS;
+        this.lastLogRead = at;
+    }
+    /**
+     * Move the cursor forward to `cursor`, forgetting applied rows before it:
+     * no query returns them again.
+     */
+    advance(cursor) {
+        if (cursor <= this.cursor) {
+            return;
+        }
+        this.cursor = cursor;
+        for (const [sk, at] of this.applied) {
+            if (at < cursor) {
+                this.applied.delete(sk);
+            }
+        }
+    }
+    /**
+     * Read `tags` from the table, and report whether that worked. A read that
+     * fails leaves them tracked as they were, and the next refresh reads them
+     * again: the same "assume the entry is valid" the incremental cache has
+     * always answered with, rather than a read on every request while DynamoDB
+     * is unavailable.
+     */
+    async readInto(tags) {
+        if (tags.length === 0) {
+            return true;
+        }
+        const at = this.clock();
+        try {
+            const read = await this.markers.read(tags);
+            for (const tag of tags) {
+                this.unread.delete(tag);
+                this.remember(tag, mergeMarkers(mergeMarkers(this.tags.get(tag), read.get(tag)), this.takePendingRows(tag)));
+                this.known(tag, at);
+            }
+            this.debug(`read ${tags.length} tag markers (${read.size} set)`);
+            return true;
+        }
+        catch (error) {
+            console.error("Error reading tag markers:", error);
+            this.trackUnread(tags);
+            for (const tag of tags) {
+                this.unread.add(tag);
+                const pending = this.takePendingRows(tag);
+                if (pending) {
+                    this.remember(tag, mergeMarkers(this.tags.get(tag), pending));
+                }
+            }
+            return false;
+        }
+    }
+    takePendingRows(tag) {
+        const pending = this.pendingRows.get(tag);
+        this.pendingRows.delete(tag);
+        return pending;
+    }
+    /** Record that `tag`'s marker was known from the table at `at`. */
+    known(tag, at) {
+        this.dueAt.delete(tag);
+        this.dueAt.set(tag, at + this.resyncIntervalMs * (1 - TAG_RESYNC_JITTER * this.random()));
+    }
+    remember(tag, marker) {
+        this.tags.delete(tag);
+        this.tags.set(tag, marker);
+        for (const oldest of this.tags.keys()) {
+            if (this.tags.size <= this.maxTrackedTags) {
+                break;
+            }
+            this.tags.delete(oldest);
+            this.dueAt.delete(oldest);
+            this.unread.delete(oldest);
+        }
+    }
+    touch(tag) {
+        const marker = this.tags.get(tag);
+        if (marker) {
+            this.remember(tag, marker);
+        }
+    }
+}
+exports.TrackedTagMarkers = TrackedTagMarkers;
+/**
+ * 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;
+/**
+ * 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
+ * consistent, and a read straight after this instance's own revalidation could
+ * otherwise take it back.
+ */
+function mergeMarkers(local, remote) {
+    if (!local) {
+        return remote ?? {};
+    }
+    if (!remote) {
+        return local;
+    }
+    // `expiredAt` is written with `staleAt`, so it belongs to whichever is
+    // newer - unless that revalidation's profile had no `expire` and left it.
+    const [older, newer] = (local.staleAt ?? -1) > (remote.staleAt ?? -1)
+        ? [remote, local]
+        : [local, remote];
+    return {
+        ...applyMarker(older, newer),
+        revalidatedAt: maxDefined(local.revalidatedAt, remote.revalidatedAt),
+    };
+}
+function maxDefined(a, b) {
+    if (a === undefined)
+        return b;
+    if (b === undefined)
+        return a;
+    return Math.max(a, b);
+}
+/**
+ * The cache bucket, as the handlers use it: whole objects read and written as
+ * UTF-8 text under the keys above.
+ */
+class CacheBucket {
+    client;
+    bucketName;
+    constructor(client, bucketName) {
+        this.client = client;
+        this.bucketName = bucketName;
+    }
+    /**
+     * The body of the object at `key`, or `undefined` when there is none (`NoSuchKey`, or an
+     * empty response body). Any other error is thrown: the handlers disagree on
+     * whether one is worth logging.
+     */
+    async get(key) {
+        try {
+            const response = await this.client.send(new client_s3_1.GetObjectCommand({ Bucket: this.bucketName, Key: key }));
+            if (!response.Body) {
+                return undefined;
+            }
+            return await response.Body.transformToString("utf-8");
+        }
+        catch (error) {
+            if (error instanceof client_s3_1.NoSuchKey) {
+                return undefined;
+            }
+            throw error;
+        }
+    }
+    /** Write `body` as a JSON object at `key`. */
+    async putJson(key, body) {
+        await this.client.send(new client_s3_1.PutObjectCommand({
+            Bucket: this.bucketName,
+            Key: key,
+            Body: body,
+            ContentType: "application/json; charset=utf-8",
+        }));
+    }
+}
+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"]}