@wirecat/cli-core 0.487.0 → 0.489.0

package/dist/calendar/sync.js

@@ -3,6 +3,14 @@ import { runBudget } from "../background/budget.js";
 import { progressLine, progressOf } from "../background/checkpoints.js";
 import { isCliFailure } from "../errors/failures.js";
 const DAY = 86_400_000;
+/**
+ * How far the window's far end may move before a full round asks every series for its slots again. In between it asks
+ * only the series that changed, so a series that did not change lacks slots up to this far behind the window's end.
+ */
+const SLOTS_EVERY = 7 * DAY;
+/** Series whose slots one transaction saves: a short one, so another process waits for the lock briefly. */
+const BATCH_SERIES = 50;
+const BATCH_SLOTS = 250;
 const isWindow = (value) => typeof value?.from === "number" && typeof value.to === "number";
 const isToken = (value) => value === null || typeof value === "string";
 const roundOf = (value) => {
@@ -18,10 +26,22 @@ const roundOf = (value) => {
         typeof round.listed !== "boolean" ||
         !isToken(round.next) ||
         !Array.isArray(round.series) ||
-        round.series.some((id) => typeof id !== "string"))
+        round.series.some((id) => typeof id !== "string") ||
+        (round.everySeries !== undefined && typeof round.everySeries !== "boolean"))
         return undefined;
