cdk-nextjs 0.7.5 → 0.7.7

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

@@ -152,6 +152,29 @@ describe("TagMarkerTable", () => {
             expiredAt: undefined,
         });
     });
+    it("keys a tag past the sort key limit by its hash, and reads it back as the tag", async () => {
+        // `revalidatePath` on a long path: an implicit tag is as long as the path.
+        const tag = `_N_T_/${"p".repeat(1100)}`;
+        send.mockResolvedValue({});
+        await table.write(tag, 1000, undefined);
+        const written = commandInput(send.mock.calls[0][0], client_dynamodb_1.UpdateItemCommand);
+        expect(written.Key.sk.S).toBe((0, aws_cache_store_1.hashedTag)(tag));
+        expect((0, aws_cache_store_1.hashedTag)(tag)).toMatch(/^#[0-9a-f]{64}$/);
+        send.mockReset();
+        send.mockImplementation((command) => {
+            const { RequestItems } = commandInput(command, client_dynamodb_1.BatchGetItemCommand);
+            return Promise.resolve({
+                Responses: {
+                    tbl: RequestItems.tbl.Keys.map(({ sk }) => ({
+                        sk,
+                        revalidatedAt: { N: "7" },
+                    })),
+                },
+            });
+        });
+        const markers = await table.read([tag, "short"]);
+        expect([...markers.keys()].sort()).toEqual(["short", tag].sort());
+    });
     // A read-back after the write is eventually consistent, so it can return
     // the marker from before it: the writer tracks what the write returned.
     it("returns the row as the write left it", async () => {
@@ -269,6 +292,18 @@ describe("RevalidationLog", () => {
             },
         ]);
     });
