cdk-nextjs 0.6.2 → 0.7.1

package/lib/adapter/use-cache-common.test.js

@@ -0,0 +1,646 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable import/no-extraneous-dependencies */
+jest.mock("@aws-sdk/client-dynamodb");
+const aws_cache_store_1 = require("./aws-cache-store");
+const use_cache_common_1 = require("./use-cache-common");
+/** A `TagMarkerTable` over a plain map, counting its calls. */
+function fakeMarkers(rows = new Map()) {
+    const read = jest.fn(async (tags) => {
+        const found = new Map();
+        for (const tag of tags) {
+            const row = rows.get(tag);
+            if (row)
+                found.set(tag, { ...row });
+        }
+        return found;
+    });
+    const write = jest.fn(async (tag, at, durations) => {
+        const row = rows.get(tag) ?? {};
+        if (!durations) {
+            row.revalidatedAt = at;
+        }
+        else {
+            row.staleAt = at;
+            if (durations.expire !== undefined) {
+                row.expiredAt = at + durations.expire * 1000;
+            }
+        }
+        rows.set(tag, row);
+        // `ReturnValues: "ALL_NEW"`, as the real table answers.
+        return { ...row };
+    });
+    return {
+        rows,
+        read,
+        write,
+        table: { read, write },
+    };
+}
+/**
+ * A `RevalidationLog` over a plain array, counting its calls. Its query returns
+ * what the real one would: every row at or after `since`, oldest first.
+ */
+function fakeLog(rows = []) {
+    const put = jest.fn(async (tag, at, marker) => {
+        rows.push({
+            sk: `${String(at).padStart(15, "0")}#${tag}`,
+            at,
+            tag,
+            marker,
+        });
+    });
+    const query = jest.fn(async (since) => ({
+        rows: rows.filter((row) => row.at >= since).sort((a, b) => a.at - b.at),
+        truncated: false,
+    }));
+    return {
+        rows,
+        put,
+        query,
+        log: { put, query },
+    };
+}
+/** A wall clock a test moves by hand. */
+function fakeClock(start = 1_000_000) {
+    const clock = { at: start, now: () => clock.at };
+    return clock;
+}
+function streamOf(...chunks) {
+    return new ReadableStream({
+        start(controller) {
+            for (const chunk of chunks) {
+                controller.enqueue(new TextEncoder().encode(chunk));
+            }
+            controller.close();
+        },
+    });
+}
+function stored(bytes, extra = {}) {
+    return {
+        value: new Uint8Array(bytes),
+        tags: [],
+        stale: 300,
+        timestamp: Date.now(),
+        expire: 3600,
+        revalidate: 900,
+        ...extra,
+    };
+}
+describe("TrackedTagMarkers", () => {
+    it("reads a tag the first time it is needed, and not again", async () => {
+        const markers = fakeMarkers(new Map([["a", { revalidatedAt: 50 }]]));
+        const tags = new aws_cache_store_1.TrackedTagMarkers({
+            markers: markers.table,
+            log: fakeLog().log,
+        });
+        await Promise.all([tags.ensure(["a", "b"]), tags.ensure(["a", "b"])]);
+        await tags.ensure(["a", "b"]);
+        expect(markers.read).toHaveBeenCalledTimes(1);
+        expect(markers.read).toHaveBeenCalledWith(["a", "b"]);
+        expect(tags.state(["a"], 40)).toBe("expired");
+        expect(tags.state(["a"], 60)).toBe("fresh");
+        expect(tags.state(["b"], 40)).toBe("fresh");
+    });
+    it("applies its own revalidation at once, and writes it once for both handlers", async () => {
+        const markers = fakeMarkers();
+        const tags = new aws_cache_store_1.TrackedTagMarkers({
+            markers: markers.table,
+            log: fakeLog().log,
+        });
+        const createdAt = Date.now() - 1000;
+        // What Next.js does: `updateTags` on the default and the remote handler.
+        await Promise.all([
+            tags.update(["a", "b"], { expire: 0 }),
+            tags.update(["a", "b"], { expire: 0 }),
+        ]);
+        expect(markers.write).toHaveBeenCalledTimes(2);
+        expect(tags.state(["b"], createdAt)).toBe("expired");
+        expect(markers.rows.get("a")).toEqual({
+            staleAt: expect.any(Number),
+            expiredAt: expect.any(Number),
+        });
+    });
+    it("gives a later revalidation its own marker while the first is still writing", async () => {
+        const markers = fakeMarkers();
+        let release = () => { };
+        markers.write.mockImplementationOnce((_tag, at) => new Promise((resolve) => {
+            release = () => resolve({ revalidatedAt: at });
+        }));
+        const tags = new aws_cache_store_1.TrackedTagMarkers({
+            markers: markers.table,
+            log: fakeLog().log,
+        });
+        const first = tags.update(["x"], undefined);
+        // Another request's `revalidateTag('x')`, a turn later.
+        await new Promise((resolve) => setImmediate(resolve));
+        const second = tags.update(["x"], undefined);
+        release();
+        await Promise.all([first, second]);
+        expect(markers.write).toHaveBeenCalledTimes(2);
+        const [[, firstAt], [, secondAt]] = markers.write.mock.calls;
+        expect(secondAt).toBeGreaterThan(firstAt);
+    });
+    it("puts a slow log row again under a fresh timestamp, so readers see it", async () => {
+        const clock = fakeClock();
+        const log = fakeLog();
+        log.put.mockImplementationOnce(async () => {
+            // Readers' cursors have moved past the row by the time it shows.
+            clock.at += 10_000;
+        });
+        const tags = new aws_cache_store_1.TrackedTagMarkers({
+            markers: fakeMarkers().table,
+            log: log.log,
+            clock: clock.now,
+        });
+        expect(await tags.update(["x"], undefined)).toBe(true);
+        expect(log.put.mock.calls.map(([, at]) => at)).toEqual([
+            1_000_000, 1_010_000,
+        ]);
+    });
+    it("reports a log row slow twice as not recorded", async () => {
+        const clock = fakeClock();
+        const log = fakeLog();
+        log.put.mockImplementation(async () => {
+            clock.at += 10_000;
+        });
+        const error = jest.spyOn(console, "error").mockImplementation(() => { });
+        const tags = new aws_cache_store_1.TrackedTagMarkers({
+            markers: fakeMarkers().table,
+            log: log.log,
+            clock: clock.now,
+        });
+        expect(await tags.update(["x"], undefined)).toBe(false);
+        expect(log.put).toHaveBeenCalledTimes(2);
+        error.mockRestore();
+    });
+    it("tracks the whole row its own write returns, not just what it set", async () => {
+        // Another instance's `updateTag` for a tag this one does not track yet.
+        const createdAt = Date.now() - 1000;
+        const markers = fakeMarkers(new Map([["posts", { revalidatedAt: createdAt + 500 }]]));
+        const tags = new aws_cache_store_1.TrackedTagMarkers({
+            markers: markers.table,
+            log: fakeLog().log,
+        });
+        await tags.update(["posts"], { expire: 3600 });
+        // Older than that `updateTag`, so a blocking render, not stale-while-revalidate.
+        expect(tags.state(["posts"], createdAt)).toBe("expired");
+    });
+    it("marks a profile's revalidation stale until its expire", async () => {
+        const tags = new aws_cache_store_1.TrackedTagMarkers({});
+        const createdAt = Date.now() - 1000;
+        await tags.update(["a"], { expire: 3600 });
+        expect(tags.state(["a"], createdAt)).toBe("stale");
+        // Not an expiration yet, so implicit tags are not affected either.
+        expect(tags.expiration(["a"])).toBe(0);
+    });
+    // Next.js stamps entries with `performance.timeOrigin + performance.now()`,
+    // which can run behind `Date.now()`. A marker stamped on the wall clock would
+    // then postdate an entry regenerated right after the revalidation, which
+    // would read as revalidated again, and again.
+    it("stamps markers on the clock entries are stamped with", async () => {
+        const wall = jest.spyOn(Date, "now").mockImplementation(() => (0, use_cache_common_1.now)() + 500);
+        try {
+            const tags = new aws_cache_store_1.TrackedTagMarkers({});
+            await tags.update(["a"], undefined);
+            const regenerated = (0, use_cache_common_1.now)() + 1;
+            expect(tags.state(["a"], regenerated)).toBe("fresh");
+            expect(tags.state(["a"], regenerated - 100)).toBe("expired");
+        }
+        finally {
+            wall.mockRestore();
+        }
+    });
+    it("reports the latest past expiration of implicit tags", async () => {
+        const markers = fakeMarkers(new Map([
+            ["_N_T_/a", { revalidatedAt: 100 }],
+            ["_N_T_/b", { staleAt: 150, expiredAt: 200 }],
+            ["_N_T_/c", { staleAt: 150, expiredAt: Date.now() + 60_000 }],
+        ]));
+        const tags = new aws_cache_store_1.TrackedTagMarkers({
+            markers: markers.table,
+            log: fakeLog().log,
+        });
+        await tags.ensure(["_N_T_/a", "_N_T_/b", "_N_T_/c", "_N_T_/d"]);
+        expect(tags.expiration(["_N_T_/a", "_N_T_/b", "_N_T_/c"])).toBe(200);
+        expect(tags.expiration(["_N_T_/d"])).toBe(0);
+    });
+    it("does not let an eventually consistent read undo its own write", async () => {
+        const markers = fakeMarkers();
+        const tags = new aws_cache_store_1.TrackedTagMarkers({
+            markers: markers.table,
+            log: fakeLog().log,
+            refreshIntervalMs: 0,
+        });
+        await tags.update(["a"], undefined);
+        // The read does not show the write yet.
+        markers.rows.clear();
+        await tags.refresh();
+        expect(tags.state(["a"], Date.now() - 1000)).toBe("expired");
+    });
+    it("treats a failed read as fresh and tries again on the next refresh", async () => {
+        const markers = fakeMarkers(new Map([["a", { revalidatedAt: 50 }]]));
+        const error = jest.spyOn(console, "error").mockImplementation(() => { });
+        markers.read.mockRejectedValueOnce(new Error("throttled"));
+        const tags = new aws_cache_store_1.TrackedTagMarkers({
+            markers: markers.table,
+            log: fakeLog().log,
+            refreshIntervalMs: 0,
+        });
+        await tags.ensure(["a"]);
+        expect(tags.state(["a"], 40)).toBe("fresh");
+        await tags.refresh();
+        expect(tags.state(["a"], 40)).toBe("expired");
+        error.mockRestore();
+    });
+    it("forgets the least recently used tag past its bound, and reads it again", async () => {
+        const markers = fakeMarkers();
+        const tags = new aws_cache_store_1.TrackedTagMarkers({
+            markers: markers.table,
+            log: fakeLog().log,
+            maxTrackedTags: 2,
+        });
+        await tags.ensure(["a"]);
+        await tags.ensure(["b"]);
+        await tags.ensure(["a"]); // `b` is now the oldest
+        await tags.ensure(["c"]);
+        markers.read.mockClear();
+        await tags.ensure(["a", "b", "c"]);
+        expect(markers.read).toHaveBeenCalledWith(["b"]);
+    });
+    // Every path is a tag of its own, so an app of 1000 tagged pages needs 2000:
+    // tracked 1000 at most, half its requests re-read an evicted marker.
+    it("keeps 2000 tags a page each tracked, without reading them again", async () => {
+        const markers = fakeMarkers();
+        const tags = new aws_cache_store_1.TrackedTagMarkers({
+            markers: markers.table,
+            log: fakeLog().log,
+        });
+        const pages = Array.from({ length: 1000 }, (_, n) => [
+            `item-${n}`,
+            `_N_T_/use-cache/${n}`,
+        ]);
+        for (const page of pages)
+            await tags.ensure(page);
+        markers.read.mockClear();
+        for (const page of pages)
+            await tags.ensure(page);
+        expect(markers.read).not.toHaveBeenCalled();
+    });
+    it("keeps tags local to the process without a table", async () => {
+        const tags = new aws_cache_store_1.TrackedTagMarkers({});
+        await tags.ensure(["a"]);
+        await tags.refresh();
+        await tags.update(["a"], undefined);
+        expect(tags.state(["a"], Date.now() - 1000)).toBe("expired");
+    });
+});
+describe("TrackedTagMarkers with the revalidation log", () => {
+    const INTERVAL = 1000;
+    /** Two instances, `a` and `b`, over one table and one clock. */
+    function instances(options = {}) {
+        const markerRows = new Map();
+        const logRows = [];
+        const clock = fakeClock();
+        const instance = () => {
+            const markers = fakeMarkers(markerRows);
+            const log = fakeLog(logRows);
+            const tags = new aws_cache_store_1.TrackedTagMarkers({
+                markers: markers.table,
+                log: log.log,
+                refreshIntervalMs: INTERVAL,
+                clock: clock.now,
+                // Due at the full interval unless a test asks otherwise.
+                random: () => 0,
+                ...options,
+            });
+            return { markers, log, tags };
+        };
+        return { clock, logRows, instance, a: instance(), b: instance() };
+    }
+    const createdAt = () => (0, use_cache_common_1.now)() - 1000;
+    it("reaches another instance within one interval, in one Query and no BatchGetItem", async () => {
+        const { clock, a, b } = instances();
+        await b.tags.ensure(["posts"]);
+        b.markers.read.mockClear();
+        await a.tags.update(["posts"], undefined);
+        expect(a.log.put).toHaveBeenCalledWith("posts", clock.at, expect.objectContaining({ revalidatedAt: expect.any(Number) }));
+        clock.at += INTERVAL;
+        await b.tags.refresh();
+        expect(b.tags.state(["posts"], createdAt())).toBe("expired");
+        expect(b.log.query).toHaveBeenCalledTimes(1);
+        expect(b.markers.read).not.toHaveBeenCalled();
+    });
+    it("issues no read while the interval has not passed", async () => {
+        const { clock, b } = instances();
+        // Nothing tracked: nothing to ask.
+        clock.at += INTERVAL;
+        await b.tags.refresh();
+        expect(b.log.query).not.toHaveBeenCalled();
+        await b.tags.ensure(["posts"]);
+        b.markers.read.mockClear();
+        // That refresh still counts: what is tracked since was read, or is new.
+        await b.tags.refresh();
+        expect(b.log.query).not.toHaveBeenCalled();
+        clock.at += INTERVAL;
+        await Promise.all([b.tags.refresh(), b.tags.refresh()]);
+        expect(b.log.query).toHaveBeenCalledTimes(1);
+        clock.at += INTERVAL - 1;
+        await b.tags.refresh();
+        expect(b.log.query).toHaveBeenCalledTimes(1);
+        expect(b.markers.read).not.toHaveBeenCalled();
+        clock.at += 1;
+        await b.tags.refresh();
+        expect(b.log.query).toHaveBeenCalledTimes(2);
+    });
+    it("applies a row read again inside the lookback only once", async () => {
+        const { clock, logRows, b } = instances();
+        await b.tags.ensure(["posts"]);
+        b.markers.read.mockClear();
+        let reads = 0;
+        const row = {
+            sk: `${clock.at}#posts`,
+            at: clock.at,
+            tag: "posts",
+            get marker() {
+                reads++;
+                return { revalidatedAt: (0, use_cache_common_1.now)() };
+            },
+        };
+        // The same row twice in one page, and again on the next query.
+        logRows.push(row, row);
+        for (let i = 0; i < 3; i++) {
+            clock.at += INTERVAL;
+            await b.tags.refresh();
+        }
+        expect(b.log.query).toHaveBeenCalledTimes(3);
+        expect(reads).toBe(1);
+        expect(b.tags.state(["posts"], createdAt())).toBe("expired");
+    });
+    // Replication lag, or a writer whose clock runs behind: the row shows up
+    // after a query that should have seen it, with a sort key before it.
+    it("still sees a row that appears up to the lookback late", async () => {
+        const { clock, logRows, b } = instances();
+        await b.tags.ensure(["late", "too-late"]);
+        b.markers.read.mockClear();
+        clock.at += INTERVAL;
+        const firstQuery = clock.at;
+        await b.tags.refresh();
+        const marker = { revalidatedAt: (0, use_cache_common_1.now)() };
+        logRows.push({ sk: "late", at: firstQuery - 5000, tag: "late", marker }, { sk: "too-late", at: firstQuery - 5001, tag: "too-late", marker });
+        clock.at += INTERVAL;
+        await b.tags.refresh();
+        expect(b.log.query).toHaveBeenLastCalledWith(firstQuery - 5000);
+        expect(b.tags.state(["late"], createdAt())).toBe("expired");
+        // Past the lookback: what the periodic re-read of the markers is for.
+        expect(b.tags.state(["too-late"], createdAt())).toBe("fresh");
+    });
+    it("forgets its tracked markers after a gap the log may not cover, and reads each as it is needed", async () => {
+        const { clock, a, b } = instances();
+        await b.tags.ensure(["posts", "other"]);
+        await a.tags.update(["posts"], undefined);
+        clock.at += aws_cache_store_1.MAX_REVALIDATION_LOG_GAP_MS + 1;
+        const gapEnd = clock.at;
+        await b.tags.refresh();
+        // No burst of re-reads, and no query of a log that may have lost rows.
+        expect(b.markers.read).toHaveBeenCalledTimes(1);
+        expect(b.log.query).not.toHaveBeenCalled();
+        await b.tags.ensure(["posts"]);
+        expect(b.markers.read).toHaveBeenLastCalledWith(["posts"]);
+        expect(b.tags.state(["posts"], createdAt())).toBe("expired");
+        // Then back on the log, from just before the gap ended.
+        clock.at += INTERVAL;
+        await b.tags.refresh();
+        expect(b.log.query).toHaveBeenCalledWith(gapEnd - 5000);
+    });
+    // Re-reading every tracked marker at once is ~5,000 RCU at 10,000 tags: more
+    // than the one partition serves in a second.
+    it("re-reads each tracked marker once per resync interval, at most 100 a refresh", async () => {
+        const { clock, b } = instances({ resyncIntervalMs: 10 * INTERVAL });
+        await b.tags.ensure(Array.from({ length: 250 }, (_, i) => `t${i}`));
+        b.markers.read.mockClear();
+        const sizes = [];
+        for (let i = 1; i <= 14; i++) {
+            clock.at += INTERVAL;
+            b.markers.read.mockClear();
+            await b.tags.refresh();
+            sizes.push(b.markers.read.mock.calls[0]?.[0].length ?? 0);
+        }
+        expect(b.log.query).toHaveBeenCalledTimes(14);
+        // Due at 10 intervals, oldest first, 100 per refresh; then not again.
+        expect(sizes).toEqual([0, 0, 0, 0, 0, 0, 0, 0, 0, 100, 100, 50, 0, 0]);
+        expect(b.markers.read).not.toHaveBeenCalled();
+    });
+    // Tags first read together must not come due together every interval.
+    it("spreads when each tag comes due over the last quarter of the interval", async () => {
+        // Due at 10, 8.75 and 7.5 intervals, known in that order: the one due
+        // first is last, behind two that are not due yet.
+        const randoms = [0, 0.5, 1];
+        const { clock, b } = instances({
+            resyncIntervalMs: 10 * INTERVAL,
+            random: () => randoms.shift() ?? 0,
+        });
+        await b.tags.ensure(["late", "middle", "early"]);
+        b.markers.read.mockClear();
+        const readAt = {};
+        for (let i = 1; i <= 10; i++) {
+            clock.at += INTERVAL;
+            b.markers.read.mockClear();
+            await b.tags.refresh();
+            for (const tag of b.markers.read.mock.calls[0]?.[0] ?? []) {
+                readAt[tag] ??= i;
+            }
+        }
+        expect(readAt).toEqual({ early: 8, middle: 9, late: 10 });
+    });
+    it("re-reads a marker it learned of from its own write only once that is due", async () => {
+        const { clock, a } = instances({ resyncIntervalMs: 10 * INTERVAL });
+        await a.tags.ensure(["posts"]);
+        clock.at += 9 * INTERVAL;
+        await a.tags.update(["posts"], undefined);
+        clock.at += 2 * INTERVAL;
+        await a.tags.refresh();
+        // Read 11 intervals ago, but written - so known - 2 intervals ago.
+        expect(a.markers.read).toHaveBeenCalledTimes(1);
+    });
+    it("reads a tag whose first read failed again on the next refresh", async () => {
+        const error = jest.spyOn(console, "error").mockImplementation(() => { });
+        const { clock, a, b } = instances();
+        // Only the marker row has it, so only reading the marker finds it.
+        a.log.put.mockRejectedValueOnce(new Error("throttled"));
+        await a.tags.update(["posts"], undefined);
+        b.markers.read.mockRejectedValueOnce(new Error("throttled"));
+        await b.tags.ensure(["posts"]);
+        expect(b.tags.state(["posts"], createdAt())).toBe("fresh");
+        clock.at += INTERVAL;
+        await b.tags.refresh();
+        expect(b.markers.read).toHaveBeenLastCalledWith(["posts"]);
+        expect(b.tags.state(["posts"], createdAt())).toBe("expired");
+        error.mockRestore();
+    });
+    it("forgets its tracked markers when the log has more rows than one query reads", async () => {
+        const { clock, b } = instances();
+        await b.tags.ensure(["posts"]);
+        b.log.query.mockResolvedValueOnce({ rows: [], truncated: true });
+        clock.at += INTERVAL;
+        await b.tags.refresh();
+        expect(b.markers.read).toHaveBeenCalledTimes(1);
+        await b.tags.ensure(["posts"]);
+        expect(b.markers.read).toHaveBeenCalledTimes(2);
+    });
+    // Tracking is per tag, not per entry: storing a new entry must not vouch for
+    // an older one with the same tag. B's log cursor starts after C's
+    // revalidation, so only reading the marker shows it.
+    it("still reads a tag's marker after storing an entry with it", async () => {
+        const { clock, instance, a: c } = instances();
+        const k1CreatedAt = createdAt();
+        await c.tags.update(["posts"], undefined);
+        clock.at += 10_000;
+        // Started after the revalidation: its log cursor is past C's row.
+        const b = instance();
+        b.tags.track(["posts"]);
+        await b.tags.ensure(["posts"]);
+        expect(b.markers.read).toHaveBeenCalledWith(["posts"]);
+        expect(b.tags.state(["posts"], k1CreatedAt)).toBe("expired");
+    });
+    it("still reads a tag's marker after storing an entry with it following a forget", async () => {
+        const { clock, a, b } = instances();
+        await b.tags.ensure(["posts"]);
+        const k1CreatedAt = createdAt();
+        // Revalidated while `b` was frozen past what the log covers.
+        clock.at += aws_cache_store_1.MAX_REVALIDATION_LOG_GAP_MS + 1;
+        a.log.put.mockRejectedValueOnce(new Error("lost"));
+        const error = jest.spyOn(console, "error").mockImplementation(() => { });
+        await a.tags.update(["posts"], undefined);
+        error.mockRestore();
+        await b.tags.refresh();
+        b.tags.track(["posts"]);
+        await b.tags.ensure(["posts"]);
+        expect(b.tags.state(["posts"], k1CreatedAt)).toBe("expired");
+    });
+    it("applies a log row that lands while the tag's first read is in flight", async () => {
+        const { clock, a, b } = instances();
+        // Something tracked, so the refresh queries the log.
+        await b.tags.ensure(["other"]);
+        let answer;
+        // Answered before the revalidation below, as a read racing it can be.
+        b.markers.read.mockImplementationOnce(() => new Promise((resolve) => (answer = resolve)));
+        const first = b.tags.ensure(["posts"]);
+        await a.tags.update(["posts"], undefined);
+        clock.at += INTERVAL;
+        await b.tags.refresh();
+        answer(new Map());
+        await first;
+        expect(b.tags.state(["posts"], createdAt())).toBe("expired");
+    });
+    it("is visible at once on the instance that ran updateTag", async () => {
+        const { a } = instances();
+        a.tags.track(["posts"]);
+        await a.tags.update(["posts"], undefined);
+        expect(a.tags.state(["posts"], createdAt())).toBe("expired");
+        expect(a.markers.write).toHaveBeenCalledTimes(1);
+        expect(a.log.put).toHaveBeenCalledTimes(1);
+    });
+    it("keeps its tags through a failed query and asks again next interval", async () => {
+        const error = jest.spyOn(console, "error").mockImplementation(() => { });
+        const { clock, a, b } = instances();
+        await b.tags.ensure(["posts"]);
+        b.markers.read.mockClear();
+        await a.tags.update(["posts"], undefined);
+        b.log.query.mockRejectedValueOnce(new Error("throttled"));
+        clock.at += INTERVAL;
+        const cursor = clock.at - INTERVAL - 5000;
+        await b.tags.refresh();
+        expect(b.tags.state(["posts"], createdAt())).toBe("fresh");
+        expect(error).toHaveBeenCalled();
+        clock.at += INTERVAL;
+        await b.tags.refresh();
+        // From the same cursor, so nothing written meanwhile is skipped.
+        expect(b.log.query).toHaveBeenLastCalledWith(cursor);
+        expect(b.tags.state(["posts"], createdAt())).toBe("expired");
+        expect(b.markers.read).not.toHaveBeenCalled();
+        error.mockRestore();
+    });
+    it("still writes the marker when the log row fails", async () => {
+        const error = jest.spyOn(console, "error").mockImplementation(() => { });
+        const { a } = instances();
+        a.log.put.mockRejectedValueOnce(new Error("throttled"));
+        await a.tags.update(["posts"], undefined);
+        expect(a.markers.rows.get("posts")?.revalidatedAt).toEqual(expect.any(Number));
+        expect(error).toHaveBeenCalledWith(expect.stringMatching(/revalidation log/), expect.any(Error));
+        error.mockRestore();
+    });
+});
+describe("EntryLru", () => {
+    it("evicts the least recently used entries past its byte bound", () => {
+        const lru = new use_cache_common_1.EntryLru(250);
+        lru.set("a", stored(100));
+        lru.set("b", stored(100));
+        lru.get("a");
+        lru.set("c", stored(100));
+        expect(lru.get("b")).toBeUndefined();
+        expect(lru.get("a")).toBeDefined();
+        expect(lru.get("c")).toBeDefined();
+    });
+    it("does not keep an entry larger than the whole bound", () => {
+        const lru = new use_cache_common_1.EntryLru(50);
+        lru.set("a", stored(100));
+        expect(lru.size).toBe(0);
+    });
+    it("accounts for a replaced entry", () => {
+        const lru = new use_cache_common_1.EntryLru(250);
+        lru.set("a", stored(200));
+        lru.set("a", stored(10));
+        lru.set("b", stored(200));
+        expect(lru.size).toBe(2);
+    });
+});
+describe("entries", () => {
+    it("reads a stream to the end", async () => {
+        const bytes = await (0, use_cache_common_1.readStream)(streamOf("ab", "cd"));
+        expect(new TextDecoder().decode(bytes)).toBe("abcd");
+    });
+    it("rejects a stream that errors part-way", async () => {
+        const failing = new ReadableStream({
+            start(controller) {
+                controller.enqueue(new Uint8Array([1]));
+                controller.error(new Error("render failed"));
+            },
+        });
+        await expect((0, use_cache_common_1.readStream)(failing)).rejects.toThrow("render failed");
+    });
+    it("hands every reader its own stream", async () => {
+        const entry = {
+            value: streamOf("payload"),
+            tags: ["t"],
+            stale: 1,
+            timestamp: 2,
+            expire: 3,
+            revalidate: 4,
+        };
+        const kept = await (0, use_cache_common_1.storedEntryOf)(Promise.resolve(entry));
+        const first = (0, use_cache_common_1.cacheEntryOf)(kept);
+        const second = (0, use_cache_common_1.cacheEntryOf)(kept, -1);
+        expect(second.revalidate).toBe(-1);
+        expect(first.tags).toEqual(["t"]);
+        expect(new TextDecoder().decode(await (0, use_cache_common_1.readStream)(first.value))).toBe("payload");
+        expect(new TextDecoder().decode(await (0, use_cache_common_1.readStream)(second.value))).toBe("payload");
+    });
+});
+describe("PendingSets", () => {
+    it("holds a get until the set for its key ends", async () => {
+        const pending = new use_cache_common_1.PendingSets();
+        const done = pending.begin("k");
+        let waited = false;
+        const wait = pending.wait("k").then(() => (waited = true));
+        await Promise.resolve();
+        expect(waited).toBe(false);
+        done();
+        await wait;
+        expect(waited).toBe(true);
+        // Nothing pending: no wait at all.
+        await pending.wait("k");
+        await pending.wait("other");
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"use-cache-common.test.js","sourceRoot":"","sources":["../../src/adapter/use-cache-common.test.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\njest.mock(\"@aws-sdk/client-dynamodb\");\n\nimport type { CacheEntry } from \"next/dist/server/lib/cache-handlers/types\";\nimport {\n  MAX_REVALIDATION_LOG_GAP_MS,\n  RevalidationLog,\n  RevalidationLogRow,\n  TagMarker,\n  TagMarkerTable,\n  TrackedTagMarkers,\n} from \"./aws-cache-store\";\nimport {\n  cacheEntryOf,\n  EntryLru,\n  now,\n  PendingSets,\n  readStream,\n  StoredEntry,\n  storedEntryOf,\n} from \"./use-cache-common\";\n\n/** A `TagMarkerTable` over a plain map, counting its calls. */\nfunction fakeMarkers(rows = new Map<string, TagMarker>()) {\n  const read = jest.fn(async (tags: string[]) => {\n    const found = new Map<string, TagMarker>();\n    for (const tag of tags) {\n      const row = rows.get(tag);\n      if (row) found.set(tag, { ...row });\n    }\n    return found;\n  });\n  const write = jest.fn(\n    async (tag: string, at: number, durations?: { expire?: number }) => {\n      const row = rows.get(tag) ?? {};\n      if (!durations) {\n        row.revalidatedAt = at;\n      } else {\n        row.staleAt = at;\n        if (durations.expire !== undefined) {\n          row.expiredAt = at + durations.expire * 1000;\n        }\n      }\n      rows.set(tag, row);\n      // `ReturnValues: \"ALL_NEW\"`, as the real table answers.\n      return { ...row };\n    },\n  );\n  return {\n    rows,\n    read,\n    write,\n    table: { read, write } as unknown as TagMarkerTable,\n  };\n}\n\n/**\n * A `RevalidationLog` over a plain array, counting its calls. Its query returns\n * what the real one would: every row at or after `since`, oldest first.\n */\nfunction fakeLog(rows: RevalidationLogRow[] = []) {\n  const put = jest.fn(async (tag: string, at: number, marker: TagMarker) => {\n    rows.push({\n      sk: `${String(at).padStart(15, \"0\")}#${tag}`,\n      at,\n      tag,\n      marker,\n    });\n  });\n  const query = jest.fn(async (since: number) => ({\n    rows: rows.filter((row) => row.at >= since).sort((a, b) => a.at - b.at),\n    truncated: false,\n  }));\n  return {\n    rows,\n    put,\n    query,\n    log: { put, query } as unknown as RevalidationLog,\n  };\n}\n\n/** A wall clock a test moves by hand. */\nfunction fakeClock(start = 1_000_000) {\n  const clock = { at: start, now: () => clock.at };\n  return clock;\n}\n\nfunction streamOf(...chunks: string[]): ReadableStream<Uint8Array> {\n  return new ReadableStream({\n    start(controller) {\n      for (const chunk of chunks) {\n        controller.enqueue(new TextEncoder().encode(chunk));\n      }\n      controller.close();\n    },\n  });\n}\n\nfunction stored(bytes: number, extra: Partial<StoredEntry> = {}): StoredEntry {\n  return {\n    value: new Uint8Array(bytes),\n    tags: [],\n    stale: 300,\n    timestamp: Date.now(),\n    expire: 3600,\n    revalidate: 900,\n    ...extra,\n  };\n}\n\ndescribe(\"TrackedTagMarkers\", () => {\n  it(\"reads a tag the first time it is needed, and not again\", async () => {\n    const markers = fakeMarkers(new Map([[\"a\", { revalidatedAt: 50 }]]));\n    const tags = new TrackedTagMarkers({\n      markers: markers.table,\n      log: fakeLog().log,\n    });\n\n    await Promise.all([tags.ensure([\"a\", \"b\"]), tags.ensure([\"a\", \"b\"])]);\n    await tags.ensure([\"a\", \"b\"]);\n\n    expect(markers.read).toHaveBeenCalledTimes(1);\n    expect(markers.read).toHaveBeenCalledWith([\"a\", \"b\"]);\n    expect(tags.state([\"a\"], 40)).toBe(\"expired\");\n    expect(tags.state([\"a\"], 60)).toBe(\"fresh\");\n    expect(tags.state([\"b\"], 40)).toBe(\"fresh\");\n  });\n\n  it(\"applies its own revalidation at once, and writes it once for both handlers\", async () => {\n    const markers = fakeMarkers();\n    const tags = new TrackedTagMarkers({\n      markers: markers.table,\n      log: fakeLog().log,\n    });\n    const createdAt = Date.now() - 1000;\n\n    // What Next.js does: `updateTags` on the default and the remote handler.\n    await Promise.all([\n      tags.update([\"a\", \"b\"], { expire: 0 }),\n      tags.update([\"a\", \"b\"], { expire: 0 }),\n    ]);\n\n    expect(markers.write).toHaveBeenCalledTimes(2);\n    expect(tags.state([\"b\"], createdAt)).toBe(\"expired\");\n    expect(markers.rows.get(\"a\")).toEqual({\n      staleAt: expect.any(Number),\n      expiredAt: expect.any(Number),\n    });\n  });\n\n  it(\"gives a later revalidation its own marker while the first is still writing\", async () => {\n    const markers = fakeMarkers();\n    let release = () => {};\n    markers.write.mockImplementationOnce(\n      (_tag, at) =>\n        new Promise((resolve) => {\n          release = () => resolve({ revalidatedAt: at });\n        }),\n    );\n    const tags = new TrackedTagMarkers({\n      markers: markers.table,\n      log: fakeLog().log,\n    });\n\n    const first = tags.update([\"x\"], undefined);\n    // Another request's `revalidateTag('x')`, a turn later.\n    await new Promise((resolve) => setImmediate(resolve));\n    const second = tags.update([\"x\"], undefined);\n    release();\n    await Promise.all([first, second]);\n\n    expect(markers.write).toHaveBeenCalledTimes(2);\n    const [[, firstAt], [, secondAt]] = markers.write.mock.calls;\n    expect(secondAt).toBeGreaterThan(firstAt);\n  });\n\n  it(\"puts a slow log row again under a fresh timestamp, so readers see it\", async () => {\n    const clock = fakeClock();\n    const log = fakeLog();\n    log.put.mockImplementationOnce(async () => {\n      // Readers' cursors have moved past the row by the time it shows.\n      clock.at += 10_000;\n    });\n    const tags = new TrackedTagMarkers({\n      markers: fakeMarkers().table,\n      log: log.log,\n      clock: clock.now,\n    });\n\n    expect(await tags.update([\"x\"], undefined)).toBe(true);\n    expect(log.put.mock.calls.map(([, at]) => at)).toEqual([\n      1_000_000, 1_010_000,\n    ]);\n  });\n\n  it(\"reports a log row slow twice as not recorded\", async () => {\n    const clock = fakeClock();\n    const log = fakeLog();\n    log.put.mockImplementation(async () => {\n      clock.at += 10_000;\n    });\n    const error = jest.spyOn(console, \"error\").mockImplementation(() => {});\n    const tags = new TrackedTagMarkers({\n      markers: fakeMarkers().table,\n      log: log.log,\n      clock: clock.now,\n    });\n\n    expect(await tags.update([\"x\"], undefined)).toBe(false);\n    expect(log.put).toHaveBeenCalledTimes(2);\n    error.mockRestore();\n  });\n\n  it(\"tracks the whole row its own write returns, not just what it set\", async () => {\n    // Another instance's `updateTag` for a tag this one does not track yet.\n    const createdAt = Date.now() - 1000;\n    const markers = fakeMarkers(\n      new Map([[\"posts\", { revalidatedAt: createdAt + 500 }]]),\n    );\n    const tags = new TrackedTagMarkers({\n      markers: markers.table,\n      log: fakeLog().log,\n    });\n\n    await tags.update([\"posts\"], { expire: 3600 });\n\n    // Older than that `updateTag`, so a blocking render, not stale-while-revalidate.\n    expect(tags.state([\"posts\"], createdAt)).toBe(\"expired\");\n  });\n\n  it(\"marks a profile's revalidation stale until its expire\", async () => {\n    const tags = new TrackedTagMarkers({});\n    const createdAt = Date.now() - 1000;\n    await tags.update([\"a\"], { expire: 3600 });\n    expect(tags.state([\"a\"], createdAt)).toBe(\"stale\");\n    // Not an expiration yet, so implicit tags are not affected either.\n    expect(tags.expiration([\"a\"])).toBe(0);\n  });\n\n  // Next.js stamps entries with `performance.timeOrigin + performance.now()`,\n  // which can run behind `Date.now()`. A marker stamped on the wall clock would\n  // then postdate an entry regenerated right after the revalidation, which\n  // would read as revalidated again, and again.\n  it(\"stamps markers on the clock entries are stamped with\", async () => {\n    const wall = jest.spyOn(Date, \"now\").mockImplementation(() => now() + 500);\n    try {\n      const tags = new TrackedTagMarkers({});\n      await tags.update([\"a\"], undefined);\n      const regenerated = now() + 1;\n      expect(tags.state([\"a\"], regenerated)).toBe(\"fresh\");\n      expect(tags.state([\"a\"], regenerated - 100)).toBe(\"expired\");\n    } finally {\n      wall.mockRestore();\n    }\n  });\n\n  it(\"reports the latest past expiration of implicit tags\", async () => {\n    const markers = fakeMarkers(\n      new Map<string, TagMarker>([\n        [\"_N_T_/a\", { revalidatedAt: 100 }],\n        [\"_N_T_/b\", { staleAt: 150, expiredAt: 200 }],\n        [\"_N_T_/c\", { staleAt: 150, expiredAt: Date.now() + 60_000 }],\n      ]),\n    );\n    const tags = new TrackedTagMarkers({\n      markers: markers.table,\n      log: fakeLog().log,\n    });\n    await tags.ensure([\"_N_T_/a\", \"_N_T_/b\", \"_N_T_/c\", \"_N_T_/d\"]);\n    expect(tags.expiration([\"_N_T_/a\", \"_N_T_/b\", \"_N_T_/c\"])).toBe(200);\n    expect(tags.expiration([\"_N_T_/d\"])).toBe(0);\n  });\n\n  it(\"does not let an eventually consistent read undo its own write\", async () => {\n    const markers = fakeMarkers();\n    const tags = new TrackedTagMarkers({\n      markers: markers.table,\n      log: fakeLog().log,\n      refreshIntervalMs: 0,\n    });\n    await tags.update([\"a\"], undefined);\n    // The read does not show the write yet.\n    markers.rows.clear();\n    await tags.refresh();\n    expect(tags.state([\"a\"], Date.now() - 1000)).toBe(\"expired\");\n  });\n\n  it(\"treats a failed read as fresh and tries again on the next refresh\", async () => {\n    const markers = fakeMarkers(new Map([[\"a\", { revalidatedAt: 50 }]]));\n    const error = jest.spyOn(console, \"error\").mockImplementation(() => {});\n    markers.read.mockRejectedValueOnce(new Error(\"throttled\"));\n    const tags = new TrackedTagMarkers({\n      markers: markers.table,\n      log: fakeLog().log,\n      refreshIntervalMs: 0,\n    });\n\n    await tags.ensure([\"a\"]);\n    expect(tags.state([\"a\"], 40)).toBe(\"fresh\");\n    await tags.refresh();\n    expect(tags.state([\"a\"], 40)).toBe(\"expired\");\n    error.mockRestore();\n  });\n\n  it(\"forgets the least recently used tag past its bound, and reads it again\", async () => {\n    const markers = fakeMarkers();\n    const tags = new TrackedTagMarkers({\n      markers: markers.table,\n      log: fakeLog().log,\n      maxTrackedTags: 2,\n    });\n    await tags.ensure([\"a\"]);\n    await tags.ensure([\"b\"]);\n    await tags.ensure([\"a\"]); // `b` is now the oldest\n    await tags.ensure([\"c\"]);\n    markers.read.mockClear();\n\n    await tags.ensure([\"a\", \"b\", \"c\"]);\n    expect(markers.read).toHaveBeenCalledWith([\"b\"]);\n  });\n\n  // Every path is a tag of its own, so an app of 1000 tagged pages needs 2000:\n  // tracked 1000 at most, half its requests re-read an evicted marker.\n  it(\"keeps 2000 tags a page each tracked, without reading them again\", async () => {\n    const markers = fakeMarkers();\n    const tags = new TrackedTagMarkers({\n      markers: markers.table,\n      log: fakeLog().log,\n    });\n    const pages = Array.from({ length: 1000 }, (_, n) => [\n      `item-${n}`,\n      `_N_T_/use-cache/${n}`,\n    ]);\n    for (const page of pages) await tags.ensure(page);\n    markers.read.mockClear();\n    for (const page of pages) await tags.ensure(page);\n    expect(markers.read).not.toHaveBeenCalled();\n  });\n\n  it(\"keeps tags local to the process without a table\", async () => {\n    const tags = new TrackedTagMarkers({});\n    await tags.ensure([\"a\"]);\n    await tags.refresh();\n    await tags.update([\"a\"], undefined);\n    expect(tags.state([\"a\"], Date.now() - 1000)).toBe(\"expired\");\n  });\n});\n\ndescribe(\"TrackedTagMarkers with the revalidation log\", () => {\n  const INTERVAL = 1000;\n\n  /** Two instances, `a` and `b`, over one table and one clock. */\n  function instances(\n    options: { resyncIntervalMs?: number; random?: () => number } = {},\n  ) {\n    const markerRows = new Map<string, TagMarker>();\n    const logRows: RevalidationLogRow[] = [];\n    const clock = fakeClock();\n    const instance = () => {\n      const markers = fakeMarkers(markerRows);\n      const log = fakeLog(logRows);\n      const tags = new TrackedTagMarkers({\n        markers: markers.table,\n        log: log.log,\n        refreshIntervalMs: INTERVAL,\n        clock: clock.now,\n        // Due at the full interval unless a test asks otherwise.\n        random: () => 0,\n        ...options,\n      });\n      return { markers, log, tags };\n    };\n    return { clock, logRows, instance, a: instance(), b: instance() };\n  }\n\n  const createdAt = () => now() - 1000;\n\n  it(\"reaches another instance within one interval, in one Query and no BatchGetItem\", async () => {\n    const { clock, a, b } = instances();\n    await b.tags.ensure([\"posts\"]);\n    b.markers.read.mockClear();\n\n    await a.tags.update([\"posts\"], undefined);\n    expect(a.log.put).toHaveBeenCalledWith(\n      \"posts\",\n      clock.at,\n      expect.objectContaining({ revalidatedAt: expect.any(Number) }),\n    );\n\n    clock.at += INTERVAL;\n    await b.tags.refresh();\n    expect(b.tags.state([\"posts\"], createdAt())).toBe(\"expired\");\n    expect(b.log.query).toHaveBeenCalledTimes(1);\n    expect(b.markers.read).not.toHaveBeenCalled();\n  });\n\n  it(\"issues no read while the interval has not passed\", async () => {\n    const { clock, b } = instances();\n    // Nothing tracked: nothing to ask.\n    clock.at += INTERVAL;\n    await b.tags.refresh();\n    expect(b.log.query).not.toHaveBeenCalled();\n\n    await b.tags.ensure([\"posts\"]);\n\n    b.markers.read.mockClear();\n    // That refresh still counts: what is tracked since was read, or is new.\n    await b.tags.refresh();\n    expect(b.log.query).not.toHaveBeenCalled();\n\n    clock.at += INTERVAL;\n    await Promise.all([b.tags.refresh(), b.tags.refresh()]);\n    expect(b.log.query).toHaveBeenCalledTimes(1);\n\n    clock.at += INTERVAL - 1;\n    await b.tags.refresh();\n    expect(b.log.query).toHaveBeenCalledTimes(1);\n    expect(b.markers.read).not.toHaveBeenCalled();\n\n    clock.at += 1;\n    await b.tags.refresh();\n    expect(b.log.query).toHaveBeenCalledTimes(2);\n  });\n\n  it(\"applies a row read again inside the lookback only once\", async () => {\n    const { clock, logRows, b } = instances();\n    await b.tags.ensure([\"posts\"]);\n    b.markers.read.mockClear();\n    let reads = 0;\n    const row: RevalidationLogRow = {\n      sk: `${clock.at}#posts`,\n      at: clock.at,\n      tag: \"posts\",\n      get marker() {\n        reads++;\n        return { revalidatedAt: now() };\n      },\n    };\n    // The same row twice in one page, and again on the next query.\n    logRows.push(row, row);\n\n    for (let i = 0; i < 3; i++) {\n      clock.at += INTERVAL;\n      await b.tags.refresh();\n    }\n    expect(b.log.query).toHaveBeenCalledTimes(3);\n    expect(reads).toBe(1);\n    expect(b.tags.state([\"posts\"], createdAt())).toBe(\"expired\");\n  });\n\n  // Replication lag, or a writer whose clock runs behind: the row shows up\n  // after a query that should have seen it, with a sort key before it.\n  it(\"still sees a row that appears up to the lookback late\", async () => {\n    const { clock, logRows, b } = instances();\n    await b.tags.ensure([\"late\", \"too-late\"]);\n    b.markers.read.mockClear();\n    clock.at += INTERVAL;\n    const firstQuery = clock.at;\n    await b.tags.refresh();\n\n    const marker = { revalidatedAt: now() };\n    logRows.push(\n      { sk: \"late\", at: firstQuery - 5000, tag: \"late\", marker },\n      { sk: \"too-late\", at: firstQuery - 5001, tag: \"too-late\", marker },\n    );\n    clock.at += INTERVAL;\n    await b.tags.refresh();\n    expect(b.log.query).toHaveBeenLastCalledWith(firstQuery - 5000);\n    expect(b.tags.state([\"late\"], createdAt())).toBe(\"expired\");\n    // Past the lookback: what the periodic re-read of the markers is for.\n    expect(b.tags.state([\"too-late\"], createdAt())).toBe(\"fresh\");\n  });\n\n  it(\"forgets its tracked markers after a gap the log may not cover, and reads each as it is needed\", async () => {\n    const { clock, a, b } = instances();\n    await b.tags.ensure([\"posts\", \"other\"]);\n    await a.tags.update([\"posts\"], undefined);\n\n    clock.at += MAX_REVALIDATION_LOG_GAP_MS + 1;\n    const gapEnd = clock.at;\n    await b.tags.refresh();\n    // No burst of re-reads, and no query of a log that may have lost rows.\n    expect(b.markers.read).toHaveBeenCalledTimes(1);\n    expect(b.log.query).not.toHaveBeenCalled();\n\n    await b.tags.ensure([\"posts\"]);\n    expect(b.markers.read).toHaveBeenLastCalledWith([\"posts\"]);\n    expect(b.tags.state([\"posts\"], createdAt())).toBe(\"expired\");\n\n    // Then back on the log, from just before the gap ended.\n    clock.at += INTERVAL;\n    await b.tags.refresh();\n    expect(b.log.query).toHaveBeenCalledWith(gapEnd - 5000);\n  });\n\n  // Re-reading every tracked marker at once is ~5,000 RCU at 10,000 tags: more\n  // than the one partition serves in a second.\n  it(\"re-reads each tracked marker once per resync interval, at most 100 a refresh\", async () => {\n    const { clock, b } = instances({ resyncIntervalMs: 10 * INTERVAL });\n    await b.tags.ensure(Array.from({ length: 250 }, (_, i) => `t${i}`));\n    b.markers.read.mockClear();\n    const sizes: number[] = [];\n    for (let i = 1; i <= 14; i++) {\n      clock.at += INTERVAL;\n      b.markers.read.mockClear();\n      await b.tags.refresh();\n      sizes.push(b.markers.read.mock.calls[0]?.[0].length ?? 0);\n    }\n    expect(b.log.query).toHaveBeenCalledTimes(14);\n    // Due at 10 intervals, oldest first, 100 per refresh; then not again.\n    expect(sizes).toEqual([0, 0, 0, 0, 0, 0, 0, 0, 0, 100, 100, 50, 0, 0]);\n    expect(b.markers.read).not.toHaveBeenCalled();\n  });\n\n  // Tags first read together must not come due together every interval.\n  it(\"spreads when each tag comes due over the last quarter of the interval\", async () => {\n    // Due at 10, 8.75 and 7.5 intervals, known in that order: the one due\n    // first is last, behind two that are not due yet.\n    const randoms = [0, 0.5, 1];\n    const { clock, b } = instances({\n      resyncIntervalMs: 10 * INTERVAL,\n      random: () => randoms.shift() ?? 0,\n    });\n    await b.tags.ensure([\"late\", \"middle\", \"early\"]);\n    b.markers.read.mockClear();\n    const readAt: Record<string, number> = {};\n    for (let i = 1; i <= 10; i++) {\n      clock.at += INTERVAL;\n      b.markers.read.mockClear();\n      await b.tags.refresh();\n      for (const tag of b.markers.read.mock.calls[0]?.[0] ?? []) {\n        readAt[tag] ??= i;\n      }\n    }\n    expect(readAt).toEqual({ early: 8, middle: 9, late: 10 });\n  });\n\n  it(\"re-reads a marker it learned of from its own write only once that is due\", async () => {\n    const { clock, a } = instances({ resyncIntervalMs: 10 * INTERVAL });\n    await a.tags.ensure([\"posts\"]);\n    clock.at += 9 * INTERVAL;\n    await a.tags.update([\"posts\"], undefined);\n    clock.at += 2 * INTERVAL;\n    await a.tags.refresh();\n    // Read 11 intervals ago, but written - so known - 2 intervals ago.\n    expect(a.markers.read).toHaveBeenCalledTimes(1);\n  });\n\n  it(\"reads a tag whose first read failed again on the next refresh\", async () => {\n    const error = jest.spyOn(console, \"error\").mockImplementation(() => {});\n    const { clock, a, b } = instances();\n    // Only the marker row has it, so only reading the marker finds it.\n    a.log.put.mockRejectedValueOnce(new Error(\"throttled\"));\n    await a.tags.update([\"posts\"], undefined);\n    b.markers.read.mockRejectedValueOnce(new Error(\"throttled\"));\n    await b.tags.ensure([\"posts\"]);\n    expect(b.tags.state([\"posts\"], createdAt())).toBe(\"fresh\");\n    clock.at += INTERVAL;\n\n    await b.tags.refresh();\n    expect(b.markers.read).toHaveBeenLastCalledWith([\"posts\"]);\n    expect(b.tags.state([\"posts\"], createdAt())).toBe(\"expired\");\n    error.mockRestore();\n  });\n\n  it(\"forgets its tracked markers when the log has more rows than one query reads\", async () => {\n    const { clock, b } = instances();\n    await b.tags.ensure([\"posts\"]);\n    b.log.query.mockResolvedValueOnce({ rows: [], truncated: true });\n    clock.at += INTERVAL;\n    await b.tags.refresh();\n    expect(b.markers.read).toHaveBeenCalledTimes(1);\n    await b.tags.ensure([\"posts\"]);\n    expect(b.markers.read).toHaveBeenCalledTimes(2);\n  });\n\n  // Tracking is per tag, not per entry: storing a new entry must not vouch for\n  // an older one with the same tag. B's log cursor starts after C's\n  // revalidation, so only reading the marker shows it.\n  it(\"still reads a tag's marker after storing an entry with it\", async () => {\n    const { clock, instance, a: c } = instances();\n    const k1CreatedAt = createdAt();\n    await c.tags.update([\"posts\"], undefined);\n    clock.at += 10_000;\n    // Started after the revalidation: its log cursor is past C's row.\n    const b = instance();\n    b.tags.track([\"posts\"]);\n    await b.tags.ensure([\"posts\"]);\n    expect(b.markers.read).toHaveBeenCalledWith([\"posts\"]);\n    expect(b.tags.state([\"posts\"], k1CreatedAt)).toBe(\"expired\");\n  });\n\n  it(\"still reads a tag's marker after storing an entry with it following a forget\", async () => {\n    const { clock, a, b } = instances();\n    await b.tags.ensure([\"posts\"]);\n    const k1CreatedAt = createdAt();\n    // Revalidated while `b` was frozen past what the log covers.\n    clock.at += MAX_REVALIDATION_LOG_GAP_MS + 1;\n    a.log.put.mockRejectedValueOnce(new Error(\"lost\"));\n    const error = jest.spyOn(console, \"error\").mockImplementation(() => {});\n    await a.tags.update([\"posts\"], undefined);\n    error.mockRestore();\n    await b.tags.refresh();\n    b.tags.track([\"posts\"]);\n    await b.tags.ensure([\"posts\"]);\n    expect(b.tags.state([\"posts\"], k1CreatedAt)).toBe(\"expired\");\n  });\n\n  it(\"applies a log row that lands while the tag's first read is in flight\", async () => {\n    const { clock, a, b } = instances();\n    // Something tracked, so the refresh queries the log.\n    await b.tags.ensure([\"other\"]);\n    let answer!: (read: Map<string, TagMarker>) => void;\n    // Answered before the revalidation below, as a read racing it can be.\n    b.markers.read.mockImplementationOnce(\n      () => new Promise((resolve) => (answer = resolve)),\n    );\n    const first = b.tags.ensure([\"posts\"]);\n    await a.tags.update([\"posts\"], undefined);\n    clock.at += INTERVAL;\n    await b.tags.refresh();\n    answer(new Map());\n    await first;\n    expect(b.tags.state([\"posts\"], createdAt())).toBe(\"expired\");\n  });\n\n  it(\"is visible at once on the instance that ran updateTag\", async () => {\n    const { a } = instances();\n    a.tags.track([\"posts\"]);\n    await a.tags.update([\"posts\"], undefined);\n    expect(a.tags.state([\"posts\"], createdAt())).toBe(\"expired\");\n    expect(a.markers.write).toHaveBeenCalledTimes(1);\n    expect(a.log.put).toHaveBeenCalledTimes(1);\n  });\n\n  it(\"keeps its tags through a failed query and asks again next interval\", async () => {\n    const error = jest.spyOn(console, \"error\").mockImplementation(() => {});\n    const { clock, a, b } = instances();\n    await b.tags.ensure([\"posts\"]);\n    b.markers.read.mockClear();\n    await a.tags.update([\"posts\"], undefined);\n    b.log.query.mockRejectedValueOnce(new Error(\"throttled\"));\n\n    clock.at += INTERVAL;\n    const cursor = clock.at - INTERVAL - 5000;\n    await b.tags.refresh();\n    expect(b.tags.state([\"posts\"], createdAt())).toBe(\"fresh\");\n    expect(error).toHaveBeenCalled();\n\n    clock.at += INTERVAL;\n    await b.tags.refresh();\n    // From the same cursor, so nothing written meanwhile is skipped.\n    expect(b.log.query).toHaveBeenLastCalledWith(cursor);\n    expect(b.tags.state([\"posts\"], createdAt())).toBe(\"expired\");\n    expect(b.markers.read).not.toHaveBeenCalled();\n    error.mockRestore();\n  });\n\n  it(\"still writes the marker when the log row fails\", async () => {\n    const error = jest.spyOn(console, \"error\").mockImplementation(() => {});\n    const { a } = instances();\n    a.log.put.mockRejectedValueOnce(new Error(\"throttled\"));\n    await a.tags.update([\"posts\"], undefined);\n    expect(a.markers.rows.get(\"posts\")?.revalidatedAt).toEqual(\n      expect.any(Number),\n    );\n    expect(error).toHaveBeenCalledWith(\n      expect.stringMatching(/revalidation log/),\n      expect.any(Error),\n    );\n    error.mockRestore();\n  });\n});\n\ndescribe(\"EntryLru\", () => {\n  it(\"evicts the least recently used entries past its byte bound\", () => {\n    const lru = new EntryLru(250);\n    lru.set(\"a\", stored(100));\n    lru.set(\"b\", stored(100));\n    lru.get(\"a\");\n    lru.set(\"c\", stored(100));\n    expect(lru.get(\"b\")).toBeUndefined();\n    expect(lru.get(\"a\")).toBeDefined();\n    expect(lru.get(\"c\")).toBeDefined();\n  });\n\n  it(\"does not keep an entry larger than the whole bound\", () => {\n    const lru = new EntryLru(50);\n    lru.set(\"a\", stored(100));\n    expect(lru.size).toBe(0);\n  });\n\n  it(\"accounts for a replaced entry\", () => {\n    const lru = new EntryLru(250);\n    lru.set(\"a\", stored(200));\n    lru.set(\"a\", stored(10));\n    lru.set(\"b\", stored(200));\n    expect(lru.size).toBe(2);\n  });\n});\n\ndescribe(\"entries\", () => {\n  it(\"reads a stream to the end\", async () => {\n    const bytes = await readStream(streamOf(\"ab\", \"cd\"));\n    expect(new TextDecoder().decode(bytes)).toBe(\"abcd\");\n  });\n\n  it(\"rejects a stream that errors part-way\", async () => {\n    const failing = new ReadableStream<Uint8Array>({\n      start(controller) {\n        controller.enqueue(new Uint8Array([1]));\n        controller.error(new Error(\"render failed\"));\n      },\n    });\n    await expect(readStream(failing)).rejects.toThrow(\"render failed\");\n  });\n\n  it(\"hands every reader its own stream\", async () => {\n    const entry: CacheEntry = {\n      value: streamOf(\"payload\"),\n      tags: [\"t\"],\n      stale: 1,\n      timestamp: 2,\n      expire: 3,\n      revalidate: 4,\n    };\n    const kept = await storedEntryOf(Promise.resolve(entry));\n    const first = cacheEntryOf(kept);\n    const second = cacheEntryOf(kept, -1);\n    expect(second.revalidate).toBe(-1);\n    expect(first.tags).toEqual([\"t\"]);\n    expect(new TextDecoder().decode(await readStream(first.value))).toBe(\n      \"payload\",\n    );\n    expect(new TextDecoder().decode(await readStream(second.value))).toBe(\n      \"payload\",\n    );\n  });\n});\n\ndescribe(\"PendingSets\", () => {\n  it(\"holds a get until the set for its key ends\", async () => {\n    const pending = new PendingSets();\n    const done = pending.begin(\"k\");\n    let waited = false;\n    const wait = pending.wait(\"k\").then(() => (waited = true));\n    await Promise.resolve();\n    expect(waited).toBe(false);\n    done();\n    await wait;\n    expect(waited).toBe(true);\n    // Nothing pending: no wait at all.\n    await pending.wait(\"k\");\n    await pending.wait(\"other\");\n  });\n});\n"]}