@wirecat/cli-core 0.463.0 → 0.464.0

package/dist/calendar/sync.js

@@ -1,18 +1,47 @@
 import { CliError } from "@wirecat/cli-base";
+import { runBudget } from "../background/budget.js";
+import { progressLine, progressOf } from "../background/checkpoints.js";
 import { isCliFailure } from "../errors/failures.js";
 const DAY = 86_400_000;
+const isWindow = (value) => typeof value?.from === "number" && typeof value.to === "number";
+const isToken = (value) => value === null || typeof value === "string";
+const roundOf = (value) => {
+    if (value === null || value === undefined)
+        return null;
+    const round = value;
+    if (typeof round.full !== "boolean" ||
+        !isToken(round.from) ||
+        !isWindow(round.window) ||
+        typeof round.startedAt !== "number" ||
+        typeof round.reset !== "boolean" ||
+        !isToken(round.page) ||
+        typeof round.listed !== "boolean" ||
+        !isToken(round.next) ||
+        !Array.isArray(round.series) ||
+        round.series.some((id) => typeof id !== "string"))
+        return undefined;
+    const { full, from, window, startedAt, reset, page, listed, next, series } = round;
+    return { full, from, window, startedAt, reset, page, listed, next, series };
+};
 export const parseCalendarCursor = (value) => {
     if (value === null)
         return null;
     try {
-        const parsed = JSON.parse(value);
-        if (parsed?.v !== 1 ||
-            (parsed.token !== null && typeof parsed.token !== "string") ||
-            typeof parsed.fullAt !== "number" ||
-            typeof parsed.window?.from !== "number" ||
-            typeof parsed.window.to !== "number")
+        const cursor = JSON.parse(value);
+        if ((cursor?.v !== 1 && cursor?.v !== 2) ||
+            !isToken(cursor.token) ||
+            typeof cursor.fullAt !== "number" ||
+            !isWindow(cursor.window))
+            return null;
+        const { token, window, fullAt } = cursor;
+        if (cursor.v === 1)
+            return { v: 2, token, window, fullAt, updatedAt: null, done: 0, round: null };
+        const round = roundOf(cursor.round);
+        if (round === undefined ||
+            (cursor.updatedAt !== null && typeof cursor.updatedAt !== "number") ||
+            typeof cursor.done !== "number")
             return null;
-        return { v: 1, token: parsed.token, window: parsed.window, fullAt: parsed.fullAt };
+        return { v: 2, token, window, fullAt, updatedAt: cursor.updatedAt ?? null, done: cursor.done, round };
     }
     catch {
         return null;
@@ -27,141 +56,278 @@ export const calendarSyncWindow = (now) => {
     const [year, month, date] = [day.getUTCFullYear(), day.getUTCMonth(), day.getUTCDate()];
     return { from: Date.UTC(year - 1, month, date), to: Date.UTC(year, month + 3, date) };
 };
-const roundOf = async (source, store, calendar, cursor, window, now) => {
-    const round = { token: null, saved: 0, removed: 0, series: [] };
-    const seen = new Set();
-    let page;
-    for (;;) {
-        const result = await source.changes(calendar, { cursor, window, ...(page === undefined ? {} : { page }) });
-        if ("reset" in result)
-            return "reset";
-        if (result.entries.length) {
-            await store.saveEntries(calendar.id, result.entries, now);
-            round.saved += result.entries.length;
-            for (const entry of result.entries)
-                if (entry.kind === "series")
-                    round.series.push(entry);
-        }
-        if (result.removed.length)
-            round.removed += await store.removeEntries(calendar.id, result.removed, now);
-        if (result.nextPage === undefined) {
-            round.token = result.cursor ?? null;
-            return round;
-        }
-        if (seen.has(result.nextPage))
-            throw new CliError("invalid_response", `${source.provider} returned the same page twice`);
-        seen.add(result.nextPage);
-        page = result.nextPage;
-    }
-};
-const occurrencesOf = async (source, store, calendar, series, window, now, expand) => {
-    if (source.traits.expands === "in-changes")
-        return 0;
-    let saved = 0;
-    for (const one of series) {
-        if (one.status === "cancelled")
-            continue;
-        const slots = source.traits.expands === "local"
-            ? await expand(one, window)
-            : await source.occurrences(calendar, one.externalId, window);
-        if (!slots.length)
-            continue;
-        await store.saveEntries(calendar.id, slots, now);
-        saved += slots.length;
-    }
-    return saved;
-};
-const syncOne = async (source, store, calendar, { full: asked, window, now, expand }) => {
-    const stored = parseCalendarCursor(await store.cursor(calendar.id));
+const CONTINUE = "run sync again to continue";
+const freshRound = (full, from, window, now, reset = false) => ({
+    full,
+    from: full ? null : from,
+    window,
+    startedAt: now,
+    reset,
+    page: null,
+    listed: false,
+    next: null,
+    series: [],
+});
+/** The round in progress, or the one this run starts: a full one when asked, due, or the only kind the source has. */
+const roundFor = (source, stored, { asked, window, now }) => {
+    if (stored?.round && !asked)
+        return stored.round;
     const windowMoved = stored !== null && (stored.window.from !== window.from || stored.window.to !== window.to);
     // A full round once a day also asks every series for its slots again, which an incremental round does only for
     // the series that changed (foundation §6.2 step 7).
-    let full = asked ||
+    const full = asked ||
         source.traits.fullListOnly ||
         stored === null ||
         stored.token === null ||
         (source.traits.cursorHoldsWindow && windowMoved) ||
         now - stored.fullAt >= DAY;
-    let reset = false;
-    let round = await roundOf(source, store, calendar, full ? null : (stored?.token ?? null), window, now);
-    if (round === "reset") {
-        if (full)
-            throw new CliError("invalid_response", `${source.provider} refused a full list as a dead cursor`);
-        reset = true;
-        full = true;
-        await store.setCursor(calendar.id, null, now);
-        round = await roundOf(source, store, calendar, null, window, now);
-        if (round === "reset")
-            throw new CliError("invalid_response", `${source.provider} refused a full list as a dead cursor`);
-    }
-    const occurrences = await occurrencesOf(source, store, calendar, round.series, window, now, expand);
-    const unseen = full ? await store.markUnseen(calendar.id, now, window, now) : 0;
-    const cursor = { v: 1, token: round.token, window, fullAt: full ? now : (stored?.fullAt ?? now) };
-    await store.setCursor(calendar.id, JSON.stringify(cursor), now);
-    return {
-        calendarId: calendar.id,
-        externalId: calendar.externalId,
-        title: calendar.title,
-        round: full ? "full" : "changes",
-        reset,
-        saved: round.saved,
-        removed: round.removed,
-        occurrences,
-        unseen,
+    return freshRound(full, stored?.token ?? null, window, now);
+};
+const deadList = (provider) => new CliError("invalid_response", `${provider} refused a full list as a dead cursor`);
+/**
+ * One calendar's round, saved after every page and every series, so a stop — the budget, a cancel, a kill — loses
+ * at most the step it was on. Returns why it stopped, or `null` when the round finished.
+ */
+const syncOne = async ({ source, store, calendar, window, now, expand, budget, signal, moved }, stored, asked, result) => {
+    let cursor = stored ?? {
+        v: 2,
+        token: null,
+        window,
+        fullAt: 0,
+        updatedAt: null,
+        done: 0,
+        round: null,
+    };
+    let round = roundFor(source, stored, { asked, window, now });
+    if (round !== stored?.round)
+        cursor = { ...cursor, done: 0 };
+    const show = () => Object.assign(result, { round: round.full ? "full" : "changes", reset: round.reset });
+    show();
+    const save = async (finished) => {
+        cursor = { ...cursor, round, updatedAt: now, ...finished };
+        await store.setCursor(calendar.id, JSON.stringify(cursor), now);
     };
+    const saveSlots = async (slots) => {
+        if (!slots.length)
+            return;
+        await store.saveEntries(calendar.id, slots, now);
+        result.occurrences += slots.length;
+        cursor = { ...cursor, done: cursor.done + slots.length };
+    };
+    const stop = () => budget.take();
+    let restarted = false;
+    const seen = new Set();
+    while (!round.listed) {
+        const why = stop();
+        if (why)
+            return why;
+        const page = await source.changes(calendar, {
+            cursor: round.from,
+            window: round.window,
+            ...(round.page === null ? {} : { page: round.page }),
+        });
+        if ("reset" in page) {
+            // A page token held since an earlier run may have expired; the provider says how long none of them last.
+            if (round.page !== null && !restarted) {
+                restarted = true;
+                round = freshRound(round.full, round.from, round.window, now, round.reset);
+            }
+            else if (round.full)
+                throw deadList(source.provider);
+            else {
+                round = freshRound(true, null, window, now, true);
+                cursor = { ...cursor, token: null };
+            }
+            cursor = { ...cursor, done: 0 };
+            show();
+            await save();
+            continue;
+        }
+        if (signal?.aborted)
+            return "cancelled";
+        if (page.entries.length) {
+            await store.saveEntries(calendar.id, page.entries, now);
+            result.saved += page.entries.length;
+            cursor = { ...cursor, done: cursor.done + page.entries.length };
+            for (const entry of page.entries) {
+                if (entry.kind !== "series" || entry.status === "cancelled")
+                    continue;
+                if (source.traits.expands === "local")
+                    await saveSlots(await expand(entry, round.window));
+                else if (source.traits.expands === "on-request" && !round.series.includes(entry.externalId))
+                    round = { ...round, series: [...round.series, entry.externalId] };
+            }
+        }
+        if (page.removed.length)
+            result.removed += await store.removeEntries(calendar.id, page.removed, now);
+        if (page.nextPage === undefined)
+            round = { ...round, page: null, listed: true, next: page.cursor ?? null };
+        else {
+            if (seen.has(page.nextPage))
+                throw new CliError("invalid_response", `${source.provider} returned the same page twice`);
+            seen.add(page.nextPage);
+            round = { ...round, page: page.nextPage };
+        }
+        await save();
+        moved();
+    }
+    const occurrences = source.occurrences;
+    for (const series of round.series) {
+        const why = stop();
+        if (why)
+            return why;
+        const slots = await occurrences.call(source, calendar, series, round.window);
+        if (signal?.aborted)
+            return "cancelled";
+        await saveSlots(slots);
+        round = { ...round, series: round.series.filter((one) => one !== series) };
+        await save();
+        moved();
+    }
+    if (signal?.aborted)
+        return "cancelled";
+    result.unseen = round.full ? await store.markUnseen(calendar.id, round.startedAt, round.window, now) : 0;
+    await save({
+        token: round.next,
+        window: round.window,
+        fullAt: round.full ? round.startedAt : cursor.fullAt,
+        round: null,
+    });
+    result.state = "complete";
+    return null;
 };
 /**
  * Brings one calendar account's synced calendars up to date (foundation §6.2): the calendar list first, then for
  * each synced calendar its changes since the cursor, or a full list of the window, then the slots of the series that
- * changed. Each calendar's cursor is saved last, only when all of it saved; a calendar that fails keeps its old one
- * and the others go on.
+ * changed. Every page is saved as it comes, with the round's position in the cursor, so a run the budget stops, or
+ * one that fails, goes on from there next time. Calendars with a round in progress go first, then the longest unsynced.
  */
 export const syncCalendars = async (source, store, options) => {
     const now = options.now ?? Date.now();
     const window = options.window ?? calendarSyncWindow(now);
+    const budget = options.budget ?? runBudget();
     if (source.traits.expands === "local" && !options.expand)
         throw new CliError("configuration_error", `${source.provider} needs a local expander for its repeating events`);
     if (source.traits.expands === "on-request" && !source.occurrences)
         throw new CliError("configuration_error", `${source.provider} expands on request but has no occurrences()`);
-    const listed = await store.saveCalendars(options.accountId, await source.calendars(), now);
     const report = {
         provider: source.provider,
         accountId: options.accountId,
         window,
-        calendars: listed.length,
+        calendars: 0,
         synced: [],
         notSynced: [],
         complete: true,
+        state: "complete",
+        progress: { calendars: 0, calendarsDone: 0, requests: 0, saved: 0, steps: 0 },
     };
+    const finish = (stopped) => {
+        report.progress = {
+            calendars: report.synced.length,
+            calendarsDone: report.synced.filter((one) => one.state === "complete").length,
+            requests: budget.used,
+            saved: report.synced.reduce((sum, one) => sum + one.saved + one.occurrences, 0),
+            steps,
+        };
+        report.complete = report.synced.every((one) => one.state === "complete" && one.error === undefined);
+        report.state = report.complete && stopped === null ? "complete" : "partial";
+        if (stopped)
+            report.stopped = stopped;
+        if (report.state === "partial") {
+            report.complete = false;
+            report.hint = CONTINUE;
+        }
+        return report;
+    };
+    let steps = 0;
+    let stopped = budget.take();
+    if (stopped)
+        return finish(stopped);
+    const listed = await store.saveCalendars(options.accountId, await source.calendars(), now);
+    report.calendars = listed.length;
+    const synced = [];
     for (const calendar of listed) {
-        if (!calendar.synced) {
+        if (calendar.synced)
+            synced.push({ calendar, stored: parseCalendarCursor(await store.cursor(calendar.id)) });
+        else
             report.notSynced.push({ calendarId: calendar.id, externalId: calendar.externalId, title: calendar.title });
+    }
+    const rank = ({ stored }) => [stored?.round && !options.full ? 0 : 1, stored?.updatedAt ?? 0];
+    synced.sort((a, b) => {
+        const [x, y] = [rank(a), rank(b)];
+        return x[0] - y[0] || x[1] - y[1];
+    });
+    for (const { calendar, stored } of synced) {
+        const asked = options.full === true;
+        const planned = roundFor(source, stored, { asked, window, now });
+        const result = {
+            calendarId: calendar.id,
+            externalId: calendar.externalId,
+            title: calendar.title,
+            round: planned.full ? "full" : "changes",
+            reset: planned.reset,
+            state: "partial",
+            saved: 0,
+            removed: 0,
+            occurrences: 0,
+            unseen: 0,
+        };
+        report.synced.push(result);
+        if (stopped)
             continue;
-        }
         try {
-            report.synced.push(await syncOne(source, store, calendar, {
-                full: options.full === true,
+            stopped = await syncOne({
+                source,
+                store,
+                calendar,
                 window,
                 now,
-                ...(options.expand ? { expand: options.expand } : {}),
-            }));
+                expand: options.expand,
+                budget,
+                signal: options.signal,
+                moved: () => {
+                    steps += 1;
+                },
+            }, stored, asked, result);
         }
         catch (error) {
-            report.complete = false;
-            report.synced.push({
-                calendarId: calendar.id,
-                externalId: calendar.externalId,
-                title: calendar.title,
-                round: options.full ? "full" : "changes",
-                reset: false,
-                saved: 0,
-                removed: 0,
-                occurrences: 0,
-                unseen: 0,
-                // An adapter's own failure says what went wrong; anything else may carry a request URL with a token in it.
-                error: isCliFailure(error) ? error.message : "the calendar could not be synced",
-            });
+            if (options.signal?.aborted) {
+                stopped = "cancelled";
+                continue;
+            }
+            // An adapter's own failure says what went wrong; anything else may carry a request URL with a token in it.
+            result.error = isCliFailure(error) ? error.message : "the calendar could not be synced";
         }
     }
-    return report;
+    return finish(stopped);
+};
+/**
+ * Each synced calendar's sync in the WC-LIFE-14 shape: `done` counts the entries its current or last round saved,
+ * `total` is null since no provider says how many a window holds, and `cursor_age_ms` growing on a `partial` one
+ * means nothing is moving it.
+ */
+export const calendarStatus = async (store, accountId, { profile, now }) => {
+    const items = [];
+    for (const calendar of await store.calendars(accountId)) {
+        if (!calendar.synced || calendar.deletedAt !== null)
+            continue;
+        const cursor = parseCalendarCursor(await store.cursor(calendar.id));
+        const progress = progressOf({
+            job: `calendar ${calendar.id}`,
+            profile,
+            done: cursor?.done ?? 0,
+            complete: cursor !== null && cursor.round === null,
+            ...(cursor?.updatedAt == null ? {} : { updatedAt: new Date(cursor.updatedAt).toISOString() }),
+            now: new Date(now),
+        });
+        items.push({
+            calendar_id: String(calendar.id),
+            external_id: calendar.externalId,
+            title: calendar.title,
+            round: cursor?.round ? (cursor.round.full ? "full" : "changes") : null,
+            ...progress,
+            line: progressLine(progress),
+        });
+    }
+    return { items, page: 1, limit: Math.max(1, items.length), hasMore: false };
 };

package/dist/calendar/testing/source-contract.js

@@ -167,5 +167,19 @@ export const calendarSourceContract = (make) => {
             if (fixture.movedOut)
                 assert.ok(!removed.includes(fixture.movedOut), "an entry outside the window is no removal");
         }),
+        test("free/busy answers each calendar and person once, inside the window; an unknown person is an error", async ({ source, window, }) => {
+            if (!source.freeBusy)
+                return;
+            const [first] = await source.calendars();
+            const calendar = first.externalId;
+            const nobody = "nobody@example.invalid";
+            const answer = await source.freeBusy({ calendars: [calendar], people: [nobody], window });
+            assert.deepEqual(answer.map(({ id }) => id).sort(), [calendar, nobody].sort());
+            for (const { id, busy } of answer)
+                for (const one of busy)
+                    assert.ok(one.from < one.to && one.from >= window.from && one.to <= window.to, `${id}: ${JSON.stringify(one)}`);
+            const unknown = answer.find(({ id }) => id === nobody);
+            assert.ok(unknown?.error, "a person the provider cannot see is not free");
+        }),
     ];
 };

package/dist/calendar/testing/source.d.ts

@@ -23,8 +23,14 @@ export interface FakeCalendarSource extends CalendarSource {
     setOccurrences(seriesExternalId: string, entries: EntryInput[]): void;
     /** Every cursor given out so far is dead: the next round with one gets `{ reset: true }`. */
     expireCursors(): void;
+    /** Every page token given out so far is dead, as one held too long: asking for it gets `{ reset: true }`. */
+    expirePages(): void;
     /** The `changes()` call after this many more succeeds throws once. */
     failAfter(calls: number): void;
+    /** A person's busy times, or the provider's refusal to say; a person never set is `notFound`. */
+    setBusy(person: string, busy: SyncWindow[] | {
+        error: string;
+    }): void;
     readonly calls: {
         changes: {
             calendar: string;

package/dist/calendar/testing/source.js

@@ -19,8 +19,10 @@ export const fakeCalendarSource = (options = {}) => {
     const held = new Map();
     const log = [];
     const occurrences = new Map();
+    const people = new Map();
     let version = 0;
     let deadBefore = 0;
+    let pages = 0;
     let failIn = null;
     const calls = { changes: [], occurrences: [] };
     const of = (calendar) => {
@@ -62,13 +64,16 @@ export const fakeCalendarSource = (options = {}) => {
             }
             if (cursor === null || traits.fullListOnly)
                 entries = entries.filter((entry) => inside(entry, window));
-            const from = page === undefined ? 0 : Number(page);
+            const [, generation, offset] = /^p(\d+):(\d+)$/u.exec(page ?? `p${pages}:0`) ?? [];
+            if (Number(generation) !== pages)
+                return { reset: true };
+            const from = Number(offset);
             const slice = entries.slice(from, from + pageSize);
             const more = from + pageSize < entries.length;
             return {
                 entries: slice.map((entry) => structuredClone(entry)),
                 removed: from === 0 ? removed : [],
-                ...(more ? { nextPage: String(from + pageSize) } : { cursor: token(window) }),
+                ...(more ? { nextPage: `p${pages}:${from + pageSize}` } : { cursor: token(window) }),
             };
         },
         ...(traits.expands === "on-request"
@@ -81,6 +86,26 @@ export const fakeCalendarSource = (options = {}) => {
                 },
             }
             : {}),
+        async freeBusy({ calendars: asked, people: persons, window }) {
+            const taken = (busy) => busy
+                .filter(({ from, to }) => from < window.to && to > window.from)
+                .map(({ from, to }) => ({ from: Math.max(from, window.from), to: Math.min(to, window.to) }));
+            return [
+                ...asked.map((id) => ({
+                    id,
+                    busy: taken([...of(id).values()]
+                        .filter((entry) => entry.status !== "cancelled" && entry.transparency !== "transparent")
+                        .flatMap(({ startsAt, endsAt }) => startsAt == null || endsAt == null ? [] : [{ from: startsAt, to: endsAt }])),
+                })),
+                ...persons.map((id) => {
+                    const busy = people.get(id) ?? { error: "notFound" };
+                    return Array.isArray(busy) ? { id, busy: taken(busy) } : { id, busy: [], error: busy.error };
+                }),
+            ];
+        },
+        setBusy(person, busy) {
+            people.set(person, busy);
+        },
         put(calendar, ...entries) {
             for (const entry of entries) {
                 of(calendar).set(entry.externalId, structuredClone(entry));
@@ -100,6 +125,9 @@ export const fakeCalendarSource = (options = {}) => {
         setOccurrences(seriesExternalId, entries) {
             occurrences.set(seriesExternalId, entries);
         },
+        expirePages() {
+            pages += 1;
+        },
         expireCursors() {
             deadBefore = ++version;
         },

package/dist/calendar/testing/sync-contract.d.ts

@@ -10,6 +10,7 @@ export declare const CALENDAR_TRAIT_COMBINATIONS: readonly CalendarSourceTraits[
 /**
  * The sync engine over `fakeCalendarSource`, once for each trait combination: changes after a cursor, removal by id,
  * a dead cursor, a window that moved, each way of expanding a series and a slot cancelled later, a failed page, an
- * unsynced calendar and a full list. Run it over the store the CLI uses.
+ * unsynced calendar, a full list, a run the budget or a near deadline stops and the rerun that finishes it, and a page
+ * token that expired between runs. Run it over the store the CLI uses.
  */
 export declare const calendarSyncContract: (make: () => CalendarSyncFixture | Promise<CalendarSyncFixture>) => ContractCase[];

package/dist/calendar/testing/sync-contract.js

@@ -1,4 +1,5 @@
 import assert from "node:assert/strict";
+import { runBudget } from "../../background/budget.js";
 import { parseCalendarCursor, syncCalendars } from "../sync.js";
 import { fakeCalendarSource } from "./source.js";
 /** Every combination of the source traits: the engine must handle each. */
@@ -51,7 +52,8 @@ const nameOf = ({ expands, cursorHoldsWindow, fullListOnly }) => `[expands ${exp
 /**
  * The sync engine over `fakeCalendarSource`, once for each trait combination: changes after a cursor, removal by id,
  * a dead cursor, a window that moved, each way of expanding a series and a slot cancelled later, a failed page, an
- * unsynced calendar and a full list. Run it over the store the CLI uses.
+ * unsynced calendar, a full list, a run the budget or a near deadline stops and the rerun that finishes it, and a page
+ * token that expired between runs. Run it over the store the CLI uses.
  */
 export const calendarSyncContract = (make) => CALENDAR_TRAIT_COMBINATIONS.flatMap((traits) => {
     const test = (name, check, options = {}) => ({
@@ -159,21 +161,94 @@ export const calendarSyncContract = (make) => CALENDAR_TRAIT_COMBINATIONS.flatMa
             const event = await store.event(entry?.eventId);
             assert.equal(event?.event.status, "cancelled");
         }),
-        test("a failed page keeps the old cursor, and the next run reads the same changes again", async ({ store, source, sync }) => {
+        test("a failed page keeps the pages before it, and the next run goes on from the failed one", async ({ store, source, sync }) => {
             source.put("primary", single("e1"));
             const first = await sync(NOW);
             const calendarId = first.synced[0]?.calendarId;
-            const before = await store.cursor(calendarId);
             source.put("primary", single("e2"), single("e3"));
             source.failAfter(1);
             const failed = await sync(NOW + HOUR);
-            assert.equal(failed.complete, false);
+            assert.deepEqual([failed.complete, failed.state], [false, "partial"]);
             assert.match(failed.synced[0]?.error ?? "", /example provider failed/u);
-            assert.equal(await store.cursor(calendarId), before);
+            const held = (await cursorOf(store, calendarId))?.round;
+            assert.ok(held?.page);
             const again = await sync(NOW + 2 * HOUR);
             assert.equal(again.complete, true);
+            assert.equal(source.calls.changes.at(-2)?.page, held.page);
             assert.deepEqual([...(await entriesOf(store)).keys()].sort(), ["e1", "e2", "e3"]);
         }, { pageSize: 1 }),
+        test("a run the budget stops goes on next time and ends with the store one whole run gives", async ({ store, source, sync }) => {
+            const fill = (one) => {
+                one.put("primary", single("e0"));
+                return one;
+            };
+            const grow = (one) => {
+                one.drop("primary", "e0");
+                one.put("primary", single("e1"), single("e2", AT + HOUR), single("e3", AT + 2 * HOUR));
+                const slots = [slot("s", AT), slot("s", AT + DAY), slot("s", AT + 2 * DAY)];
+                if (traits.expands === "in-changes")
+                    one.put("primary", seriesOf("s"), ...slots);
+                else
+                    one.put("primary", seriesOf("s"));
+                if (traits.expands === "on-request")
+                    one.setOccurrences("s", slots);
+            };
+            const whole = await make();
+            const reference = fill(fakeCalendarSource({ pageSize: 1, traits }));
+            const expand = traits.expands === "local" ? { expand: exampleExpander } : {};
+            const once = (at, extra = {}) => syncCalendars(reference, whole.store, { accountId: whole.accountId, now: at, ...expand, ...extra });
+            await once(NOW);
+            grow(reference);
+            assert.equal((await once(NOW + HOUR, { full: true })).state, "complete");
+            fill(source);
+            await sync(NOW);
+            grow(source);
+            const first = await sync(NOW + HOUR, { full: true, budget: runBudget({ requests: 2 }) });
+            assert.deepEqual([first.state, first.stopped, first.hint], ["partial", "requests", "run sync again to continue"]);
+            assert.equal(first.synced[0]?.state, "partial");
+            let runs = 1;
+            let last = first;
+            while (last.state === "partial" && runs < 30) {
+                runs += 1;
+                last = await sync(NOW + HOUR + runs * 60_000, { budget: runBudget({ requests: 2 }) });
+                if (last.state === "partial")
+                    assert.equal(last.complete, false);
+            }
+            assert.equal(last.state, "complete");
+            assert.ok(runs > 2);
+            const shape = async (one) => [...(await entriesOf(one)).values()]
+                .map(({ externalId, status, deletedAt }) => `${externalId} ${status} ${deletedAt === null}`)
+                .sort();
+            assert.deepEqual(await shape(store), await shape(whole.store));
+            const entries = await entriesOf(store);
+            assert.equal(entries.get("e1")?.deletedAt, null);
+            assert.notEqual(entries.get("e0")?.deletedAt ?? null, null);
+        }, { pageSize: 1 }),
+        test("a deadline close by stops the run before its next request", async ({ source, sync }) => {
+            source.put("primary", single("e1"), single("e2"));
+            const endsAt = NOW + 30_000;
+            const clock = [NOW, NOW + 1_000, endsAt - 2_000];
+            const budget = runBudget({ deadline: { endsAt, ms: 30_000 }, now: () => clock.shift() ?? endsAt });
+            const stopped = await sync(NOW, { budget });
+            assert.deepEqual([stopped.state, stopped.stopped, budget.used], ["partial", "deadline", 2]);
+            assert.equal(stopped.synced[0]?.saved, 1);
+            const again = await sync(NOW + HOUR);
+            assert.equal(again.state, "complete");
+            assert.equal(again.synced[0]?.saved, 1);
+        }, { pageSize: 1 }),
+        test("a page token that expired since the last run starts that calendar's round over, once", async ({ store, source, sync }) => {
+            source.put("primary", single("e1"), single("e2"), single("e3"));
+            const first = await sync(NOW, { budget: runBudget({ requests: 2 }) });
+            assert.equal(first.state, "partial");
+            source.expirePages();
+            const again = await sync(NOW + HOUR);
+            assert.equal(again.state, "complete");
+            const calls = source.calls.changes.slice(1);
+            assert.ok(calls[0]?.page);
+            assert.equal(calls[1]?.page, undefined);
+            assert.deepEqual([...(await entriesOf(store)).keys()].sort(), ["e1", "e2", "e3"]);
+            assert.equal((await cursorOf(store, again.synced[0]?.calendarId))?.round, null);
+        }, { pageSize: 1 }),
         test("a calendar the owner does not sync is listed and never read", async ({ source, sync }) => {
             const report = await sync(NOW);
             assert.deepEqual(report.notSynced.map(({ externalId }) => externalId), ["team"]);