+    it("hashes a tag too long for the sort key, carrying it in longTag", async () => {
+        const tag = `_N_T_/${"p".repeat(1100)}`;
+        send.mockResolvedValue({});
+        await log.put(tag, 1000, { revalidatedAt: 5 });
+        const { Item } = commandInput(send.mock.calls[0][0], client_dynamodb_1.PutItemCommand);
+        expect(Item.sk.S).toBe(`000000000001000#${(0, aws_cache_store_1.hashedTag)(tag)}`);
+        expect(Item.longTag).toEqual({ S: tag });
+        send.mockReset();
+        send.mockResolvedValueOnce({ Items: [{ ...Item }] });
+        const { rows } = await log.query(0);
+        expect(rows.map((row) => row.tag)).toEqual([tag]);
+    });
     it("stops after its page bound and says so", async () => {
         send.mockResolvedValue({
             Items: [],
@@ -317,6 +352,677 @@ describe("CacheBucket", () => {
     });
 });
 describe("TrackedTagMarkers", () => {
+    it("never counts a render the runtime caught up as behind", async () => {
+        let clock = 1_000_000;
+        const markers = new aws_cache_store_1.TrackedTagMarkers({
+            markers: { read: jest.fn() },
+            log: { query: jest.fn() },
+            refreshIntervalMs: 1000,
+            clock: () => clock,
+        });
+        // Just short of the line as the request came in: `catchUp` lets it go.
+        clock += 1000 + aws_cache_store_1.TAG_REFRESH_GRACE_MS;
+        expect(markers.behind).toBe(false);
+        await markers.catchUp(async () => {
+            // However long the render takes, its lookups never wait: waiting is
+            // what the catch-up before it was for.
+            clock += 100;
+            expect(markers.behind).toBe(true);
+            expect(markers.behindInRender).toBe(false);
+            clock += 60_000;
+            expect(markers.behindInRender).toBe(false);
+        });
+        // Outside it - a route handler alongside, in a container - it waits.
+        expect(markers.behindInRender).toBe(true);
+    });
+    it("gives a render no grace when catchUp, holding nothing, did not catch up", async () => {
+        let clock = 1_000_000;
+        let held = false;
+        const markers = new aws_cache_store_1.TrackedTagMarkers({
+            markers: { read: jest.fn() },
+            log: {
+                query: jest.fn(async () => ({ rows: [], truncated: false })),
+            },
+            refreshIntervalMs: 1000,
+            clock: () => clock,
+        });
+        markers.judgeEntriesOf(() => (held ? 0 : Infinity), () => held);
+        clock += 1000 + aws_cache_store_1.TAG_REFRESH_GRACE_MS + 100;
+        await markers.catchUp(async () => {
+            // Another request stores an entry before this render's first lookup.
+            held = true;
+            expect(markers.behindInRender).toBe(true);
+        });
+    });
+    it("starts a refresh for a page that is not behind, without waiting for it", async () => {
+        let clock = 1_000_000;
+        let release;
+        const query = jest.fn(() => new Promise((resolve) => (release = () => resolve({ rows: [], truncated: false }))));
+        const markers = new aws_cache_store_1.TrackedTagMarkers({
+            markers: { read: jest.fn() },
+            log: { query },
+            refreshIntervalMs: 1000,
+            clock: () => clock,
+        });
+        markers.judgeEntriesOf(() => 0);
+        clock += 1000;
+        expect(markers.behind).toBe(false);
+        // A page that reads no cache still keeps the instance current.
+        await expect(markers.catchUp(async () => "page")).resolves.toBe("page");
+        expect(query).toHaveBeenCalledTimes(1);
+        release();
+    });
+    it("catches up on the log without waiting for the rolling re-read", async () => {
+        let clock = 1_000_000;
+        let release;
+        const read = jest.fn(async (tags) => {
+            if (read.mock.calls.length > 1) {
+                await new Promise((resolve) => (release = resolve));
+            }
+            return new Map(tags.map((tag) => [tag, {}]));
+        });
+        const markers = new aws_cache_store_1.TrackedTagMarkers({
+            markers: { read },
+            log: {
+                query: jest.fn(async () => ({ rows: [], truncated: false })),
+            },
+            refreshIntervalMs: 1000,
+            resyncIntervalMs: 1000,
+            random: () => 0,
+            clock: () => clock,
+        });
+        markers.judgeEntriesOf(() => 0);
+        await markers.ensure(["posts"]);
+        // Due for its re-read, and behind, as after a quiet spell.
+        clock += 5000;
+        expect(markers.behind).toBe(true);
+        let rendered = false;
+        await markers.catchUp(async () => (rendered = true));
+        // A throttled `BatchGetItem` would otherwise hold the page.
+        expect(rendered).toBe(true);
+        expect(read).toHaveBeenCalledTimes(2);
+        // Nor does a lookup of the tracked tag wait on it.
+        let ensured = false;
+        void markers.ensure(["posts"]).then(() => (ensured = true));
+        await new Promise((resolve) => setImmediate(resolve));
+        expect(ensured).toBe(true);
+        // Still in flight an interval later: not read a second time meanwhile.
+        clock += 1000;
+        await markers.refresh();
+        expect(read).toHaveBeenCalledTimes(2);
+        release();
+    });
+    it("gives a route handler, which no catch-up precedes, no grace more", async () => {
+        let clock = 1_000_000;
+        const markers = new aws_cache_store_1.TrackedTagMarkers({
+            markers: { read: jest.fn() },
+            log: { query: jest.fn() },
+            refreshIntervalMs: 1000,
+            clock: () => clock,
+        });
+        clock += 1000 + aws_cache_store_1.TAG_REFRESH_GRACE_MS + 100;
+        expect(markers.behindInRender).toBe(true);
+    });
+    it("reads again only once, however many forgets land meanwhile", async () => {
+        let clock = 1_000_000;
+        const releases = [];
+        const read = jest.fn(async () => {
+            await new Promise((resolve) => releases.push(resolve));
+            return new Map([["posts", { revalidatedAt: 1 }]]);
+        });
+        const markers = new aws_cache_store_1.TrackedTagMarkers({
+            markers: { read },
+            log: {
+                query: jest.fn(async () => ({ rows: [], truncated: false })),
+            },
+            refreshIntervalMs: 0,
+            clock: () => clock,
+        });
+        markers.judgeEntriesOf(() => 0);
+        const forget = async () => {
+            clock += aws_cache_store_1.MAX_REVALIDATION_LOG_GAP_MS + 1;
+            await markers.refresh();
+        };
+        const ensuring = markers.ensure(["posts"]);
+        await forget();
+        releases.shift()();
+        await new Promise((resolve) => setImmediate(resolve));
+        await forget();
+        releases.shift()();
+        await ensuring;
+        // A truncated log forgets on every query: waiting for a read no forget
+        // overtook would keep the requests waiting on this one for as long.
+        expect(read).toHaveBeenCalledTimes(2);
+        expect(markers.get("posts")).toEqual({ revalidatedAt: 1 });
+    });
+    it("reads again what a read from before a forget found", async () => {
+        let clock = 1_000_000;
+        let release;
+        const held = new Promise((resolve) => (release = resolve));
+        let revalidatedAt;
+        const read = jest.fn(async () => {
+            await held;
+            return new Map(revalidatedAt === undefined ? [] : [["posts", { revalidatedAt }]]);
+        });
+        const markers = new aws_cache_store_1.TrackedTagMarkers({
+            markers: { read },
+            log: {
+                query: jest.fn(async () => ({ rows: [], truncated: false })),
+            },
+            refreshIntervalMs: 0,
+            clock: () => clock,
+        });
+        markers.judgeEntriesOf(() => 0);
+        // A background read in flight as the sandbox froze, past the log's TTL.
+        const ensuring = markers.ensure(["posts"]);
+        clock += aws_cache_store_1.MAX_REVALIDATION_LOG_GAP_MS + 1;
+        await markers.refresh();
+        // Read again once the stale read returns: tracked, its marker would
+        // vouch for every entry with the tag, revalidated during the freeze or
+        // not; untracked, the request waiting on it would judge by nothing.
+        revalidatedAt = (0, aws_cache_store_1.markerClock)();
+        release();
+        await ensuring;
+        expect(read).toHaveBeenCalledTimes(2);
+        expect(markers.get("posts")).toEqual({ revalidatedAt });
+    });
+    it("moves completeSince past what it forgets", async () => {
+        let clock = 1_000_000;
+        const later = (0, aws_cache_store_1.markerClock)() + 60_000;
+        const rows = ["a", "b"].map((tag, i) => ({
+            sk: `${String(clock).padStart(15, "0")}#${tag}`,
+            at: clock,
+            tag,
+            marker: { revalidatedAt: later + i },
+        }));
+        const query = jest.fn(async () => ({ rows, truncated: false }));
+        const markers = new aws_cache_store_1.TrackedTagMarkers({
+            markers: { read: jest.fn() },
+            log: { query },
+            refreshIntervalMs: 0,
+            maxTrackedTags: 1,
+            clock: () => clock,
+        });
+        // An entry store holding something older than every row.
+        markers.judgeEntriesOf(() => 0);
+        const start = markers.completeSince;
+        expect(start).toBeLessThanOrEqual((0, aws_cache_store_1.markerClock)());
+        // Untracked tags' rows are known from the log alone, as far as they fit.
+        await markers.refresh();
+        expect(markers.state(["b"], later)).toBe("expired");
+        // "a" was dropped for space, and with it what it knew.
+        expect(markers.state(["a"], later)).toBe("fresh");
+        expect(markers.completeSince).toBe(later);
+        // Forgetting everything moves it to now, or past what it forgot: "b".
+        clock += aws_cache_store_1.MAX_REVALIDATION_LOG_GAP_MS + 1;
+        await markers.refresh();
+        expect(markers.completeSince).toBe(later + 1);
+    });
+    it("moves completeSince past a row it lets go of with no entry held", async () => {
+        const clock = 1_000_000;
+        const revalidatedAt = (0, aws_cache_store_1.markerClock)() + 60_000;
+        const markers = new aws_cache_store_1.TrackedTagMarkers({
+            markers: { read: jest.fn() },
+            log: {
+                query: jest.fn(async () => ({
+                    rows: [
+                        {
+                            sk: `${String(clock).padStart(15, "0")}#posts`,
+                            at: clock,
+                            tag: "posts",
+                            marker: { revalidatedAt },
+                        },
+                    ],
+                    truncated: false,
+                })),
+            },
+            refreshIntervalMs: 0,
+            clock: () => clock,
+        });
+        markers.judgeEntriesOf(() => Infinity);
+        await markers.refresh();
+        // An entry whose generation started before the revalidation, stored once
+        // the row is gone, is older than `completeSince`, and so read first.
+        expect(markers.state(["posts"], revalidatedAt - 1)).toBe("fresh");
+        expect(markers.completeSince).toBe(revalidatedAt);
+    });
+    it("prunes a profile's row, and moves completeSince to its expiredAt once past", async () => {
+        const clock = 1_000_000;
+        const staleAt = (0, aws_cache_store_1.markerClock)() + 1000;
+        const expiredAt = staleAt + 60_000;
+        const markers = new aws_cache_store_1.TrackedTagMarkers({
+            markers: { read: jest.fn() },
+            log: {
+                query: jest.fn(async () => ({
+                    rows: [
+                        {
+                            sk: `${String(clock).padStart(15, "0")}#posts`,
+                            at: clock,
+                            tag: "posts",
+                            marker: { staleAt, expiredAt },
+                        },
+                    ],
+                    truncated: false,
+                })),
+            },
+            refreshIntervalMs: 0,
+            clock: () => clock,
+        });
+        markers.judgeEntriesOf(() => staleAt + 1);
+        await markers.refresh();
+        expect(markers.state(["posts"], staleAt - 1)).toBe("fresh");
+        expect(markers.completeSince).toBe(staleAt);
+        const now = jest
+            .spyOn(performance, "now")
+            .mockReturnValue(expiredAt - performance.timeOrigin);
+        try {
+            expect(markers.completeSince).toBe(expiredAt);
+        }
+        finally {
+            now.mockRestore();
+        }
+    });
+    it("queues a pruned row's future expiredAt once, however often the lookback returns it", async () => {
+        let clock = 1_000_000;
+        const staleAt = (0, aws_cache_store_1.markerClock)() + 1000;
+        const markers = new aws_cache_store_1.TrackedTagMarkers({
+            markers: { read: jest.fn() },
+            log: {
+                query: jest.fn(async () => ({
+                    rows: [
+                        {
+                            sk: `${String(1_000_000).padStart(15, "0")}#posts`,
+                            at: 1_000_000,
+                            tag: "posts",
+                            marker: { staleAt, expiredAt: staleAt + 60_000 },
+                        },
+                    ],
+                    truncated: false,
+                })),
+            },
+            refreshIntervalMs: 0,
+            clock: () => clock,
+        });
+        markers.judgeEntriesOf(() => staleAt + 1);
+        for (let i = 0; i < 3; i++) {
+            await markers.refresh();
+            clock += 1000;
+        }
+        // Pruned rows are not marked applied, so each query applies it again.
+        expect(markers.laterFloors).toHaveLength(1);
+    });
+    it("merges future expiredAts past its bound without moving completeSince early", async () => {
+        const at = (0, aws_cache_store_1.markerClock)();
+        const expiries = new Map([
+            ["a", at + 60_000],
+            ["b", at + 60_010],
+            ["c", at + 120_000],
+        ]);
+        const markers = new aws_cache_store_1.TrackedTagMarkers({
+            markers: {
+                read: jest.fn(async (tags) => new Map(tags.map((tag) => [
+                    tag,
+                    { staleAt: at - 1000, expiredAt: expiries.get(tag) },
+                ]))),
+            },
+            log: { query: jest.fn() },
+            maxTrackedTags: 1,
+        });
+        const start = markers.completeSince;
+        // "a", then "b", dropped for space: two expiredAts past a bound of one.
+        for (const tag of ["a", "b", "c"]) {
+            await markers.ensure([tag]);
+        }
+        expect(markers.completeSince).toBe(start);
+        const now = jest.spyOn(performance, "now");
+        try {
+            now.mockReturnValue(at + 59_999 - performance.timeOrigin);
+            expect(markers.completeSince).toBe(start);
+            // Merged: "b"'s from "a"'s, 10 ms early.
+            now.mockReturnValue(at + 60_000 - performance.timeOrigin);
+            expect(markers.completeSince).toBe(at + 60_010);
+        }
+        finally {
+            now.mockRestore();
+        }
+    });
+    it("does not join a near expiredAt to far ones past its bound", async () => {
+        const at = (0, aws_cache_store_1.markerClock)();
+        const year = 365 * 24 * 60 * 60 * 1000;
+        const expiries = new Map([
+            ["a", at + year],
+            ["b", at + year + 10],
+            ["c", at + 60_000],
+        ]);
+        const markers = new aws_cache_store_1.TrackedTagMarkers({
+            markers: {
+                read: jest.fn(async (tags) => new Map(tags.map((tag) => [
+                    tag,
+                    { staleAt: at - 1000, expiredAt: expiries.get(tag) },
+                ]))),
+            },
+            log: { query: jest.fn() },
+            maxTrackedTags: 2,
+        });
+        for (const tag of ["a", "b", "c", "d", "e"]) {
+            await markers.ensure([tag]);
+        }
+        const now = jest
+            .spyOn(performance, "now")
+            .mockReturnValue(at + 60_000 - performance.timeOrigin);
+        try {
+            // "a" and "b" are merged, not "c" into "a": `completeSince` a year
+            // early would have every held entry read its markers first until then.
+            expect(markers.completeSince).toBe(at + 60_000);
+        }
+        finally {
+            now.mockRestore();
+        }
+    });
+    it("merges the closest future expiredAts past its bound", async () => {
+        const at = (0, aws_cache_store_1.markerClock)();
+        const expiries = new Map([
+            ["a", at + 60_000],
+            ["b", at + 120_000],
+            ["c", at + 60_010],
+        ]);
+        const markers = new aws_cache_store_1.TrackedTagMarkers({
+            markers: {
+                read: jest.fn(async (tags) => new Map(tags.map((tag) => [
+                    tag,
+                    { staleAt: at - 1000, expiredAt: expiries.get(tag) },
+                ]))),
+            },
+            log: { query: jest.fn() },
+            maxTrackedTags: 2,
+        });
+        // "a", "b", then "c" dropped for space: three expiredAts past a bound of
+        // two, and "c" is 10 ms from "a".
+        for (const tag of ["a", "b", "c", "d", "e"]) {
+            await markers.ensure([tag]);
+        }
+        const start = markers.completeSince;
+        const now = jest.spyOn(performance, "now");
+        try {
+            now.mockReturnValue(at + 59_999 - performance.timeOrigin);
+            expect(markers.completeSince).toBe(start);
+            now.mockReturnValue(at + 60_000 - performance.timeOrigin);
+            expect(markers.completeSince).toBe(at + 60_010);
+            now.mockReturnValue(at + 119_999 - performance.timeOrigin);
+            expect(markers.completeSince).toBe(at + 60_010);
+            now.mockReturnValue(at + 120_000 - performance.timeOrigin);
+            expect(markers.completeSince).toBe(at + 120_000);
+        }
+        finally {
+            now.mockRestore();
+        }
+    });
+    it("catches up only for an entry store holding entries, and not when every check asks anyway", async () => {
+        let clock = 1_000_000;
+        const instance = (refreshIntervalMs) => {
+            const query = jest.fn(async () => ({ rows: [], truncated: false }));
+            const markers = new aws_cache_store_1.TrackedTagMarkers({
+                markers: { read: jest.fn() },
+                log: { query },
+                refreshIntervalMs,
+                clock: () => clock,
+            });
+            return { markers, query };
+        };
+        const noStore = instance(1000);
+        const everyCheck = instance(0);
+        everyCheck.markers.judgeEntriesOf(() => Infinity);
+        // A store, but holding nothing a refresh could expire.
+        const emptyStore = instance(1000);
+        emptyStore.markers.judgeEntriesOf(() => Infinity);
+        const store = instance(1000);
+        store.markers.judgeEntriesOf(() => 0);
+        clock += 60_000;
+        for (const { markers } of [noStore, everyCheck, emptyStore, store]) {
+            expect(markers.behind).toBe(true);
+            await markers.catchUp(async () => { });
+        }
+        expect(noStore.query).not.toHaveBeenCalled();
+        expect(everyCheck.query).not.toHaveBeenCalled();
+        expect(emptyStore.query).not.toHaveBeenCalled();
+        expect(store.query).toHaveBeenCalledTimes(1);
+    });
+    it("moves completeSince to a dropped marker's future expiredAt only once it is past", async () => {
+        const at = (0, aws_cache_store_1.markerClock)();
+        const read = jest.fn(async (tags) => new Map(tags.map((tag) => [
+            tag,
+            { staleAt: at - 1000, expiredAt: at + 60_000 },
+        ])));
+        const markers = new aws_cache_store_1.TrackedTagMarkers({
+            markers: { read },
+            log: { query: jest.fn() },
+            maxTrackedTags: 1,
+        });
+        const start = markers.completeSince;
+        await markers.ensure(["a"]);
+        // "a" is dropped for space: a year-long `expire` would otherwise keep
+        // every entry reading its markers first for as long.
+        await markers.ensure(["b"]);
+        expect(markers.completeSince).toBe(start);
+        const clock = jest
+            .spyOn(performance, "now")
+            .mockReturnValue(at + 60_001 - performance.timeOrigin);
+        try {
+            expect(markers.completeSince).toBe(at + 60_000);
+        }
+        finally {
+            clock.mockRestore();
+        }
+    });
+    it("keeps only the log rows that could apply to an entry held", async () => {
+        let clock = 1_000_000;
+        const later = (0, aws_cache_store_1.markerClock)() + 60_000;
+        const rows = ["old", "new"].map((tag, i) => ({
+            sk: `${String(clock).padStart(15, "0")}#${tag}`,
+            at: clock,
+            tag,
+            marker: { revalidatedAt: i === 0 ? 1 : later },
+        }));
+        const markers = new aws_cache_store_1.TrackedTagMarkers({
+            markers: { read: jest.fn() },
+            log: {
+                query: jest.fn(async () => ({ rows, truncated: false })),
+            },
+            refreshIntervalMs: 0,
+            maxTrackedTags: 1,
+            clock: () => clock,
+        });
+        let oldest = 2;
+        markers.judgeEntriesOf(() => oldest);
+        const start = markers.completeSince;
+        // "old" can expire nothing held, so it takes no room, and "new" is
+        // kept without dropping anything for space.
+        await markers.refresh();
+        expect(markers.state(["new"], later - 1)).toBe("expired");
+        expect(markers.completeSince).toBe(start);
+        // Once every entry held is newer than it, "new" goes too, taking
+        // `completeSince` no further than the oldest entry held.
+        oldest = later;
+        clock += 1000;
+        await markers.refresh();
+        expect(markers.state(["new"], later - 1)).toBe("fresh");
+        expect(markers.completeSince).toBe(later);
+    });
+    it("scans the entry stores once a minute, pruning only when the oldest moves", async () => {
+        let clock = 1_000_000;
+        const later = (0, aws_cache_store_1.markerClock)() + 60_000;
+        const rows = [
+            {
+                sk: `${String(clock).padStart(15, "0")}#new`,
+                at: clock,
+                tag: "new",
+                marker: { revalidatedAt: later },
+            },
+        ];
+        const markers = new aws_cache_store_1.TrackedTagMarkers({
+            markers: { read: jest.fn() },
+            // The row leaves the lookback after the first query: only the prune
+            // can let it go.
+            log: {
+                query: jest
+                    .fn()
+                    .mockResolvedValueOnce({ rows, truncated: false })
+                    .mockResolvedValue({ rows: [], truncated: false }),
+            },
+            refreshIntervalMs: 0,
+            clock: () => clock,
+        });
+        let bound = 2;
+        let exact = 2;
+        const oldest = jest.fn((scan) => (scan ? exact : bound));
+        markers.judgeEntriesOf(oldest);
+        const prune = jest.spyOn(markers, "pruneLogged");
+        await markers.refresh();
+        expect(oldest).toHaveBeenLastCalledWith(true);
+        expect(prune).toHaveBeenCalledTimes(1);
+        // Within the minute: the bound, and no prune while it stays put.
+        clock += 1000;
+        exact = later;
+        await markers.refresh();
+        expect(oldest).toHaveBeenLastCalledWith(false);
+        expect(prune).toHaveBeenCalledTimes(1);
+        expect(markers.state(["new"], later - 1)).toBe("expired");
+        // The minute's scan finds every entry newer than the row: it goes.
+        clock += 60_000;
+        await markers.refresh();
+        expect(oldest).toHaveBeenLastCalledWith(true);
+        expect(prune).toHaveBeenCalledTimes(2);
+        expect(markers.state(["new"], later - 1)).toBe("fresh");
+        expect(markers.completeSince).toBe(later);
+        // An entry set since moves the bound back: nothing to prune.
+        clock += 1000;
+        bound = 1;
+        await markers.refresh();
+        expect(prune).toHaveBeenCalledTimes(2);
+    });
+    it("waits for a fresh query rather than one started before a freeze", async () => {
+        let clock = 1_000_000;
+        const queries = [];
+        const query = jest.fn(() => new Promise((resolve) => queries.push(() => resolve({ rows: [], truncated: false }))));
+        const markers = new aws_cache_store_1.TrackedTagMarkers({
+            markers: { read: jest.fn() },
+            log: { query },
+            refreshIntervalMs: 1000,
+            clock: () => clock,
+            canFreeze: true,
+        });
+        markers.judgeEntriesOf(() => 0);
+        clock += 1000;
+        // Started, not waited for, and then the sandbox froze.
+        void markers.refresh();
+        clock += 60_000;
+        expect(markers.behind).toBe(true);
+        let caughtUp = false;
+        const catchUp = markers
+            .catchUp(async () => { })
+            .then(() => (caughtUp = true));
+        queries.shift()();
+        await new Promise((resolve) => setImmediate(resolve));
+        expect(caughtUp).toBe(false);
+        expect(query).toHaveBeenCalledTimes(2);
+        queries.shift()();
+        await catchUp;
+        expect(markers.behind).toBe(false);
+    });
+    describe("with a refresh in flight", () => {
+        let clock;
+        beforeEach(() => {
+            clock = 1_000_000;
+            jest.useFakeTimers({ doNotFake: ["setImmediate", "nextTick"] });
+        });
+        afterEach(() => jest.useRealTimers());
+        /** Move the clock and the timers on together: no freeze. */
+        const run = (ms) => {
+            for (let step = 0; step < ms; step += 250) {
+                clock += 250;
+                jest.advanceTimersByTime(250);
+            }
+        };
+        const instance = (fails = false, canFreeze = true) => {
+            const queries = [];
+            const query = jest.fn(() => new Promise((resolve, reject) => queries.push(() => fails
+                ? reject(new Error("throttled"))
+                : resolve({ rows: [], truncated: false }))));
+            const markers = new aws_cache_store_1.TrackedTagMarkers({
+                markers: { read: jest.fn() },
+                log: { query },
+                refreshIntervalMs: 1000,
+                clock: () => clock,
+                canFreeze,
+            });
+            markers.judgeEntriesOf(() => 0);
+            return { markers, query, queries };
+        };
+        it("waits for a fresh query after a freeze, even once the late tick has run", async () => {
+            const { markers, query, queries } = instance();
+            clock += 1000;
+            void markers.refresh();
+            clock += 60_000;
+            // After the thaw the overdue tick can run before any request does.
+            jest.advanceTimersByTime(250);
+            let caughtUp = false;
+            const catchUp = markers
+                .catchUp(async () => { })
+                .then(() => (caughtUp = true));
+            queries.shift()();
+            await new Promise((resolve) => setImmediate(resolve));
+            // What the first query knew predates the freeze.
+            expect(markers.behind).toBe(true);
+            expect(caughtUp).toBe(false);
+            expect(query).toHaveBeenCalledTimes(2);
+            queries.shift()();
+            await catchUp;
+            expect(markers.behind).toBe(false);
+        });
+        it("in a container, which is never frozen, waits only for the query in flight", async () => {
+            const { markers, query, queries } = instance(false, false);
+            clock += 1000;
+            void markers.refresh();
+            // A long stall, not a freeze: no timer to tell them apart, none needed.
+            clock += 60_000;
+            const catchUp = markers.catchUp(async () => { });
+            queries.shift()();
+            await catchUp;
+            expect(query).toHaveBeenCalledTimes(1);
+            expect(markers.behind).toBe(false);
+        });
+        it("is caught up once the catch-up's slow query returns, the process running throughout", async () => {
+            for (const fails of [false, true]) {
+                const { markers, queries } = instance(fails);
+                clock += 60_000;
+                expect(markers.behind).toBe(true);
+                const catchUp = markers.catchUp(async () => { });
+                run(3000);
+                queries.shift()();
+                await catchUp;
+                // Or the first `'use cache'` lookup would wait for another query,
+                // inside the render: one request, two waits.
+                expect(markers.behind).toBe(false);
+            }
+        });
+        it("waits only for a slow query in flight, the process running throughout", async () => {
+            const { markers, query, queries } = instance();
+            clock += 60_000;
+            const first = markers.catchUp(async () => { });
+            run(2500);
+            // Past the grace into the query, but the query is as fresh as any.
+            let caughtUp = false;
+            const second = markers
+                .catchUp(async () => { })
+                .then(() => (caughtUp = true));
+            queries.shift()();
+            await first;
+            await new Promise((resolve) => setImmediate(resolve));
+            expect(caughtUp).toBe(true);
+            await second;
+            expect(query).toHaveBeenCalledTimes(1);
+        });
+    });
     it("does not skip a row for an untracked tag that its first read missed", async () => {
         // The writer puts the log row and the marker at the same time, and the
         // marker read is eventually consistent: `refresh` can see the row, then
@@ -344,12 +1050,13 @@ describe("TrackedTagMarkers", () => {
             clock: () => clock,
             random: () => 0,
         });
-        // Something tracked, so the refresh queries the log.
+        markers.judgeEntriesOf(() => 0);
         await markers.ensure(["other"]);
         clock += 1000;
         await markers.refresh();
+        // The row seen before the read is applied to what the read found.
         await markers.ensure(["posts"]);
-        expect(markers.get("posts")).toEqual({});
+        expect(markers.get("posts")).toEqual({ revalidatedAt });
         clock += 1000;
         await markers.refresh();
         expect(query).toHaveBeenCalledTimes(2);
@@ -358,4 +1065,4 @@ describe("TrackedTagMarkers", () => {
         expect(read).toHaveBeenCalledTimes(2);
     });
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-cache-store.test.js","sourceRoot":"","sources":["../../src/adapter/aws-cache-store.test.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\njest.mock(\"@aws-sdk/client-s3\");\njest.mock(\"@aws-sdk/client-dynamodb\");\n\nimport {\n  BatchGetItemCommand,\n  DynamoDBClient,\n  PutItemCommand,\n  QueryCommand,\n  UpdateItemCommand,\n} from \"@aws-sdk/client-dynamodb\";\nimport {\n  GetObjectCommand,\n  NoSuchKey,\n  PutObjectCommand,\n  S3Client,\n} from \"@aws-sdk/client-s3\";\nimport {\n  buildS3Key,\n  CacheBucket,\n  markerFor,\n  markerState,\n  markerUpdate,\n  mergeMarkers,\n  resolveAwsCacheConfig,\n  REVALIDATION_LOG_MAX_PAGES,\n  REVALIDATION_LOG_TTL_MS,\n  RevalidationLog,\n  RevalidationLogRow,\n  TagMarker,\n  TagMarkerTable,\n  TrackedTagMarkers,\n  useCacheS3Key,\n} from \"./aws-cache-store\";\n\n/** The input an automocked SDK command was constructed with. */\nconst commandInput = (command: unknown, type: unknown) => {\n  const mock = type as jest.Mock;\n  return mock.mock.calls[mock.mock.instances.indexOf(command)][0];\n};\n\ndescribe(\"resolveAwsCacheConfig\", () => {\n  const env = process.env;\n  beforeEach(() => {\n    process.env = { ...env };\n  });\n  afterAll(() => {\n    process.env = env;\n  });\n\n  it(\"reads the environment the constructs set\", () => {\n    process.env.CDK_NEXTJS_CACHE_BUCKET_NAME = \"bucket\";\n    process.env.CDK_NEXTJS_REVALIDATION_TABLE_NAME = \"table\";\n    process.env.CDK_NEXTJS_BUILD_ID = \"build\";\n    process.env.AWS_REGION = \"eu-west-1\";\n    expect(resolveAwsCacheConfig()).toEqual({\n      bucketName: \"bucket\",\n      tableName: \"table\",\n      buildId: \"build\",\n      region: \"eu-west-1\",\n    });\n  });\n\n  it(\"reports what is unset as empty\", () => {\n    delete process.env.CDK_NEXTJS_CACHE_BUCKET_NAME;\n    delete process.env.CDK_NEXTJS_REVALIDATION_TABLE_NAME;\n    delete process.env.CDK_NEXTJS_BUILD_ID;\n    delete process.env.AWS_REGION;\n    expect(resolveAwsCacheConfig()).toEqual({\n      bucketName: \"\",\n      tableName: \"\",\n      buildId: \"\",\n      region: \"us-east-1\",\n    });\n  });\n});\n\ndescribe(\"S3 keys\", () => {\n  it(\"keeps the incremental cache's {buildId}/{key}.json convention\", () => {\n    expect(buildS3Key(\"b\", \"/\")).toBe(\"b/index.json\");\n    expect(buildS3Key(\"b\", \"\")).toBe(\"b/index.json\");\n    expect(buildS3Key(\"b\", \"/blog/post\")).toBe(\"b/blog/post.json\");\n    expect(buildS3Key(\"b\", \"abc123\")).toBe(\"b/abc123.json\");\n  });\n\n  it(\"puts 'use cache' entries where no incremental key can land\", () => {\n    const key = useCacheS3Key(\"b\", \"f\".repeat(64));\n    expect(key).toBe(`b/_use-cache/${\"f\".repeat(64)}.entry`);\n    // Even a route spelled like the use-cache key gets `.json` appended.\n    expect(buildS3Key(\"b\", `/_use-cache/${\"f\".repeat(64)}.entry`)).not.toBe(\n      key,\n    );\n    expect(key.endsWith(\".json\")).toBe(false);\n  });\n});\n\ndescribe(\"tag markers\", () => {\n  it(\"writes what markerFor applies locally\", () => {\n    for (const durations of [undefined, {}, { expire: 60 }]) {\n      const update = markerUpdate(1000, durations);\n      const local = markerFor(1000, durations);\n      const written: Record<string, number> = {};\n      for (const [name, value] of Object.entries(\n        update.ExpressionAttributeValues!,\n      )) {\n        written[name.slice(1)] = Number(value.N);\n      }\n      expect(written).toEqual(local);\n    }\n    expect(markerFor(1000, { expire: 60 })).toEqual({\n      staleAt: 1000,\n      expiredAt: 61000,\n    });\n  });\n\n  it(\"keeps an earlier expiredAt a profile with no expire leaves\", () => {\n    // The row keeps it (`SET staleAt` only), so an instance learning of the\n    // second revalidation from the log has to keep it too.\n    const first = markerFor(1000, { expire: 60 });\n    const second = markerFor(2000, {});\n    expect(mergeMarkers(first, second)).toEqual({\n      staleAt: 2000,\n      expiredAt: 61000,\n    });\n    expect(mergeMarkers(second, first)).toEqual({\n      staleAt: 2000,\n      expiredAt: 61000,\n    });\n    // A newer `expire` still replaces it.\n    expect(mergeMarkers(first, markerFor(2000, { expire: 1 }))).toEqual({\n      staleAt: 2000,\n      expiredAt: 3000,\n    });\n  });\n\n  it(\"judges an entry the way the incremental cache always has\", () => {\n    // Expired outright after creation.\n    expect(markerState({ revalidatedAt: 20 }, 10, 30)).toBe(\"expired\");\n    // Revalidated before the entry was created: no effect.\n    expect(markerState({ revalidatedAt: 5 }, 10, 30)).toBe(\"fresh\");\n    // A profile: stale now, expired once `expiredAt` passes.\n    expect(markerState({ staleAt: 20, expiredAt: 50 }, 10, 30)).toBe(\"stale\");\n    expect(markerState({ staleAt: 20, expiredAt: 50 }, 10, 60)).toBe(\"expired\");\n    // `expire: 0`: stale and expired at once.\n    expect(markerState({ staleAt: 20, expiredAt: 20 }, 10, 30)).toBe(\"expired\");\n    expect(markerState({}, 10, 30)).toBe(\"fresh\");\n  });\n});\n\ndescribe(\"TagMarkerTable\", () => {\n  const send = jest.fn();\n  let table: TagMarkerTable;\n\n  beforeEach(() => {\n    send.mockReset();\n    (DynamoDBClient as jest.Mock).mockImplementation(() => ({ send }));\n    table = new TagMarkerTable(new DynamoDBClient({}), \"tbl\", \"build\");\n  });\n\n  it(\"writes the marker row under the build\", async () => {\n    send.mockResolvedValue({});\n    await table.write(\"posts\", 1000, { expire: 1 });\n    const input = commandInput(send.mock.calls[0][0], UpdateItemCommand);\n    expect(input).toEqual({\n      TableName: \"tbl\",\n      Key: { pk: { S: \"build\" }, sk: { S: \"posts\" } },\n      UpdateExpression: \"SET staleAt = :staleAt, expiredAt = :expiredAt\",\n      ExpressionAttributeValues: {\n        \":staleAt\": { N: \"1000\" },\n        \":expiredAt\": { N: \"2000\" },\n      },\n      ReturnValues: \"ALL_NEW\",\n    });\n  });\n\n  it(\"reads markers in batches of 100 and parses them\", async () => {\n    send.mockImplementation((command: unknown) => {\n      const { RequestItems } = commandInput(command, BatchGetItemCommand);\n      const keys = RequestItems.tbl.Keys as { sk: { S: string } }[];\n      return Promise.resolve({\n        Responses: {\n          tbl: keys\n            .filter(({ sk }) => sk.S.endsWith(\"0\"))\n            .map(({ sk }) => ({ sk, revalidatedAt: { N: \"7\" } })),\n        },\n      });\n    });\n    const tags = Array.from({ length: 150 }, (_, i) => `t${i}`);\n    const markers = await table.read([...tags, \"t0\"]);\n    expect(send).toHaveBeenCalledTimes(2);\n    expect(markers.size).toBe(15);\n    expect(markers.get(\"t10\")).toEqual({\n      revalidatedAt: 7,\n      staleAt: undefined,\n      expiredAt: undefined,\n    });\n  });\n\n  // A read-back after the write is eventually consistent, so it can return\n  // the marker from before it: the writer tracks what the write returned.\n  it(\"returns the row as the write left it\", async () => {\n    send.mockResolvedValueOnce({\n      Attributes: {\n        sk: { S: \"posts\" },\n        revalidatedAt: { N: \"5000\" },\n        staleAt: { N: \"10\" },\n      },\n    });\n    expect(await table.write(\"posts\", 5000, undefined)).toEqual({\n      revalidatedAt: 5000,\n      staleAt: 10,\n      expiredAt: undefined,\n    });\n    send.mockResolvedValueOnce({});\n    expect(await table.write(\"posts\", 6000, undefined)).toBeUndefined();\n  });\n\n  it(\"asks again for unprocessed keys, and gives up after three tries\", async () => {\n    const unprocessed = {\n      UnprocessedKeys: {\n        tbl: { Keys: [{ pk: { S: \"build\" }, sk: { S: \"a\" } }] },\n      },\n    };\n    send.mockResolvedValueOnce(unprocessed).mockResolvedValueOnce({\n      Responses: { tbl: [{ sk: { S: \"a\" }, staleAt: { N: \"3\" } }] },\n    });\n    expect((await table.read([\"a\"])).get(\"a\")?.staleAt).toBe(3);\n\n    send.mockResolvedValue(unprocessed);\n    await expect(table.read([\"a\"])).rejects.toThrow(/unread after retrying/);\n  });\n});\n\ndescribe(\"RevalidationLog\", () => {\n  const send = jest.fn();\n  let log: RevalidationLog;\n\n  beforeEach(() => {\n    send.mockReset();\n    (DynamoDBClient as jest.Mock).mockImplementation(() => ({ send }));\n    log = new RevalidationLog(new DynamoDBClient({}), \"tbl\", \"build\");\n  });\n\n  it(\"puts one row per revalidation under the build's log, with a TTL\", async () => {\n    send.mockResolvedValue({});\n    const at = 1_727_000_000_123;\n    await log.put(\"user#42\", at, { staleAt: 5, expiredAt: 6 });\n    expect(commandInput(send.mock.calls[0][0], PutItemCommand)).toEqual({\n      TableName: \"tbl\",\n      Item: {\n        pk: { S: \"build#log\" },\n        sk: { S: \"001727000000123#user#42\" },\n        ttl: { N: String(Math.ceil((at + REVALIDATION_LOG_TTL_MS) / 1000)) },\n        staleAt: { N: \"5\" },\n        expiredAt: { N: \"6\" },\n      },\n      ConditionExpression: \"attribute_not_exists(sk)\",\n    });\n  });\n\n  it(\"moves a row to the next millisecond rather than overwrite another revalidation\", async () => {\n    // `updateTag('x')` and `revalidateTag('x', 'max')` in one millisecond.\n    const taken = Object.assign(new Error(\"taken\"), {\n      name: \"ConditionalCheckFailedException\",\n    });\n    send.mockRejectedValueOnce(taken).mockResolvedValueOnce({});\n    await log.put(\"x\", 1000.5, { revalidatedAt: 5 });\n    expect(\n      send.mock.calls.map(\n        ([command]) => commandInput(command, PutItemCommand).Item.sk.S,\n      ),\n    ).toEqual([\"000000000001000#x\", \"000000000001001#x\"]);\n  });\n\n  it(\"gives up after a bounded number of collisions, and on other errors at once\", async () => {\n    const taken = Object.assign(new Error(\"taken\"), {\n      name: \"ConditionalCheckFailedException\",\n    });\n    send.mockRejectedValue(taken);\n    await expect(log.put(\"x\", 1000, {})).rejects.toBe(taken);\n    expect(send).toHaveBeenCalledTimes(5);\n\n    send.mockReset();\n    const throttled = new Error(\"throttled\");\n    send.mockRejectedValue(throttled);\n    await expect(log.put(\"x\", 1000, {})).rejects.toBe(throttled);\n    expect(send).toHaveBeenCalledTimes(1);\n  });\n\n  it(\"queries from a zero-padded cursor and parses the tag after it\", async () => {\n    send\n      .mockResolvedValueOnce({\n        Items: [\n          { sk: { S: \"000000000001000#a\" }, revalidatedAt: { N: \"7\" } },\n          { sk: { S: \"not a log row\" } },\n        ],\n        LastEvaluatedKey: { pk: { S: \"build#log\" }, sk: { S: \"x\" } },\n      })\n      .mockResolvedValueOnce({\n        Items: [{ sk: { S: \"000000000002000#user#42\" }, staleAt: { N: \"8\" } }],\n      });\n    const { rows, truncated } = await log.query(999.5);\n\n    const first = commandInput(send.mock.calls[0][0], QueryCommand);\n    expect(first).toMatchObject({\n      TableName: \"tbl\",\n      KeyConditionExpression: \"pk = :pk AND sk >= :since\",\n      ExpressionAttributeValues: {\n        \":pk\": { S: \"build#log\" },\n        \":since\": { S: \"000000000000999\" },\n      },\n    });\n    expect(\n      commandInput(send.mock.calls[1][0], QueryCommand).ExclusiveStartKey,\n    ).toEqual({ pk: { S: \"build#log\" }, sk: { S: \"x\" } });\n    expect(truncated).toBe(false);\n    expect(rows).toEqual([\n      {\n        sk: \"000000000001000#a\",\n        at: 1000,\n        tag: \"a\",\n        marker: { revalidatedAt: 7, staleAt: undefined, expiredAt: undefined },\n      },\n      {\n        sk: \"000000000002000#user#42\",\n        at: 2000,\n        tag: \"user#42\",\n        marker: { revalidatedAt: undefined, staleAt: 8, expiredAt: undefined },\n      },\n    ]);\n  });\n\n  it(\"stops after its page bound and says so\", async () => {\n    send.mockResolvedValue({\n      Items: [],\n      LastEvaluatedKey: { pk: { S: \"build#log\" }, sk: { S: \"x\" } },\n    });\n    expect((await log.query(0)).truncated).toBe(true);\n    expect(send).toHaveBeenCalledTimes(REVALIDATION_LOG_MAX_PAGES);\n  });\n});\n\ndescribe(\"CacheBucket\", () => {\n  const send = jest.fn();\n  let bucket: CacheBucket;\n\n  beforeEach(() => {\n    send.mockReset();\n    (S3Client as jest.Mock).mockImplementation(() => ({ send }));\n    bucket = new CacheBucket(new S3Client({}), \"bkt\");\n  });\n\n  it(\"reads an object as text\", async () => {\n    send.mockResolvedValue({\n      Body: { transformToString: jest.fn().mockResolvedValue(\"{}\") },\n      ContentType: \"application/json\",\n    });\n    expect(await bucket.get(\"k\")).toBe(\"{}\");\n    expect(commandInput(send.mock.calls[0][0], GetObjectCommand)).toEqual({\n      Bucket: \"bkt\",\n      Key: \"k\",\n    });\n  });\n\n  it(\"answers a missing object or body with undefined, and throws the rest\", async () => {\n    send.mockRejectedValueOnce(\n      new NoSuchKey({ message: \"missing\", $metadata: {} }),\n    );\n    expect(await bucket.get(\"k\")).toBeUndefined();\n    send.mockResolvedValueOnce({ Body: null });\n    expect(await bucket.get(\"k\")).toBeUndefined();\n    send.mockRejectedValueOnce(new Error(\"AccessDenied\"));\n    await expect(bucket.get(\"k\")).rejects.toThrow(\"AccessDenied\");\n  });\n\n  it(\"writes JSON\", async () => {\n    send.mockResolvedValue({});\n    await bucket.putJson(\"k\", \"{}\");\n    expect(commandInput(send.mock.calls[0][0], PutObjectCommand)).toEqual({\n      Bucket: \"bkt\",\n      Key: \"k\",\n      Body: \"{}\",\n      ContentType: \"application/json; charset=utf-8\",\n    });\n  });\n});\n\ndescribe(\"TrackedTagMarkers\", () => {\n  it(\"does not skip a row for an untracked tag that its first read missed\", async () => {\n    // The writer puts the log row and the marker at the same time, and the\n    // marker read is eventually consistent: `refresh` can see the row, then\n    // `ensure` read the marker from before it. Marked applied while the tag\n    // was untracked, the row was skipped by every query the lookback returned\n    // it to, and the instance served the stale entry until the rolling re-read.\n    let clock = 1_000_000;\n    const revalidatedAt = 999_000;\n    const row: RevalidationLogRow = {\n      sk: `${String(clock).padStart(15, \"0\")}#posts`,\n      at: clock,\n      tag: \"posts\",\n      marker: { revalidatedAt },\n    };\n    const query = jest.fn(async (since: number) => ({\n      rows: [row].filter((r) => r.at >= since),\n      truncated: false,\n    }));\n    // A replica that has not seen the write yet.\n    const read = jest.fn(async () => new Map<string, TagMarker>());\n    const markers = new TrackedTagMarkers({\n      markers: { read } as unknown as TagMarkerTable,\n      log: { query } as unknown as RevalidationLog,\n      refreshIntervalMs: 1000,\n      clock: () => clock,\n      random: () => 0,\n    });\n    // Something tracked, so the refresh queries the log.\n    await markers.ensure([\"other\"]);\n\n    clock += 1000;\n    await markers.refresh();\n    await markers.ensure([\"posts\"]);\n    expect(markers.get(\"posts\")).toEqual({});\n\n    clock += 1000;\n    await markers.refresh();\n    expect(query).toHaveBeenCalledTimes(2);\n    expect(markers.get(\"posts\")).toEqual({ revalidatedAt });\n    // Only the one read each tag's first use costs.\n    expect(read).toHaveBeenCalledTimes(2);\n  });\n});\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-cache-store.test.js","sourceRoot":"","sources":["../../src/adapter/aws-cache-store.test.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\njest.mock(\"@aws-sdk/client-s3\");\njest.mock(\"@aws-sdk/client-dynamodb\");\n\nimport {\n  BatchGetItemCommand,\n  DynamoDBClient,\n  PutItemCommand,\n  QueryCommand,\n  UpdateItemCommand,\n} from \"@aws-sdk/client-dynamodb\";\nimport {\n  GetObjectCommand,\n  NoSuchKey,\n  PutObjectCommand,\n  S3Client,\n} from \"@aws-sdk/client-s3\";\nimport {\n  buildS3Key,\n  CacheBucket,\n  hashedTag,\n  markerClock,\n  markerFor,\n  markerState,\n  markerUpdate,\n  mergeMarkers,\n  resolveAwsCacheConfig,\n  MAX_REVALIDATION_LOG_GAP_MS,\n  REVALIDATION_LOG_MAX_PAGES,\n  REVALIDATION_LOG_TTL_MS,\n  TAG_REFRESH_GRACE_MS,\n  RevalidationLog,\n  RevalidationLogRow,\n  TagMarker,\n  TagMarkerTable,\n  TrackedTagMarkers,\n  useCacheS3Key,\n} from \"./aws-cache-store\";\n\n/** The input an automocked SDK command was constructed with. */\nconst commandInput = (command: unknown, type: unknown) => {\n  const mock = type as jest.Mock;\n  return mock.mock.calls[mock.mock.instances.indexOf(command)][0];\n};\n\ndescribe(\"resolveAwsCacheConfig\", () => {\n  const env = process.env;\n  beforeEach(() => {\n    process.env = { ...env };\n  });\n  afterAll(() => {\n    process.env = env;\n  });\n\n  it(\"reads the environment the constructs set\", () => {\n    process.env.CDK_NEXTJS_CACHE_BUCKET_NAME = \"bucket\";\n    process.env.CDK_NEXTJS_REVALIDATION_TABLE_NAME = \"table\";\n    process.env.CDK_NEXTJS_BUILD_ID = \"build\";\n    process.env.AWS_REGION = \"eu-west-1\";\n    expect(resolveAwsCacheConfig()).toEqual({\n      bucketName: \"bucket\",\n      tableName: \"table\",\n      buildId: \"build\",\n      region: \"eu-west-1\",\n    });\n  });\n\n  it(\"reports what is unset as empty\", () => {\n    delete process.env.CDK_NEXTJS_CACHE_BUCKET_NAME;\n    delete process.env.CDK_NEXTJS_REVALIDATION_TABLE_NAME;\n    delete process.env.CDK_NEXTJS_BUILD_ID;\n    delete process.env.AWS_REGION;\n    expect(resolveAwsCacheConfig()).toEqual({\n      bucketName: \"\",\n      tableName: \"\",\n      buildId: \"\",\n      region: \"us-east-1\",\n    });\n  });\n});\n\ndescribe(\"S3 keys\", () => {\n  it(\"keeps the incremental cache's {buildId}/{key}.json convention\", () => {\n    expect(buildS3Key(\"b\", \"/\")).toBe(\"b/index.json\");\n    expect(buildS3Key(\"b\", \"\")).toBe(\"b/index.json\");\n    expect(buildS3Key(\"b\", \"/blog/post\")).toBe(\"b/blog/post.json\");\n    expect(buildS3Key(\"b\", \"abc123\")).toBe(\"b/abc123.json\");\n  });\n\n  it(\"puts 'use cache' entries where no incremental key can land\", () => {\n    const key = useCacheS3Key(\"b\", \"f\".repeat(64));\n    expect(key).toBe(`b/_use-cache/${\"f\".repeat(64)}.entry`);\n    // Even a route spelled like the use-cache key gets `.json` appended.\n    expect(buildS3Key(\"b\", `/_use-cache/${\"f\".repeat(64)}.entry`)).not.toBe(\n      key,\n    );\n    expect(key.endsWith(\".json\")).toBe(false);\n  });\n});\n\ndescribe(\"tag markers\", () => {\n  it(\"writes what markerFor applies locally\", () => {\n    for (const durations of [undefined, {}, { expire: 60 }]) {\n      const update = markerUpdate(1000, durations);\n      const local = markerFor(1000, durations);\n      const written: Record<string, number> = {};\n      for (const [name, value] of Object.entries(\n        update.ExpressionAttributeValues!,\n      )) {\n        written[name.slice(1)] = Number(value.N);\n      }\n      expect(written).toEqual(local);\n    }\n    expect(markerFor(1000, { expire: 60 })).toEqual({\n      staleAt: 1000,\n      expiredAt: 61000,\n    });\n  });\n\n  it(\"keeps an earlier expiredAt a profile with no expire leaves\", () => {\n    // The row keeps it (`SET staleAt` only), so an instance learning of the\n    // second revalidation from the log has to keep it too.\n    const first = markerFor(1000, { expire: 60 });\n    const second = markerFor(2000, {});\n    expect(mergeMarkers(first, second)).toEqual({\n      staleAt: 2000,\n      expiredAt: 61000,\n    });\n    expect(mergeMarkers(second, first)).toEqual({\n      staleAt: 2000,\n      expiredAt: 61000,\n    });\n    // A newer `expire` still replaces it.\n    expect(mergeMarkers(first, markerFor(2000, { expire: 1 }))).toEqual({\n      staleAt: 2000,\n      expiredAt: 3000,\n    });\n  });\n\n  it(\"judges an entry the way the incremental cache always has\", () => {\n    // Expired outright after creation.\n    expect(markerState({ revalidatedAt: 20 }, 10, 30)).toBe(\"expired\");\n    // Revalidated before the entry was created: no effect.\n    expect(markerState({ revalidatedAt: 5 }, 10, 30)).toBe(\"fresh\");\n    // A profile: stale now, expired once `expiredAt` passes.\n    expect(markerState({ staleAt: 20, expiredAt: 50 }, 10, 30)).toBe(\"stale\");\n    expect(markerState({ staleAt: 20, expiredAt: 50 }, 10, 60)).toBe(\"expired\");\n    // `expire: 0`: stale and expired at once.\n    expect(markerState({ staleAt: 20, expiredAt: 20 }, 10, 30)).toBe(\"expired\");\n    expect(markerState({}, 10, 30)).toBe(\"fresh\");\n  });\n});\n\ndescribe(\"TagMarkerTable\", () => {\n  const send = jest.fn();\n  let table: TagMarkerTable;\n\n  beforeEach(() => {\n    send.mockReset();\n    (DynamoDBClient as jest.Mock).mockImplementation(() => ({ send }));\n    table = new TagMarkerTable(new DynamoDBClient({}), \"tbl\", \"build\");\n  });\n\n  it(\"writes the marker row under the build\", async () => {\n    send.mockResolvedValue({});\n    await table.write(\"posts\", 1000, { expire: 1 });\n    const input = commandInput(send.mock.calls[0][0], UpdateItemCommand);\n    expect(input).toEqual({\n      TableName: \"tbl\",\n      Key: { pk: { S: \"build\" }, sk: { S: \"posts\" } },\n      UpdateExpression: \"SET staleAt = :staleAt, expiredAt = :expiredAt\",\n      ExpressionAttributeValues: {\n        \":staleAt\": { N: \"1000\" },\n        \":expiredAt\": { N: \"2000\" },\n      },\n      ReturnValues: \"ALL_NEW\",\n    });\n  });\n\n  it(\"reads markers in batches of 100 and parses them\", async () => {\n    send.mockImplementation((command: unknown) => {\n      const { RequestItems } = commandInput(command, BatchGetItemCommand);\n      const keys = RequestItems.tbl.Keys as { sk: { S: string } }[];\n      return Promise.resolve({\n        Responses: {\n          tbl: keys\n            .filter(({ sk }) => sk.S.endsWith(\"0\"))\n            .map(({ sk }) => ({ sk, revalidatedAt: { N: \"7\" } })),\n        },\n      });\n    });\n    const tags = Array.from({ length: 150 }, (_, i) => `t${i}`);\n    const markers = await table.read([...tags, \"t0\"]);\n    expect(send).toHaveBeenCalledTimes(2);\n    expect(markers.size).toBe(15);\n    expect(markers.get(\"t10\")).toEqual({\n      revalidatedAt: 7,\n      staleAt: undefined,\n      expiredAt: undefined,\n    });\n  });\n\n  it(\"keys a tag past the sort key limit by its hash, and reads it back as the tag\", async () => {\n    // `revalidatePath` on a long path: an implicit tag is as long as the path.\n    const tag = `_N_T_/${\"p\".repeat(1100)}`;\n    send.mockResolvedValue({});\n    await table.write(tag, 1000, undefined);\n    const written = commandInput(send.mock.calls[0][0], UpdateItemCommand);\n    expect(written.Key.sk.S).toBe(hashedTag(tag));\n    expect(hashedTag(tag)).toMatch(/^#[0-9a-f]{64}$/);\n\n    send.mockReset();\n    send.mockImplementation((command: unknown) => {\n      const { RequestItems } = commandInput(command, BatchGetItemCommand);\n      return Promise.resolve({\n        Responses: {\n          tbl: RequestItems.tbl.Keys.map(({ sk }: { sk: unknown }) => ({\n            sk,\n            revalidatedAt: { N: \"7\" },\n          })),\n        },\n      });\n    });\n    const markers = await table.read([tag, \"short\"]);\n    expect([...markers.keys()].sort()).toEqual([\"short\", tag].sort());\n  });\n\n  // A read-back after the write is eventually consistent, so it can return\n  // the marker from before it: the writer tracks what the write returned.\n  it(\"returns the row as the write left it\", async () => {\n    send.mockResolvedValueOnce({\n      Attributes: {\n        sk: { S: \"posts\" },\n        revalidatedAt: { N: \"5000\" },\n        staleAt: { N: \"10\" },\n      },\n    });\n    expect(await table.write(\"posts\", 5000, undefined)).toEqual({\n      revalidatedAt: 5000,\n      staleAt: 10,\n      expiredAt: undefined,\n    });\n    send.mockResolvedValueOnce({});\n    expect(await table.write(\"posts\", 6000, undefined)).toBeUndefined();\n  });\n\n  it(\"asks again for unprocessed keys, and gives up after three tries\", async () => {\n    const unprocessed = {\n      UnprocessedKeys: {\n        tbl: { Keys: [{ pk: { S: \"build\" }, sk: { S: \"a\" } }] },\n      },\n    };\n    send.mockResolvedValueOnce(unprocessed).mockResolvedValueOnce({\n      Responses: { tbl: [{ sk: { S: \"a\" }, staleAt: { N: \"3\" } }] },\n    });\n    expect((await table.read([\"a\"])).get(\"a\")?.staleAt).toBe(3);\n\n    send.mockResolvedValue(unprocessed);\n    await expect(table.read([\"a\"])).rejects.toThrow(/unread after retrying/);\n  });\n});\n\ndescribe(\"RevalidationLog\", () => {\n  const send = jest.fn();\n  let log: RevalidationLog;\n\n  beforeEach(() => {\n    send.mockReset();\n    (DynamoDBClient as jest.Mock).mockImplementation(() => ({ send }));\n    log = new RevalidationLog(new DynamoDBClient({}), \"tbl\", \"build\");\n  });\n\n  it(\"puts one row per revalidation under the build's log, with a TTL\", async () => {\n    send.mockResolvedValue({});\n    const at = 1_727_000_000_123;\n    await log.put(\"user#42\", at, { staleAt: 5, expiredAt: 6 });\n    expect(commandInput(send.mock.calls[0][0], PutItemCommand)).toEqual({\n      TableName: \"tbl\",\n      Item: {\n        pk: { S: \"build#log\" },\n        sk: { S: \"001727000000123#user#42\" },\n        ttl: { N: String(Math.ceil((at + REVALIDATION_LOG_TTL_MS) / 1000)) },\n        staleAt: { N: \"5\" },\n        expiredAt: { N: \"6\" },\n      },\n      ConditionExpression: \"attribute_not_exists(sk)\",\n    });\n  });\n\n  it(\"moves a row to the next millisecond rather than overwrite another revalidation\", async () => {\n    // `updateTag('x')` and `revalidateTag('x', 'max')` in one millisecond.\n    const taken = Object.assign(new Error(\"taken\"), {\n      name: \"ConditionalCheckFailedException\",\n    });\n    send.mockRejectedValueOnce(taken).mockResolvedValueOnce({});\n    await log.put(\"x\", 1000.5, { revalidatedAt: 5 });\n    expect(\n      send.mock.calls.map(\n        ([command]) => commandInput(command, PutItemCommand).Item.sk.S,\n      ),\n    ).toEqual([\"000000000001000#x\", \"000000000001001#x\"]);\n  });\n\n  it(\"gives up after a bounded number of collisions, and on other errors at once\", async () => {\n    const taken = Object.assign(new Error(\"taken\"), {\n      name: \"ConditionalCheckFailedException\",\n    });\n    send.mockRejectedValue(taken);\n    await expect(log.put(\"x\", 1000, {})).rejects.toBe(taken);\n    expect(send).toHaveBeenCalledTimes(5);\n\n    send.mockReset();\n    const throttled = new Error(\"throttled\");\n    send.mockRejectedValue(throttled);\n    await expect(log.put(\"x\", 1000, {})).rejects.toBe(throttled);\n    expect(send).toHaveBeenCalledTimes(1);\n  });\n\n  it(\"queries from a zero-padded cursor and parses the tag after it\", async () => {\n    send\n      .mockResolvedValueOnce({\n        Items: [\n          { sk: { S: \"000000000001000#a\" }, revalidatedAt: { N: \"7\" } },\n          { sk: { S: \"not a log row\" } },\n        ],\n        LastEvaluatedKey: { pk: { S: \"build#log\" }, sk: { S: \"x\" } },\n      })\n      .mockResolvedValueOnce({\n        Items: [{ sk: { S: \"000000000002000#user#42\" }, staleAt: { N: \"8\" } }],\n      });\n    const { rows, truncated } = await log.query(999.5);\n\n    const first = commandInput(send.mock.calls[0][0], QueryCommand);\n    expect(first).toMatchObject({\n      TableName: \"tbl\",\n      KeyConditionExpression: \"pk = :pk AND sk >= :since\",\n      ExpressionAttributeValues: {\n        \":pk\": { S: \"build#log\" },\n        \":since\": { S: \"000000000000999\" },\n      },\n    });\n    expect(\n      commandInput(send.mock.calls[1][0], QueryCommand).ExclusiveStartKey,\n    ).toEqual({ pk: { S: \"build#log\" }, sk: { S: \"x\" } });\n    expect(truncated).toBe(false);\n    expect(rows).toEqual([\n      {\n        sk: \"000000000001000#a\",\n        at: 1000,\n        tag: \"a\",\n        marker: { revalidatedAt: 7, staleAt: undefined, expiredAt: undefined },\n      },\n      {\n        sk: \"000000000002000#user#42\",\n        at: 2000,\n        tag: \"user#42\",\n        marker: { revalidatedAt: undefined, staleAt: 8, expiredAt: undefined },\n      },\n    ]);\n  });\n\n  it(\"hashes a tag too long for the sort key, carrying it in longTag\", async () => {\n    const tag = `_N_T_/${\"p\".repeat(1100)}`;\n    send.mockResolvedValue({});\n    await log.put(tag, 1000, { revalidatedAt: 5 });\n    const { Item } = commandInput(send.mock.calls[0][0], PutItemCommand);\n    expect(Item.sk.S).toBe(`000000000001000#${hashedTag(tag)}`);\n    expect(Item.longTag).toEqual({ S: tag });\n\n    send.mockReset();\n    send.mockResolvedValueOnce({ Items: [{ ...Item }] });\n    const { rows } = await log.query(0);\n    expect(rows.map((row) => row.tag)).toEqual([tag]);\n  });\n\n  it(\"stops after its page bound and says so\", async () => {\n    send.mockResolvedValue({\n      Items: [],\n      LastEvaluatedKey: { pk: { S: \"build#log\" }, sk: { S: \"x\" } },\n    });\n    expect((await log.query(0)).truncated).toBe(true);\n    expect(send).toHaveBeenCalledTimes(REVALIDATION_LOG_MAX_PAGES);\n  });\n});\n\ndescribe(\"CacheBucket\", () => {\n  const send = jest.fn();\n  let bucket: CacheBucket;\n\n  beforeEach(() => {\n    send.mockReset();\n    (S3Client as jest.Mock).mockImplementation(() => ({ send }));\n    bucket = new CacheBucket(new S3Client({}), \"bkt\");\n  });\n\n  it(\"reads an object as text\", async () => {\n    send.mockResolvedValue({\n      Body: { transformToString: jest.fn().mockResolvedValue(\"{}\") },\n      ContentType: \"application/json\",\n    });\n    expect(await bucket.get(\"k\")).toBe(\"{}\");\n    expect(commandInput(send.mock.calls[0][0], GetObjectCommand)).toEqual({\n      Bucket: \"bkt\",\n      Key: \"k\",\n    });\n  });\n\n  it(\"answers a missing object or body with undefined, and throws the rest\", async () => {\n    send.mockRejectedValueOnce(\n      new NoSuchKey({ message: \"missing\", $metadata: {} }),\n    );\n    expect(await bucket.get(\"k\")).toBeUndefined();\n    send.mockResolvedValueOnce({ Body: null });\n    expect(await bucket.get(\"k\")).toBeUndefined();\n    send.mockRejectedValueOnce(new Error(\"AccessDenied\"));\n    await expect(bucket.get(\"k\")).rejects.toThrow(\"AccessDenied\");\n  });\n\n  it(\"writes JSON\", async () => {\n    send.mockResolvedValue({});\n    await bucket.putJson(\"k\", \"{}\");\n    expect(commandInput(send.mock.calls[0][0], PutObjectCommand)).toEqual({\n      Bucket: \"bkt\",\n      Key: \"k\",\n      Body: \"{}\",\n      ContentType: \"application/json; charset=utf-8\",\n    });\n  });\n});\n\ndescribe(\"TrackedTagMarkers\", () => {\n  it(\"never counts a render the runtime caught up as behind\", async () => {\n    let clock = 1_000_000;\n    const markers = new TrackedTagMarkers({\n      markers: { read: jest.fn() } as unknown as TagMarkerTable,\n      log: { query: jest.fn() } as unknown as RevalidationLog,\n      refreshIntervalMs: 1000,\n      clock: () => clock,\n    });\n    // Just short of the line as the request came in: `catchUp` lets it go.\n    clock += 1000 + TAG_REFRESH_GRACE_MS;\n    expect(markers.behind).toBe(false);\n    await markers.catchUp(async () => {\n      // However long the render takes, its lookups never wait: waiting is\n      // what the catch-up before it was for.\n      clock += 100;\n      expect(markers.behind).toBe(true);\n      expect(markers.behindInRender).toBe(false);\n      clock += 60_000;\n      expect(markers.behindInRender).toBe(false);\n    });\n    // Outside it - a route handler alongside, in a container - it waits.\n    expect(markers.behindInRender).toBe(true);\n  });\n\n  it(\"gives a render no grace when catchUp, holding nothing, did not catch up\", async () => {\n    let clock = 1_000_000;\n    let held = false;\n    const markers = new TrackedTagMarkers({\n      markers: { read: jest.fn() } as unknown as TagMarkerTable,\n      log: {\n        query: jest.fn(async () => ({ rows: [], truncated: false })),\n      } as unknown as RevalidationLog,\n      refreshIntervalMs: 1000,\n      clock: () => clock,\n    });\n    markers.judgeEntriesOf(\n      () => (held ? 0 : Infinity),\n      () => held,\n    );\n    clock += 1000 + TAG_REFRESH_GRACE_MS + 100;\n    await markers.catchUp(async () => {\n      // Another request stores an entry before this render's first lookup.\n      held = true;\n      expect(markers.behindInRender).toBe(true);\n    });\n  });\n\n  it(\"starts a refresh for a page that is not behind, without waiting for it\", async () => {\n    let clock = 1_000_000;\n    let release!: () => void;\n    const query = jest.fn(\n      () =>\n        new Promise<{ rows: RevalidationLogRow[]; truncated: boolean }>(\n          (resolve) =>\n            (release = () => resolve({ rows: [], truncated: false })),\n        ),\n    );\n    const markers = new TrackedTagMarkers({\n      markers: { read: jest.fn() } as unknown as TagMarkerTable,\n      log: { query } as unknown as RevalidationLog,\n      refreshIntervalMs: 1000,\n      clock: () => clock,\n    });\n    markers.judgeEntriesOf(() => 0);\n    clock += 1000;\n    expect(markers.behind).toBe(false);\n    // A page that reads no cache still keeps the instance current.\n    await expect(markers.catchUp(async () => \"page\")).resolves.toBe(\"page\");\n    expect(query).toHaveBeenCalledTimes(1);\n    release();\n  });\n\n  it(\"catches up on the log without waiting for the rolling re-read\", async () => {\n    let clock = 1_000_000;\n    let release!: () => void;\n    const read = jest.fn(async (tags: string[]) => {\n      if (read.mock.calls.length > 1) {\n        await new Promise<void>((resolve) => (release = resolve));\n      }\n      return new Map<string, TagMarker>(tags.map((tag) => [tag, {}]));\n    });\n    const markers = new TrackedTagMarkers({\n      markers: { read } as unknown as TagMarkerTable,\n      log: {\n        query: jest.fn(async () => ({ rows: [], truncated: false })),\n      } as unknown as RevalidationLog,\n      refreshIntervalMs: 1000,\n      resyncIntervalMs: 1000,\n      random: () => 0,\n      clock: () => clock,\n    });\n    markers.judgeEntriesOf(() => 0);\n    await markers.ensure([\"posts\"]);\n    // Due for its re-read, and behind, as after a quiet spell.\n    clock += 5000;\n    expect(markers.behind).toBe(true);\n    let rendered = false;\n    await markers.catchUp(async () => (rendered = true));\n    // A throttled `BatchGetItem` would otherwise hold the page.\n    expect(rendered).toBe(true);\n    expect(read).toHaveBeenCalledTimes(2);\n\n    // Nor does a lookup of the tracked tag wait on it.\n    let ensured = false;\n    void markers.ensure([\"posts\"]).then(() => (ensured = true));\n    await new Promise((resolve) => setImmediate(resolve));\n    expect(ensured).toBe(true);\n\n    // Still in flight an interval later: not read a second time meanwhile.\n    clock += 1000;\n    await markers.refresh();\n    expect(read).toHaveBeenCalledTimes(2);\n    release();\n  });\n\n  it(\"gives a route handler, which no catch-up precedes, no grace more\", async () => {\n    let clock = 1_000_000;\n    const markers = new TrackedTagMarkers({\n      markers: { read: jest.fn() } as unknown as TagMarkerTable,\n      log: { query: jest.fn() } as unknown as RevalidationLog,\n      refreshIntervalMs: 1000,\n      clock: () => clock,\n    });\n    clock += 1000 + TAG_REFRESH_GRACE_MS + 100;\n    expect(markers.behindInRender).toBe(true);\n  });\n\n  it(\"reads again only once, however many forgets land meanwhile\", async () => {\n    let clock = 1_000_000;\n    const releases: (() => void)[] = [];\n    const read = jest.fn(async () => {\n      await new Promise<void>((resolve) => releases.push(resolve));\n      return new Map<string, TagMarker>([[\"posts\", { revalidatedAt: 1 }]]);\n    });\n    const markers = new TrackedTagMarkers({\n      markers: { read } as unknown as TagMarkerTable,\n      log: {\n        query: jest.fn(async () => ({ rows: [], truncated: false })),\n      } as unknown as RevalidationLog,\n      refreshIntervalMs: 0,\n      clock: () => clock,\n    });\n    markers.judgeEntriesOf(() => 0);\n    const forget = async () => {\n      clock += MAX_REVALIDATION_LOG_GAP_MS + 1;\n      await markers.refresh();\n    };\n    const ensuring = markers.ensure([\"posts\"]);\n    await forget();\n    releases.shift()!();\n    await new Promise((resolve) => setImmediate(resolve));\n    await forget();\n    releases.shift()!();\n    await ensuring;\n    // A truncated log forgets on every query: waiting for a read no forget\n    // overtook would keep the requests waiting on this one for as long.\n    expect(read).toHaveBeenCalledTimes(2);\n    expect(markers.get(\"posts\")).toEqual({ revalidatedAt: 1 });\n  });\n\n  it(\"reads again what a read from before a forget found\", async () => {\n    let clock = 1_000_000;\n    let release!: () => void;\n    const held = new Promise<void>((resolve) => (release = resolve));\n    let revalidatedAt: number | undefined;\n    const read = jest.fn(async () => {\n      await held;\n      return new Map<string, TagMarker>(\n        revalidatedAt === undefined ? [] : [[\"posts\", { revalidatedAt }]],\n      );\n    });\n    const markers = new TrackedTagMarkers({\n      markers: { read } as unknown as TagMarkerTable,\n      log: {\n        query: jest.fn(async () => ({ rows: [], truncated: false })),\n      } as unknown as RevalidationLog,\n      refreshIntervalMs: 0,\n      clock: () => clock,\n    });\n    markers.judgeEntriesOf(() => 0);\n    // A background read in flight as the sandbox froze, past the log's TTL.\n    const ensuring = markers.ensure([\"posts\"]);\n    clock += MAX_REVALIDATION_LOG_GAP_MS + 1;\n    await markers.refresh();\n\n    // Read again once the stale read returns: tracked, its marker would\n    // vouch for every entry with the tag, revalidated during the freeze or\n    // not; untracked, the request waiting on it would judge by nothing.\n    revalidatedAt = markerClock();\n    release();\n    await ensuring;\n    expect(read).toHaveBeenCalledTimes(2);\n    expect(markers.get(\"posts\")).toEqual({ revalidatedAt });\n  });\n\n  it(\"moves completeSince past what it forgets\", async () => {\n    let clock = 1_000_000;\n    const later = markerClock() + 60_000;\n    const rows: RevalidationLogRow[] = [\"a\", \"b\"].map((tag, i) => ({\n      sk: `${String(clock).padStart(15, \"0\")}#${tag}`,\n      at: clock,\n      tag,\n      marker: { revalidatedAt: later + i },\n    }));\n    const query = jest.fn(async () => ({ rows, truncated: false }));\n    const markers = new TrackedTagMarkers({\n      markers: { read: jest.fn() } as unknown as TagMarkerTable,\n      log: { query } as unknown as RevalidationLog,\n      refreshIntervalMs: 0,\n      maxTrackedTags: 1,\n      clock: () => clock,\n    });\n    // An entry store holding something older than every row.\n    markers.judgeEntriesOf(() => 0);\n    const start = markers.completeSince;\n    expect(start).toBeLessThanOrEqual(markerClock());\n\n    // Untracked tags' rows are known from the log alone, as far as they fit.\n    await markers.refresh();\n    expect(markers.state([\"b\"], later)).toBe(\"expired\");\n    // \"a\" was dropped for space, and with it what it knew.\n    expect(markers.state([\"a\"], later)).toBe(\"fresh\");\n    expect(markers.completeSince).toBe(later);\n\n    // Forgetting everything moves it to now, or past what it forgot: \"b\".\n    clock += MAX_REVALIDATION_LOG_GAP_MS + 1;\n    await markers.refresh();\n    expect(markers.completeSince).toBe(later + 1);\n  });\n\n  it(\"moves completeSince past a row it lets go of with no entry held\", async () => {\n    const clock = 1_000_000;\n    const revalidatedAt = markerClock() + 60_000;\n    const markers = new TrackedTagMarkers({\n      markers: { read: jest.fn() } as unknown as TagMarkerTable,\n      log: {\n        query: jest.fn(async () => ({\n          rows: [\n            {\n              sk: `${String(clock).padStart(15, \"0\")}#posts`,\n              at: clock,\n              tag: \"posts\",\n              marker: { revalidatedAt },\n            },\n          ],\n          truncated: false,\n        })),\n      } as unknown as RevalidationLog,\n      refreshIntervalMs: 0,\n      clock: () => clock,\n    });\n    markers.judgeEntriesOf(() => Infinity);\n    await markers.refresh();\n    // An entry whose generation started before the revalidation, stored once\n    // the row is gone, is older than `completeSince`, and so read first.\n    expect(markers.state([\"posts\"], revalidatedAt - 1)).toBe(\"fresh\");\n    expect(markers.completeSince).toBe(revalidatedAt);\n  });\n\n  it(\"prunes a profile's row, and moves completeSince to its expiredAt once past\", async () => {\n    const clock = 1_000_000;\n    const staleAt = markerClock() + 1000;\n    const expiredAt = staleAt + 60_000;\n    const markers = new TrackedTagMarkers({\n      markers: { read: jest.fn() } as unknown as TagMarkerTable,\n      log: {\n        query: jest.fn(async () => ({\n          rows: [\n            {\n              sk: `${String(clock).padStart(15, \"0\")}#posts`,\n              at: clock,\n              tag: \"posts\",\n              marker: { staleAt, expiredAt },\n            },\n          ],\n          truncated: false,\n        })),\n      } as unknown as RevalidationLog,\n      refreshIntervalMs: 0,\n      clock: () => clock,\n    });\n    markers.judgeEntriesOf(() => staleAt + 1);\n    await markers.refresh();\n    expect(markers.state([\"posts\"], staleAt - 1)).toBe(\"fresh\");\n    expect(markers.completeSince).toBe(staleAt);\n\n    const now = jest\n      .spyOn(performance, \"now\")\n      .mockReturnValue(expiredAt - performance.timeOrigin);\n    try {\n      expect(markers.completeSince).toBe(expiredAt);\n    } finally {\n      now.mockRestore();\n    }\n  });\n\n  it(\"queues a pruned row's future expiredAt once, however often the lookback returns it\", async () => {\n    let clock = 1_000_000;\n    const staleAt = markerClock() + 1000;\n    const markers = new TrackedTagMarkers({\n      markers: { read: jest.fn() } as unknown as TagMarkerTable,\n      log: {\n        query: jest.fn(async () => ({\n          rows: [\n            {\n              sk: `${String(1_000_000).padStart(15, \"0\")}#posts`,\n              at: 1_000_000,\n              tag: \"posts\",\n              marker: { staleAt, expiredAt: staleAt + 60_000 },\n            },\n          ],\n          truncated: false,\n        })),\n      } as unknown as RevalidationLog,\n      refreshIntervalMs: 0,\n      clock: () => clock,\n    });\n    markers.judgeEntriesOf(() => staleAt + 1);\n    for (let i = 0; i < 3; i++) {\n      await markers.refresh();\n      clock += 1000;\n    }\n    // Pruned rows are not marked applied, so each query applies it again.\n    expect(\n      (markers as unknown as { laterFloors: unknown[] }).laterFloors,\n    ).toHaveLength(1);\n  });\n\n  it(\"merges future expiredAts past its bound without moving completeSince early\", async () => {\n    const at = markerClock();\n    const expiries = new Map([\n      [\"a\", at + 60_000],\n      [\"b\", at + 60_010],\n      [\"c\", at + 120_000],\n    ]);\n    const markers = new TrackedTagMarkers({\n      markers: {\n        read: jest.fn(\n          async (tags: string[]) =>\n            new Map<string, TagMarker>(\n              tags.map((tag) => [\n                tag,\n                { staleAt: at - 1000, expiredAt: expiries.get(tag) },\n              ]),\n            ),\n        ),\n      } as unknown as TagMarkerTable,\n      log: { query: jest.fn() } as unknown as RevalidationLog,\n      maxTrackedTags: 1,\n    });\n    const start = markers.completeSince;\n    // \"a\", then \"b\", dropped for space: two expiredAts past a bound of one.\n    for (const tag of [\"a\", \"b\", \"c\"]) {\n      await markers.ensure([tag]);\n    }\n    expect(markers.completeSince).toBe(start);\n\n    const now = jest.spyOn(performance, \"now\");\n    try {\n      now.mockReturnValue(at + 59_999 - performance.timeOrigin);\n      expect(markers.completeSince).toBe(start);\n      // Merged: \"b\"'s from \"a\"'s, 10 ms early.\n      now.mockReturnValue(at + 60_000 - performance.timeOrigin);\n      expect(markers.completeSince).toBe(at + 60_010);\n    } finally {\n      now.mockRestore();\n    }\n  });\n\n  it(\"does not join a near expiredAt to far ones past its bound\", async () => {\n    const at = markerClock();\n    const year = 365 * 24 * 60 * 60 * 1000;\n    const expiries = new Map([\n      [\"a\", at + year],\n      [\"b\", at + year + 10],\n      [\"c\", at + 60_000],\n    ]);\n    const markers = new TrackedTagMarkers({\n      markers: {\n        read: jest.fn(\n          async (tags: string[]) =>\n            new Map<string, TagMarker>(\n              tags.map((tag) => [\n                tag,\n                { staleAt: at - 1000, expiredAt: expiries.get(tag) },\n              ]),\n            ),\n        ),\n      } as unknown as TagMarkerTable,\n      log: { query: jest.fn() } as unknown as RevalidationLog,\n      maxTrackedTags: 2,\n    });\n    for (const tag of [\"a\", \"b\", \"c\", \"d\", \"e\"]) {\n      await markers.ensure([tag]);\n    }\n    const now = jest\n      .spyOn(performance, \"now\")\n      .mockReturnValue(at + 60_000 - performance.timeOrigin);\n    try {\n      // \"a\" and \"b\" are merged, not \"c\" into \"a\": `completeSince` a year\n      // early would have every held entry read its markers first until then.\n      expect(markers.completeSince).toBe(at + 60_000);\n    } finally {\n      now.mockRestore();\n    }\n  });\n\n  it(\"merges the closest future expiredAts past its bound\", async () => {\n    const at = markerClock();\n    const expiries = new Map([\n      [\"a\", at + 60_000],\n      [\"b\", at + 120_000],\n      [\"c\", at + 60_010],\n    ]);\n    const markers = new TrackedTagMarkers({\n      markers: {\n        read: jest.fn(\n          async (tags: string[]) =>\n            new Map<string, TagMarker>(\n              tags.map((tag) => [\n                tag,\n                { staleAt: at - 1000, expiredAt: expiries.get(tag) },\n              ]),\n            ),\n        ),\n      } as unknown as TagMarkerTable,\n      log: { query: jest.fn() } as unknown as RevalidationLog,\n      maxTrackedTags: 2,\n    });\n    // \"a\", \"b\", then \"c\" dropped for space: three expiredAts past a bound of\n    // two, and \"c\" is 10 ms from \"a\".\n    for (const tag of [\"a\", \"b\", \"c\", \"d\", \"e\"]) {\n      await markers.ensure([tag]);\n    }\n    const start = markers.completeSince;\n\n    const now = jest.spyOn(performance, \"now\");\n    try {\n      now.mockReturnValue(at + 59_999 - performance.timeOrigin);\n      expect(markers.completeSince).toBe(start);\n      now.mockReturnValue(at + 60_000 - performance.timeOrigin);\n      expect(markers.completeSince).toBe(at + 60_010);\n      now.mockReturnValue(at + 119_999 - performance.timeOrigin);\n      expect(markers.completeSince).toBe(at + 60_010);\n      now.mockReturnValue(at + 120_000 - performance.timeOrigin);\n      expect(markers.completeSince).toBe(at + 120_000);\n    } finally {\n      now.mockRestore();\n    }\n  });\n\n  it(\"catches up only for an entry store holding entries, and not when every check asks anyway\", async () => {\n    let clock = 1_000_000;\n    const instance = (refreshIntervalMs: number) => {\n      const query = jest.fn(async () => ({ rows: [], truncated: false }));\n      const markers = new TrackedTagMarkers({\n        markers: { read: jest.fn() } as unknown as TagMarkerTable,\n        log: { query } as unknown as RevalidationLog,\n        refreshIntervalMs,\n        clock: () => clock,\n      });\n      return { markers, query };\n    };\n    const noStore = instance(1000);\n    const everyCheck = instance(0);\n    everyCheck.markers.judgeEntriesOf(() => Infinity);\n    // A store, but holding nothing a refresh could expire.\n    const emptyStore = instance(1000);\n    emptyStore.markers.judgeEntriesOf(() => Infinity);\n    const store = instance(1000);\n    store.markers.judgeEntriesOf(() => 0);\n    clock += 60_000;\n    for (const { markers } of [noStore, everyCheck, emptyStore, store]) {\n      expect(markers.behind).toBe(true);\n      await markers.catchUp(async () => {});\n    }\n    expect(noStore.query).not.toHaveBeenCalled();\n    expect(everyCheck.query).not.toHaveBeenCalled();\n    expect(emptyStore.query).not.toHaveBeenCalled();\n    expect(store.query).toHaveBeenCalledTimes(1);\n  });\n\n  it(\"moves completeSince to a dropped marker's future expiredAt only once it is past\", async () => {\n    const at = markerClock();\n    const read = jest.fn(\n      async (tags: string[]) =>\n        new Map<string, TagMarker>(\n          tags.map((tag) => [\n            tag,\n            { staleAt: at - 1000, expiredAt: at + 60_000 },\n          ]),\n        ),\n    );\n    const markers = new TrackedTagMarkers({\n      markers: { read } as unknown as TagMarkerTable,\n      log: { query: jest.fn() } as unknown as RevalidationLog,\n      maxTrackedTags: 1,\n    });\n    const start = markers.completeSince;\n    await markers.ensure([\"a\"]);\n    // \"a\" is dropped for space: a year-long `expire` would otherwise keep\n    // every entry reading its markers first for as long.\n    await markers.ensure([\"b\"]);\n    expect(markers.completeSince).toBe(start);\n\n    const clock = jest\n      .spyOn(performance, \"now\")\n      .mockReturnValue(at + 60_001 - performance.timeOrigin);\n    try {\n      expect(markers.completeSince).toBe(at + 60_000);\n    } finally {\n      clock.mockRestore();\n    }\n  });\n\n  it(\"keeps only the log rows that could apply to an entry held\", async () => {\n    let clock = 1_000_000;\n    const later = markerClock() + 60_000;\n    const rows: RevalidationLogRow[] = [\"old\", \"new\"].map((tag, i) => ({\n      sk: `${String(clock).padStart(15, \"0\")}#${tag}`,\n      at: clock,\n      tag,\n      marker: { revalidatedAt: i === 0 ? 1 : later },\n    }));\n    const markers = new TrackedTagMarkers({\n      markers: { read: jest.fn() } as unknown as TagMarkerTable,\n      log: {\n        query: jest.fn(async () => ({ rows, truncated: false })),\n      } as unknown as RevalidationLog,\n      refreshIntervalMs: 0,\n      maxTrackedTags: 1,\n      clock: () => clock,\n    });\n    let oldest = 2;\n    markers.judgeEntriesOf(() => oldest);\n    const start = markers.completeSince;\n\n    // \"old\" can expire nothing held, so it takes no room, and \"new\" is\n    // kept without dropping anything for space.\n    await markers.refresh();\n    expect(markers.state([\"new\"], later - 1)).toBe(\"expired\");\n    expect(markers.completeSince).toBe(start);\n\n    // Once every entry held is newer than it, \"new\" goes too, taking\n    // `completeSince` no further than the oldest entry held.\n    oldest = later;\n    clock += 1000;\n    await markers.refresh();\n    expect(markers.state([\"new\"], later - 1)).toBe(\"fresh\");\n    expect(markers.completeSince).toBe(later);\n  });\n\n  it(\"scans the entry stores once a minute, pruning only when the oldest moves\", async () => {\n    let clock = 1_000_000;\n    const later = markerClock() + 60_000;\n    const rows: RevalidationLogRow[] = [\n      {\n        sk: `${String(clock).padStart(15, \"0\")}#new`,\n        at: clock,\n        tag: \"new\",\n        marker: { revalidatedAt: later },\n      },\n    ];\n    const markers = new TrackedTagMarkers({\n      markers: { read: jest.fn() } as unknown as TagMarkerTable,\n      // The row leaves the lookback after the first query: only the prune\n      // can let it go.\n      log: {\n        query: jest\n          .fn()\n          .mockResolvedValueOnce({ rows, truncated: false })\n          .mockResolvedValue({ rows: [], truncated: false }),\n      } as unknown as RevalidationLog,\n      refreshIntervalMs: 0,\n      clock: () => clock,\n    });\n    let bound = 2;\n    let exact = 2;\n    const oldest = jest.fn((scan: boolean) => (scan ? exact : bound));\n    markers.judgeEntriesOf(oldest);\n    const prune = jest.spyOn(\n      markers as unknown as { pruneLogged: (oldest: number) => void },\n      \"pruneLogged\",\n    );\n\n    await markers.refresh();\n    expect(oldest).toHaveBeenLastCalledWith(true);\n    expect(prune).toHaveBeenCalledTimes(1);\n\n    // Within the minute: the bound, and no prune while it stays put.\n    clock += 1000;\n    exact = later;\n    await markers.refresh();\n    expect(oldest).toHaveBeenLastCalledWith(false);\n    expect(prune).toHaveBeenCalledTimes(1);\n    expect(markers.state([\"new\"], later - 1)).toBe(\"expired\");\n\n    // The minute's scan finds every entry newer than the row: it goes.\n    clock += 60_000;\n    await markers.refresh();\n    expect(oldest).toHaveBeenLastCalledWith(true);\n    expect(prune).toHaveBeenCalledTimes(2);\n    expect(markers.state([\"new\"], later - 1)).toBe(\"fresh\");\n    expect(markers.completeSince).toBe(later);\n\n    // An entry set since moves the bound back: nothing to prune.\n    clock += 1000;\n    bound = 1;\n    await markers.refresh();\n    expect(prune).toHaveBeenCalledTimes(2);\n  });\n\n  it(\"waits for a fresh query rather than one started before a freeze\", async () => {\n    let clock = 1_000_000;\n    const queries: (() => void)[] = [];\n    const query = jest.fn(\n      () =>\n        new Promise<{ rows: RevalidationLogRow[]; truncated: boolean }>(\n          (resolve) =>\n            queries.push(() => resolve({ rows: [], truncated: false })),\n        ),\n    );\n    const markers = new TrackedTagMarkers({\n      markers: { read: jest.fn() } as unknown as TagMarkerTable,\n      log: { query } as unknown as RevalidationLog,\n      refreshIntervalMs: 1000,\n      clock: () => clock,\n      canFreeze: true,\n    });\n    markers.judgeEntriesOf(() => 0);\n    clock += 1000;\n    // Started, not waited for, and then the sandbox froze.\n    void markers.refresh();\n    clock += 60_000;\n    expect(markers.behind).toBe(true);\n\n    let caughtUp = false;\n    const catchUp = markers\n      .catchUp(async () => {})\n      .then(() => (caughtUp = true));\n    queries.shift()!();\n    await new Promise((resolve) => setImmediate(resolve));\n    expect(caughtUp).toBe(false);\n    expect(query).toHaveBeenCalledTimes(2);\n    queries.shift()!();\n    await catchUp;\n    expect(markers.behind).toBe(false);\n  });\n\n  describe(\"with a refresh in flight\", () => {\n    let clock: number;\n    beforeEach(() => {\n      clock = 1_000_000;\n      jest.useFakeTimers({ doNotFake: [\"setImmediate\", \"nextTick\"] });\n    });\n    afterEach(() => jest.useRealTimers());\n\n    /** Move the clock and the timers on together: no freeze. */\n    const run = (ms: number) => {\n      for (let step = 0; step < ms; step += 250) {\n        clock += 250;\n        jest.advanceTimersByTime(250);\n      }\n    };\n    const instance = (fails = false, canFreeze = true) => {\n      const queries: (() => void)[] = [];\n      const query = jest.fn(\n        () =>\n          new Promise<{ rows: RevalidationLogRow[]; truncated: boolean }>(\n            (resolve, reject) =>\n              queries.push(() =>\n                fails\n                  ? reject(new Error(\"throttled\"))\n                  : resolve({ rows: [], truncated: false }),\n              ),\n          ),\n      );\n      const markers = new TrackedTagMarkers({\n        markers: { read: jest.fn() } as unknown as TagMarkerTable,\n        log: { query } as unknown as RevalidationLog,\n        refreshIntervalMs: 1000,\n        clock: () => clock,\n        canFreeze,\n      });\n      markers.judgeEntriesOf(() => 0);\n      return { markers, query, queries };\n    };\n\n    it(\"waits for a fresh query after a freeze, even once the late tick has run\", async () => {\n      const { markers, query, queries } = instance();\n      clock += 1000;\n      void markers.refresh();\n      clock += 60_000;\n      // After the thaw the overdue tick can run before any request does.\n      jest.advanceTimersByTime(250);\n\n      let caughtUp = false;\n      const catchUp = markers\n        .catchUp(async () => {})\n        .then(() => (caughtUp = true));\n      queries.shift()!();\n      await new Promise((resolve) => setImmediate(resolve));\n      // What the first query knew predates the freeze.\n      expect(markers.behind).toBe(true);\n      expect(caughtUp).toBe(false);\n      expect(query).toHaveBeenCalledTimes(2);\n      queries.shift()!();\n      await catchUp;\n      expect(markers.behind).toBe(false);\n    });\n\n    it(\"in a container, which is never frozen, waits only for the query in flight\", async () => {\n      const { markers, query, queries } = instance(false, false);\n      clock += 1000;\n      void markers.refresh();\n      // A long stall, not a freeze: no timer to tell them apart, none needed.\n      clock += 60_000;\n\n      const catchUp = markers.catchUp(async () => {});\n      queries.shift()!();\n      await catchUp;\n      expect(query).toHaveBeenCalledTimes(1);\n      expect(markers.behind).toBe(false);\n    });\n\n    it(\"is caught up once the catch-up's slow query returns, the process running throughout\", async () => {\n      for (const fails of [false, true]) {\n        const { markers, queries } = instance(fails);\n        clock += 60_000;\n        expect(markers.behind).toBe(true);\n        const catchUp = markers.catchUp(async () => {});\n        run(3000);\n        queries.shift()!();\n        await catchUp;\n        // Or the first `'use cache'` lookup would wait for another query,\n        // inside the render: one request, two waits.\n        expect(markers.behind).toBe(false);\n      }\n    });\n\n    it(\"waits only for a slow query in flight, the process running throughout\", async () => {\n      const { markers, query, queries } = instance();\n      clock += 60_000;\n      const first = markers.catchUp(async () => {});\n      run(2500);\n      // Past the grace into the query, but the query is as fresh as any.\n      let caughtUp = false;\n      const second = markers\n        .catchUp(async () => {})\n        .then(() => (caughtUp = true));\n      queries.shift()!();\n      await first;\n      await new Promise((resolve) => setImmediate(resolve));\n      expect(caughtUp).toBe(true);\n      await second;\n      expect(query).toHaveBeenCalledTimes(1);\n    });\n  });\n\n  it(\"does not skip a row for an untracked tag that its first read missed\", async () => {\n    // The writer puts the log row and the marker at the same time, and the\n    // marker read is eventually consistent: `refresh` can see the row, then\n    // `ensure` read the marker from before it. Marked applied while the tag\n    // was untracked, the row was skipped by every query the lookback returned\n    // it to, and the instance served the stale entry until the rolling re-read.\n    let clock = 1_000_000;\n    const revalidatedAt = 999_000;\n    const row: RevalidationLogRow = {\n      sk: `${String(clock).padStart(15, \"0\")}#posts`,\n      at: clock,\n      tag: \"posts\",\n      marker: { revalidatedAt },\n    };\n    const query = jest.fn(async (since: number) => ({\n      rows: [row].filter((r) => r.at >= since),\n      truncated: false,\n    }));\n    // A replica that has not seen the write yet.\n    const read = jest.fn(async () => new Map<string, TagMarker>());\n    const markers = new TrackedTagMarkers({\n      markers: { read } as unknown as TagMarkerTable,\n      log: { query } as unknown as RevalidationLog,\n      refreshIntervalMs: 1000,\n      clock: () => clock,\n      random: () => 0,\n    });\n    markers.judgeEntriesOf(() => 0);\n    await markers.ensure([\"other\"]);\n\n    clock += 1000;\n    await markers.refresh();\n    // The row seen before the read is applied to what the read found.\n    await markers.ensure([\"posts\"]);\n    expect(markers.get(\"posts\")).toEqual({ revalidatedAt });\n\n    clock += 1000;\n    await markers.refresh();\n    expect(query).toHaveBeenCalledTimes(2);\n    expect(markers.get(\"posts\")).toEqual({ revalidatedAt });\n    // Only the one read each tag's first use costs.\n    expect(read).toHaveBeenCalledTimes(2);\n  });\n});\n"]}