-    const { full, from, window, startedAt, reset, page, listed, next, series } = round;
-    return { full, from, window, startedAt, reset, page, listed, next, series };
+    const { full, from, window, startedAt, reset, page, listed, next, series, everySeries } = round;
+    return {
+        full,
+        from,
+        window,
+        startedAt,
+        reset,
+        page,
+        listed,
+        next,
+        series,
+        ...(everySeries === false ? { everySeries } : {}),
+    };
 };
 export const parseCalendarCursor = (value) => {
     if (value === null)
@@ -41,7 +61,17 @@ export const parseCalendarCursor = (value) => {
             (cursor.updatedAt !== null && typeof cursor.updatedAt !== "number") ||
             typeof cursor.done !== "number")
             return null;
-        return { v: 2, token, window, fullAt, updatedAt: cursor.updatedAt ?? null, done: cursor.done, round };
+        return {
+            v: 2,
+            token,
+            window,
+            fullAt,
+            updatedAt: cursor.updatedAt ?? null,
+            done: cursor.done,
+            round,
+            ...(cursor.restored === true ? { restored: true } : {}),
+            ...(typeof cursor.slotsTo === "number" ? { slotsTo: cursor.slotsTo } : {}),
+        };
     }
     catch {
         return null;
@@ -57,7 +87,7 @@ export const calendarSyncWindow = (now) => {
     return { from: Date.UTC(year - 1, month, date), to: Date.UTC(year, month + 3, date) };
 };
 const CONTINUE = "run sync again to continue";
-const freshRound = (full, from, window, now, reset = false) => ({
+const freshRound = (full, from, window, now, reset = false, everySeries = true) => ({
     full,
     from: full ? null : from,
     window,
@@ -67,28 +97,29 @@ const freshRound = (full, from, window, now, reset = false) => ({
     listed: false,
     next: null,
     series: [],
+    ...(everySeries ? {} : { everySeries }),
 });
-/** 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)
+/** The round in progress, or the one this run starts: a full one when due or the only kind the source has. */
+const roundFor = (source, stored, { window, now }) => {
+    if (stored?.round)
         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).
-    const full = asked ||
-        source.traits.fullListOnly ||
+    const full = source.traits.fullListOnly ||
         stored === null ||
         stored.token === null ||
         (source.traits.cursorHoldsWindow && windowMoved) ||
         now - stored.fullAt >= DAY;
-    return freshRound(full, stored?.token ?? null, window, now);
+    // The daily full round asks only the series that changed, and every series once the window's end moved on far
+    // enough that their new slots matter (foundation §6.2 step 7).
+    const everySeries = !full || stored?.slotsTo === undefined || window.to - stored.slotsTo >= SLOTS_EVERY;
+    return freshRound(full, stored?.token ?? null, window, now, false, everySeries);
 };
 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) => {
+const syncOne = async ({ source, store, calendar, window, now, expand, budget, signal, moved }, stored, result) => {
     let cursor = stored ?? {
         v: 2,
         token: null,
@@ -97,8 +128,14 @@ const syncOne = async ({ source, store, calendar, window, now, expand, budget, s
         updatedAt: null,
         done: 0,
         round: null,
+        restored: true,
     };
-    let round = roundFor(source, stored, { asked, window, now });
+    if (stored !== null && !stored.restored) {
+        // Up to 0.488.0 a full list also marked entries outside its window, which no later list returns to unmark.
+        await store.restoreUnseen(calendar.id, calendarSyncWindow, now);
+        cursor = { ...cursor, restored: true };
+    }
+    let round = roundFor(source, stored, { window, now });
     if (round !== stored?.round)
         cursor = { ...cursor, done: 0 };
     const show = () => Object.assign(result, { round: round.full ? "full" : "changes", reset: round.reset });
@@ -107,12 +144,26 @@ const syncOne = async ({ source, store, calendar, window, now, expand, budget, s
         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 };
+    /**
+     * Series' slots and the cursor in one transaction. A series' slots replace its stored ones in the window: a slot it
+     * no longer has, moved or dropped, is cancelled; one kept as stored counts as seen by this round.
+     */
+    const commit = async (groups) => {
+        const count = groups.reduce((sum, { slots }) => sum + (slots?.length ?? 0), 0);
+        cursor = { ...cursor, round, updatedAt: now, done: cursor.done + count };
+        const { saved, removed } = await store.saveSlots(calendar.id, groups, round.window, JSON.stringify(cursor), now);
+        result.occurrences += saved;
+        result.removed += removed;
+    };
+    /** A series this full round need not ask: the same version as stored, with its slots in the window stored. */
+    const unchanged = async (entry) => {
+        if (!round.full || round.everySeries !== false || !entry.etag)
+            return false;
+        const held = await store.entry(calendar.id, entry.externalId);
+        return (held !== null &&
+            held.etag === entry.etag &&
+            held.deletedAt === null &&
+            (await store.slotsOf(calendar.id, entry.externalId, round.window)).length > 0);
     };
     const stop = () => budget.take();
     let restarted = false;
@@ -130,7 +181,7 @@ const syncOne = async ({ source, store, calendar, window, now, expand, budget, s
             // 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);
+                round = freshRound(round.full, round.from, round.window, now, round.reset, round.everySeries !== false);
             }
             else if (round.full)
                 throw deadList(source.provider);
@@ -145,15 +196,22 @@ const syncOne = async ({ source, store, calendar, window, now, expand, budget, s
         }
         if (signal?.aborted)
             return "cancelled";
+        const groups = [];
+        const listed = page.entries.filter((entry) => entry.kind === "series" && entry.status !== "cancelled");
+        const kept = new Set();
+        if (source.traits.expands === "on-request")
+            for (const entry of listed)
+                if (await unchanged(entry))
+                    kept.add(entry.externalId);
         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;
+            for (const entry of listed) {
                 if (source.traits.expands === "local")
-                    await saveSlots(await expand(entry, round.window));
+                    groups.push({ series: entry.externalId, slots: await expand(entry, round.window) });
+                else if (kept.has(entry.externalId))
+                    groups.push({ series: entry.externalId, slots: null });
                 else if (source.traits.expands === "on-request" && !round.series.includes(entry.externalId))
                     round = { ...round, series: [...round.series, entry.externalId] };
             }
@@ -168,21 +226,37 @@ const syncOne = async ({ source, store, calendar, window, now, expand, budget, s
             seen.add(page.nextPage);
             round = { ...round, page: page.nextPage };
         }
-        await save();
+        await commit(groups);
         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();
+    let batch = [];
+    // Whatever stops the loop — the budget, a cancel, a failed request — the series asked so far are kept.
+    const flush = async () => {
+        if (!batch.length)
+            return;
+        const done = new Set(batch.map(({ series }) => series));
+        round = { ...round, series: round.series.filter((one) => !done.has(one)) };
+        const groups = batch;
+        batch = [];
+        await commit(groups);
+    };
+    try {
+        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";
+            batch.push({ series, slots });
+            moved();
+            if (batch.length >= BATCH_SERIES || batch.reduce((sum, one) => sum + (one.slots?.length ?? 0), 0) >= BATCH_SLOTS)
+                await flush();
+        }
+    }
+    finally {
+        await flush();
     }
     if (signal?.aborted)
         return "cancelled";
@@ -192,6 +266,7 @@ const syncOne = async ({ source, store, calendar, window, now, expand, budget, s
         window: round.window,
         fullAt: round.full ? round.startedAt : cursor.fullAt,
         round: null,
+        ...(round.full && round.everySeries !== false ? { slotsTo: round.window.to } : {}),
     });
     result.state = "complete";
     return null;
@@ -257,9 +332,16 @@ export const syncCalendars = async (source, store, options) => {
         const [x, y] = [rank(a), rank(b)];
         return x[0] - y[0] || x[1] - y[1];
     });
+    if (options.full)
+        // Every calendar keeps the rescan as its round in progress, so one this run does not reach starts it next time.
+        for (const one of synced) {
+            const round = freshRound(true, null, window, now);
+            const fresh = { v: 2, token: null, window, fullAt: 0, updatedAt: null, restored: true };
+            one.stored = { ...(one.stored ?? fresh), done: 0, round };
+            await store.setCursor(one.calendar.id, JSON.stringify(one.stored), now);
+        }
     for (const { calendar, stored } of synced) {
-        const asked = options.full === true;
-        const planned = roundFor(source, stored, { asked, window, now });
+        const planned = roundFor(source, stored, { window, now });
         const result = {
             calendarId: calendar.id,
             externalId: calendar.externalId,
@@ -288,7 +370,7 @@ export const syncCalendars = async (source, store, options) => {
                 moved: () => {
                     steps += 1;
                 },
-            }, stored, asked, result);
+            }, stored, result);
         }
         catch (error) {
             if (options.signal?.aborted) {

package/dist/calendar/testing/memory.js

@@ -1,5 +1,5 @@
 import { CliError } from "@wirecat/cli-base";
-import { calendarText, joinKeyOf, joinUrlWithoutQuery } from "../../meetings/index.js";
+import { calendarText, entryInWindow, eventChange, joinKeyOf, joinUrlWithoutQuery, } from "../../meetings/index.js";
 const TRACKED = ["title", "startsAt", "endsAt", "location", "status", "recurrence", "recurrenceEndsAt"];
 const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
 /**
@@ -77,6 +77,7 @@ export const memoryEventStore = () => {
                     id: nextId++,
                     linkableType: "calendar_entry",
                     linkableId: entry.id,
+                    calendarId: entry.calendarId,
                     entityType: entity,
                     candidates: ids,
                     reason: "ical-uid",
@@ -229,6 +230,7 @@ export const memoryEventStore = () => {
             recurrence: input.recurrence ?? null,
             recurrenceEndsAt: input.recurrenceEndsAt ?? null,
             eventType: input.eventType ?? null,
+            transparency: input.transparency ?? null,
             ownResponse: input.ownResponse ?? null,
             organizerIdentityId: input.organizer ? contactOf(input.organizer.email) : null,
             joinUrl,
@@ -248,7 +250,7 @@ export const memoryEventStore = () => {
             Object.assign(found, values);
         }
         else {
-            entry = { id: nextId++, calendarId, eventId: null, eventSeriesId: null, ...values };
+            entry = { id: nextId++, calendarId, eventId: null, eventSeriesId: null, createdAt: now, ...values };
             entries.push(entry);
         }
         const id = entry.id;
@@ -302,7 +304,7 @@ export const memoryEventStore = () => {
             throw new CliError("not_found", `no calendar entry ${id} in the local store`);
         return entry;
     };
-    return {
+    const store = {
         async saveCalendars(accountId, list, now) {
             return list.map((one) => {
                 let calendar = calendars.find((held) => held.accountId === accountId && held.externalId === one.externalId);
@@ -377,9 +379,7 @@ export const memoryEventStore = () => {
             const marked = entries.filter((one) => one.calendarId === calendarId &&
                 one.deletedAt === null &&
                 (one.seenAt === null || one.seenAt < seenBefore) &&
-                (one.kind !== "occurrence" ||
-                    one.exception ||
-                    (one.originalStartsAt !== null && one.originalStartsAt >= window.from && one.originalStartsAt < window.to)));
+                entryInWindow(one, window));
             for (const one of marked)
                 Object.assign(one, { deletedAt: now, updatedAt: now });
             for (const eventId of new Set(marked.map(({ eventId }) => eventId)))
@@ -387,10 +387,56 @@ export const memoryEventStore = () => {
                     refreshEvent(eventId, now);
             return marked.length;
         },
+        async restoreUnseen(calendarId, windowAt, now) {
+            const restored = entries.filter((one) => one.calendarId === calendarId && one.deletedAt !== null && !entryInWindow(one, windowAt(one.deletedAt)));
+            for (const one of restored)
+                Object.assign(one, { deletedAt: null, updatedAt: now });
+            refreshAround(restored.map(({ id }) => id), now);
+            return restored.length;
+        },
         async entry(calendarId, externalId) {
             const found = entries.find((one) => one.calendarId === calendarId && one.externalId === externalId);
             return found ? stored(found) : null;
         },
+        async slotsOf(calendarId, seriesExternalId, window) {
+            return entries
+                .filter((one) => one.calendarId === calendarId &&
+                one.kind === "occurrence" &&
+                one.seriesExternalId === seriesExternalId &&
+                one.originalStartsAt !== null &&
+                one.originalStartsAt >= window.from &&
+                one.originalStartsAt < window.to &&
+                one.deletedAt === null)
+                .sort((a, b) => a.originalStartsAt - b.originalStartsAt)
+                .map(stored);
+        },
+        async saveSlots(calendarId, groups, window, cursor, now) {
+            let [saved, removed] = [0, 0];
+            for (const { series, slots } of groups) {
+                const held = entries.filter((one) => one.calendarId === calendarId &&
+                    one.kind === "occurrence" &&
+                    one.seriesExternalId === series &&
+                    one.originalStartsAt !== null &&
+                    one.originalStartsAt >= window.from &&
+                    one.originalStartsAt < window.to &&
+                    one.deletedAt === null);
+                if (slots === null) {
+                    for (const one of held)
+                        one.seenAt = now;
+                    continue;
+                }
+                if (slots.length)
+                    saved += (await store.saveEntries(calendarId, slots, now)).length;
+                const given = new Set(slots.map(({ externalId }) => externalId));
+                const stale = held
+                    .filter((one) => !one.exception && one.status !== "cancelled" && !given.has(one.externalId))
+                    .map(({ externalId }) => externalId);
+                if (stale.length)
+                    removed += await store.removeEntries(calendarId, stale, now);
+            }
+            await store.setCursor(calendarId, cursor, now);
+            return { saved, removed };
+        },
         async cursor(calendarId) {
             return cursors.get(calendarId) ?? null;
         },
@@ -407,6 +453,17 @@ export const memoryEventStore = () => {
             if (!Number.isInteger(limit) || limit < 1 || limit > 1000 || !Number.isInteger(offset) || offset < 0)
                 throw new CliError("validation_error", "limit takes 1–1000 and offset 0 or more");
             const has = (event, check) => entries.some((one) => one.eventId === event.id && check(one));
+            const copiesOf = (event) => entries.filter((one) => one.eventId === event.id &&
+                (filter.accountId === undefined || calendarOf(one.calendarId).accountId === filter.accountId));
+            const busy = (event) => event.deletedAt === null &&
+                event.status !== "cancelled" &&
+                !event.allDay &&
+                event.startsAt !== null &&
+                event.endsAt !== null &&
+                copiesOf(event).some((one) => one.deletedAt === null &&
+                    one.status !== "cancelled" &&
+                    one.ownResponse !== "declined" &&
+                    one.transparency !== "transparent");
             return [...events.values()]
                 .filter((event) => event.deletedAt === null &&
                 (filter.from === undefined ||
@@ -421,11 +478,36 @@ export const memoryEventStore = () => {
                 (filter.accountId === undefined ||
                     has(event, (one) => calendarOf(one.calendarId).accountId === filter.accountId)) &&
                 (filter.personId === undefined ||
-                    has(event, (one) => participants.some((p) => p.entryId === one.id && p.identityId === filter.personId))))
+                    has(event, (one) => participants.some((p) => p.entryId === one.id && p.identityId === filter.personId))) &&
+                (filter.changedSince === undefined ||
+                    eventChange(event, copiesOf(event), revisions, filter.changedSince) !== null) &&
+                (!filter.overlapping ||
+                    (busy(event) &&
+                        [...events.values()].some((other) => other.id !== event.id &&
+                            busy(other) &&
+                            other.startsAt < event.endsAt &&
+                            other.endsAt > event.startsAt))))
                 .sort((a, b) => ((a.startsAt ?? -1) - (b.startsAt ?? -1) || a.id - b.id) * (filter.newest ? -1 : 1))
                 .slice(offset, offset + limit)
                 .map((event) => ({ ...event }));
         },
+        async historyOf(eventIds, calendarIds, since) {
+            const copies = entries.filter((one) => one.eventId !== null && eventIds.includes(one.eventId) && calendarIds.includes(one.calendarId));
+            const ids = new Set(copies.map(({ id }) => id));
+            return {
+                entries: copies.map(stored),
+                revisions: revisions.filter((one) => ids.has(one.entryId) && one.createdAt >= since).map((one) => ({ ...one })),
+            };
+        },
+        async participantsOf(eventIds, calendarIds) {
+            const wanted = new Map(entries
+                .filter((one) => one.eventId !== null && eventIds.includes(one.eventId) && calendarIds.includes(one.calendarId))
+                .map((one) => [one.id, one.eventId]));
+            return participants
+                .filter((one) => wanted.has(one.entryId))
+                .map((one) => ({ ...one, eventId: wanted.get(one.entryId) }))
+                .sort((a, b) => a.eventId - b.eventId || a.entryId - b.entryId || a.email.localeCompare(b.email));
+        },
         async event(id) {
             const event = events.get(id);
             if (!event)
@@ -486,4 +568,5 @@ export const memoryEventStore = () => {
             return { ...review, candidates: [...review.candidates] };
         },
     };
+    return store;
 };

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

@@ -161,6 +161,73 @@ export const calendarSyncContract = (make) => CALENDAR_TRAIT_COMBINATIONS.flatMa
             const event = await store.event(entry?.eventId);
             assert.equal(event?.event.status, "cancelled");
         }),
+        test("a series moved to another time keeps no slot at the old one", async ({ store, source, sync }) => {
+            if (traits.expands === "in-changes")
+                return;
+            putSeries(source, seriesOf("s"), [slot("s", AT), slot("s", AT + DAY), slot("s", AT + 2 * DAY)]);
+            await sync(NOW);
+            const later = AT + 2 * HOUR;
+            putSeries(source, { ...seriesOf("s"), startsAt: later, endsAt: later + HOUR }, [
+                slot("s", later),
+                slot("s", later + DAY),
+                slot("s", later + 2 * DAY),
+            ]);
+            await sync(NOW + HOUR);
+            const entries = await entriesOf(store);
+            assert.deepEqual([AT, AT + DAY, AT + 2 * DAY].map((at) => entries.get(slotId("s", at))?.status), ["cancelled", "cancelled", "cancelled"]);
+            assert.deepEqual([later, later + DAY, later + 2 * DAY].map((at) => entries.get(slotId("s", at))?.status), ["confirmed", "confirmed", "confirmed"]);
+        }),
+        test("a daily full round asks only the series that changed, and every series once a week", async ({ store, source, sync, }) => {
+            if (traits.expands !== "on-request" || traits.fullListOnly)
+                return;
+            const tagged = (series, etag) => ({ ...series, etag });
+            const days = (from, count) => Array.from({ length: count }, (_, n) => slot("s", from + n * DAY));
+            putSeries(source, tagged(seriesOf("s"), "v1"), days(AT, 3));
+            putSeries(source, tagged(seriesOf("t"), "v1"), [slot("t", AT)]);
+            await sync(NOW);
+            const asked = () => source.calls.occurrences.length;
+            const before = asked();
+            putSeries(source, tagged(seriesOf("t"), "v2"), [slot("t", AT), slot("t", AT + DAY)]);
+            const nextDay = await sync(NOW + DAY);
+            assert.equal(nextDay.synced[0]?.round, "full");
+            assert.deepEqual(source.calls.occurrences.slice(before), ["t"]);
+            const entries = await entriesOf(store);
+            assert.deepEqual(days(AT, 3).map(({ externalId }) => [entries.get(externalId)?.status, entries.get(externalId)?.deletedAt]), [
+                ["confirmed", null],
+                ["confirmed", null],
+                ["confirmed", null],
+            ]);
+            const far = AT + 92 * DAY;
+            source.setOccurrences("s", [...days(AT, 3), slot("s", far)]);
+            const atWeek = before + 1;
+            await sync(NOW + 2 * DAY);
+            assert.equal(asked(), atWeek);
+            await sync(NOW + 8 * DAY);
+            assert.ok(source.calls.occurrences.slice(atWeek).includes("s"));
+            assert.equal((await entriesOf(store)).get(slotId("s", far))?.status, "confirmed");
+        }),
+        test("the slots of many series take a few store writes, not two for each series", async ({ store, source, accountId, }) => {
+            if (traits.expands !== "on-request")
+                return;
+            for (let n = 0; n < 120; n++)
+                putSeries(source, seriesOf(`s${n}`), [slot(`s${n}`, AT), slot(`s${n}`, AT + DAY)]);
+            let writes = 0;
+            const counted = new Proxy(store, {
+                get: (target, key) => {
+                    const value = Reflect.get(target, key);
+                    if (typeof value !== "function")
+                        return value;
+                    return (...args) => {
+                        if (["saveEntries", "removeEntries", "saveSlots", "setCursor"].includes(String(key)))
+                            writes += 1;
+                        return value.apply(target, args);
+                    };
+                },
+            });
+            const report = await syncCalendars(source, counted, { accountId, now: NOW });
+            assert.equal(report.synced[0]?.occurrences, 240);
+            assert.ok(writes <= 10, `${writes} writes`);
+        }),
         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);
@@ -224,6 +291,29 @@ export const calendarSyncContract = (make) => CALENDAR_TRAIT_COMBINATIONS.flatMa
             assert.equal(entries.get("e1")?.deletedAt, null);
             assert.notEqual(entries.get("e0")?.deletedAt ?? null, null);
         }, { pageSize: 1 }),
+        test("a rescan the budget stops still lists every calendar it did not reach in full on the next run", async ({ source, sync }) => {
+            source.put("primary", single("e1"));
+            source.put("team", single("t1"));
+            await sync(NOW);
+            const stopped = await sync(NOW + HOUR, { full: true, budget: runBudget({ requests: 2 }) });
+            const rounds = (report) => Object.fromEntries(report.synced.map(({ externalId, round, state }) => [externalId, `${round} ${state}`]));
+            assert.deepEqual(rounds(stopped), { primary: "full complete", team: "full partial" });
+            assert.equal((await sync(NOW + 2 * HOUR)).synced.find(({ externalId }) => externalId === "team")?.round, "full");
+            if (!traits.fullListOnly)
+                assert.deepEqual(rounds(await sync(NOW + 3 * HOUR)), {
+                    primary: "changes complete",
+                    team: "changes complete",
+                });
+        }, {
+            calendars: ["primary", "team"].map((externalId) => ({
+                externalId,
+                title: externalId,
+                timezone: "UTC",
+                accessRole: "owner",
+                primary: externalId === "primary",
+                syncByDefault: true,
+            })),
+        }),
         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;

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

@@ -14,11 +14,7 @@ export interface CalendarWriterFixture {
     notified: () => boolean[];
     /** A time the provider accepts for a new event; the contract creates one-hour events from it. */
     at: number;
+    /** A second calendar of the same account, for a writer with `move`; its cases are skipped without one. */
+    target?: StoredCalendar;
 }
-/**
- * What every calendar writer keeps (gcal-cli plan §9, W1): a stale `etag` is a conflict, never an overwrite; a create
- * retried with its id finds the event; a repeat rule is kept as given and changed on the series; a timed event
- * switches to all-day and back; `notify: false` mails nobody, and a profile that keeps `events.notify` at its
- * default never reaches the provider with a write that would.
- */
 export declare const calendarWriterContract: (fixture: () => CalendarWriterFixture | Promise<CalendarWriterFixture>) => ContractCase[];