@kubun/connector-google-calendar 0.17.4 → 0.18.0

package/lib/provider.js

@@ -1,9 +1,11 @@
-import { ConnectorError, fetchOrAbsent, parseMaxAgeDays, resolveModelID } from '@kubun/connector';
+import { addBoundaryDuration, ConnectorError, fetchOrAbsent, parseMaxAgeDays, resolveModelID } from '@kubun/connector';
 import { deriveAccountKey } from './account-key.js';
-import { buildCalendarListURL, buildEventsListURL, calendarAPIClient, getCalendarListEntry, getEvent, getEventWithETag, mapCalendarToEntity, mapEventToEntity, splitEventSourceID } from './api.js';
+import { buildCalendarListURL, buildEventsListURL, calendarAPIClient, fetchEventResource, getCalendarListEntry, getEvent, getEventWithETag, mapCalendarToEntity, mapEventToEntity, splitEventSourceID } from './api.js';
 import { googleCalendarClusters } from './model.js';
 const CALENDAR_MODEL_ID = resolveModelID(googleCalendarClusters, 'GoogleCalendar');
 const CALENDAR_EVENT_MODEL_ID = resolveModelID(googleCalendarClusters, 'GoogleCalendarEvent');
+// How often the forward window rolls by a tokenless full event pass.
+const WINDOW_ROLL_INTERVAL = 'P30D';
 function computeTimeMin(boundary) {
     const days = parseMaxAgeDays(boundary);
     if (days == null) return undefined;
@@ -11,6 +13,56 @@ function computeTimeMin(boundary) {
     date.setDate(date.getDate() - days);
     return date.toISOString();
 }
+// The window of a tokenless full event pass starting now. The lower bound stays
+// frozen once set; the upper bound is recomputed from `maxAhead` but never moves
+// backwards, so a replay from an older checkpoint lists the same events or a
+// superset.
+function fullPassWindow(boundary, prior) {
+    const now = new Date();
+    const windowStart = prior?.windowStart ?? computeTimeMin(boundary);
+    const fresh = boundary.maxAhead != null ? addBoundaryDuration(now, boundary.maxAhead) : null;
+    if (fresh == null) {
+        return {
+            windowStart
+        };
+    }
+    const carried = prior?.windowEnd != null ? new Date(prior.windowEnd) : null;
+    const windowEnd = carried != null && carried > fresh ? carried : fresh;
+    return {
+        windowStart,
+        windowEnd: windowEnd.toISOString(),
+        windowRolledAt: now.toISOString()
+    };
+}
+function isRollDue(boundary, checkpoint) {
+    if (boundary.maxAhead == null) return false;
+    if (checkpoint.windowEnd == null || checkpoint.windowRolledAt == null) return true;
+    const dueAt = addBoundaryDuration(new Date(checkpoint.windowRolledAt), WINDOW_ROLL_INTERVAL);
+    return dueAt == null || Date.now() >= dueAt.getTime();
+}
+function windowFields(window) {
+    return {
+        ...window.windowStart != null ? {
+            windowStart: window.windowStart
+        } : {},
+        ...window.windowEnd != null ? {
+            windowEnd: window.windowEnd
+        } : {},
+        ...window.windowRolledAt != null ? {
+            windowRolledAt: window.windowRolledAt
+        } : {}
+    };
+}
+// Google's `timeMax` is an exclusive bound on the start, applied here to
+// listings that could not send it.
+function startsBefore(windowEnd) {
+    if (windowEnd == null) return ()=>true;
+    const bound = new Date(windowEnd).getTime();
+    return (event)=>{
+        const start = event.start.dateTime ?? event.start.date;
+        return start == null || new Date(start).getTime() < bound;
+    };
+}
 async function* fetchAllCalendars(params) {
     let pageToken;
     let isFirstPage = true;
@@ -32,21 +84,24 @@ async function* fetchAllCalendars(params) {
     }while (pageToken != null)
 }
 async function* fetchEventsForCalendar(params) {
-    let pageToken;
+    let pageToken = params.pageToken;
     let isFirstPage = true;
     do {
         const url = buildEventsListURL({
             calendarID: params.calendarID,
             syncToken: isFirstPage ? params.syncToken : undefined,
             pageToken,
-            timeMin: params.timeMin
+            timeMin: params.timeMin,
+            timeMax: params.timeMax,
+            showDeleted: params.showDeleted
         });
         const data = await params.client.get(url, {
             signal: params.signal
         });
         yield {
             items: data.items ?? [],
-            nextSyncToken: data.nextSyncToken
+            nextSyncToken: data.nextSyncToken,
+            nextPageToken: data.nextPageToken
         };
         pageToken = data.nextPageToken;
         isFirstPage = false;
@@ -62,12 +117,11 @@ export function createGoogleCalendarProvider(config) {
     // providerAccount capture.
     const accountKey = config.credential.providerAccount != null ? deriveAccountKey(config.credential.providerAccount) : undefined;
     async function* fetchAllEntities(params) {
-        // Reuse a window frozen by a prior sync (carried in an expired checkpoint on
-        // the 410 resync path, or a re-driven initial) instead of recomputing from
-        // `now`; only a genuine first sync computes it fresh.
+        // Reuse a window frozen by a prior sync when an initial pass is re-driven;
+        // only a genuine first sync computes it fresh.
         const prior = params.checkpoint;
-        const windowStart = prior?.windowStart ?? computeTimeMin(params.boundary);
-        const timeMin = windowStart;
+        const window = fullPassWindow(params.boundary, prior);
+        const inWindow = startsBefore(window.windowEnd);
         // Fetch all calendars (collect all pages first, then yield single batch)
         const allCalendars = [];
         let calendarListSyncToken;
@@ -84,7 +138,7 @@ export function createGoogleCalendarProvider(config) {
                 calendarListSyncToken = page.nextSyncToken;
             }
         }
-        // Yield calendar batch (no checkpoint yet — will be on the last event batch)
+        // Event batches checkpoint each completed calendar after this list batch.
         const calendarListToken = mintFetchHLC();
         yield {
             modelID: CALENDAR_MODEL_ID,
@@ -96,23 +150,31 @@ export function createGoogleCalendarProvider(config) {
             hasMore: true
         };
         // Fetch events per calendar
-        const calendarTokens = {};
+        const calendarTokens = Object.fromEntries(allCalendars.map((calendar)=>[
+                calendar.id,
+                {}
+            ]));
         let eventBatchYielded = false;
         for (const [i, calendar] of allCalendars.entries()){
             const isLastCalendar = i === allCalendars.length - 1;
             let eventsSyncToken;
+            const relistID = mintFetchHLC();
+            const seen = new Set();
             for await (const page of fetchEventsForCalendar({
                 calendarID: calendar.id,
                 client,
-                timeMin,
+                timeMin: window.windowStart,
+                timeMax: window.windowEnd,
+                showDeleted: true,
                 signal: params.signal
             })){
+                for (const event of page.items)seen.add(`${calendar.id}/${event.id}`);
                 if (page.nextSyncToken != null) {
                     eventsSyncToken = page.nextSyncToken;
                 }
                 const isLastPage = page.nextSyncToken != null // last page has nextSyncToken
                 ;
-                const checkpoint = isLastCalendar && isLastPage ? {
+                const checkpoint = isLastPage ? {
                     calendarListSyncToken,
                     calendars: {
                         ...calendarTokens,
@@ -120,12 +182,10 @@ export function createGoogleCalendarProvider(config) {
                             eventsSyncToken: page.nextSyncToken
                         }
                     },
-                    ...windowStart != null ? {
-                        windowStart
-                    } : {}
+                    ...windowFields(window)
                 } : undefined;
                 // Split items: cancelled → deleted, others → entities
-                const activeItems = page.items.filter((e)=>e.status !== 'cancelled');
+                const activeItems = page.items.filter((e)=>e.status !== 'cancelled' && inWindow(e));
                 const cancelledItems = page.items.filter((e)=>e.status === 'cancelled');
                 const pageToken = mintFetchHLC();
                 yield {
@@ -143,7 +203,28 @@ export function createGoogleCalendarProvider(config) {
                             sourceFetchHLC: pageToken
                         })),
                     hasMore: !(isLastCalendar && isLastPage),
-                    checkpoint
+                    checkpoint,
+                    ...isLastPage ? {
+                        sweep: {
+                            modelID: CALENDAR_EVENT_MODEL_ID,
+                            scope: {
+                                calendarID: calendar.id
+                            },
+                            partition: calendar.id,
+                            provenance: relistID,
+                            complete: true,
+                            kind: 'relist',
+                            keep: [
+                                ...seen
+                            ],
+                            sourceFetchHLC: relistID,
+                            predicate: {
+                                field: 'startAt',
+                                from: window.windowStart ?? null,
+                                to: window.windowEnd ?? null
+                            }
+                        }
+                    } : {}
                 };
                 eventBatchYielded = true;
             }
@@ -161,147 +242,274 @@ export function createGoogleCalendarProvider(config) {
                 checkpoint: {
                     calendarListSyncToken,
                     calendars: calendarTokens,
-                    ...windowStart != null ? {
-                        windowStart
-                    } : {}
+                    ...windowFields(window)
                 }
             };
         }
     }
     async function* fetchIncrementalEntities(params, checkpoint) {
-        // Carry the frozen window forward; new calendars are floored by it (not `now`).
-        const windowStart = checkpoint.windowStart ?? computeTimeMin(params.boundary);
-        const timeMin = windowStart;
-        // Fetch calendar list changes using stored syncToken
+        const resumingRelist = Object.values(checkpoint.calendars).some((calendar)=>calendar.relist != null);
+        const rollDue = checkpoint.roll != null || checkpoint.completed == null && !resumingRelist && isRollDue(params.boundary, checkpoint);
+        const window = checkpoint.roll != null ? {
+            windowStart: checkpoint.windowStart,
+            windowEnd: checkpoint.roll.windowEnd,
+            windowRolledAt: checkpoint.roll.startedAt
+        } : rollDue ? fullPassWindow(params.boundary, checkpoint) : {
+            windowStart: checkpoint.windowStart ?? computeTimeMin(params.boundary),
+            ...params.boundary.maxAhead != null ? {
+                windowEnd: checkpoint.windowEnd,
+                windowRolledAt: checkpoint.windowRolledAt
+            } : {}
+        };
+        const roll = checkpoint.roll ?? (rollDue && window.windowEnd != null && window.windowRolledAt != null ? {
+            windowEnd: window.windowEnd,
+            startedAt: window.windowRolledAt,
+            completed: []
+        } : undefined);
         const activeCalendars = [];
-        const deletedCalendarIDs = [];
+        const deletedCalendarIDs = new Set();
+        // Every calendar the list reports live, excluded ones included: exclusion
+        // is local configuration, never evidence that a calendar was removed.
+        const listedCalendarIDs = new Set();
         let newCalendarListSyncToken;
-        for await (const page of fetchAllCalendars({
-            client,
-            syncToken: checkpoint.calendarListSyncToken,
-            signal: params.signal
-        })){
-            for (const cal of page.items){
-                if (cal.deleted === true) {
-                    deletedCalendarIDs.push(cal.id);
-                } else if (!excludeSet.has(cal.id)) {
-                    activeCalendars.push(cal);
+        const collectCalendars = async (syncToken)=>{
+            activeCalendars.length = 0;
+            deletedCalendarIDs.clear();
+            listedCalendarIDs.clear();
+            for await (const page of fetchAllCalendars({
+                client,
+                syncToken,
+                signal: params.signal
+            })){
+                for (const cal of page.items){
+                    if (cal.deleted === true) {
+                        deletedCalendarIDs.add(cal.id);
+                        continue;
+                    }
+                    listedCalendarIDs.add(cal.id);
+                    if (!excludeSet.has(cal.id)) activeCalendars.push(cal);
                 }
+                if (page.nextSyncToken != null) newCalendarListSyncToken = page.nextSyncToken;
             }
-            if (page.nextSyncToken != null) {
-                newCalendarListSyncToken = page.nextSyncToken;
+        };
+        try {
+            await collectCalendars(checkpoint.calendarListSyncToken);
+        } catch (err) {
+            if (!(err instanceof ConnectorError && err.httpStatus === 410)) throw err;
+            await collectCalendars();
+            for (const id of Object.keys(checkpoint.calendars)){
+                if (!listedCalendarIDs.has(id)) deletedCalendarIDs.add(id);
             }
         }
-        // Yield calendar batch (active + deletions)
         const calendarListToken = mintFetchHLC();
         yield {
             modelID: CALENDAR_MODEL_ID,
-            entities: activeCalendars.map((c)=>({
+            entities: activeCalendars.map((cal)=>({
                     present: true,
-                    record: mapCalendarToEntity(c, accountKey),
+                    record: mapCalendarToEntity(cal, accountKey),
                     sourceFetchHLC: calendarListToken
                 })),
-            deleted: deletedCalendarIDs.map((id)=>({
+            deleted: [
+                ...deletedCalendarIDs
+            ].map((id)=>({
                     present: false,
                     sourceID: id,
                     sourceFetchHLC: calendarListToken
                 })),
             hasMore: true
         };
-        // Determine the set of calendars to sync events for
-        // Start from the previous calendar set, remove deleted, add newly discovered active ones
-        const prevCalendarTokens = {
+        const calendarTokens = {
             ...checkpoint.calendars
         };
+        for (const id of deletedCalendarIDs)delete calendarTokens[id];
+        for (const cal of activeCalendars){
+            if (!(cal.id in calendarTokens)) calendarTokens[cal.id] = {};
+        }
+        const completed = new Set(checkpoint.completed ?? []);
+        const rollCompleted = new Set(roll?.completed ?? []);
+        const pendingCalendarIDs = Object.keys(calendarTokens).filter((id)=>!completed.has(id) && !rollCompleted.has(id));
+        const checkpointFor = (tokens, complete, completedCalendarID)=>{
+            if (completedCalendarID != null) {
+                if (roll == null) completed.add(completedCalendarID);
+                else rollCompleted.add(completedCalendarID);
+            }
+            return {
+                calendarListSyncToken: newCalendarListSyncToken ?? checkpoint.calendarListSyncToken,
+                calendars: tokens,
+                ...roll == null && !complete ? {
+                    completed: [
+                        ...completed
+                    ]
+                } : {},
+                ...roll != null && !complete ? {
+                    roll: {
+                        ...roll,
+                        completed: [
+                            ...rollCompleted
+                        ]
+                    }
+                } : {},
+                ...windowFields(complete ? window : {
+                    ...window,
+                    windowRolledAt: checkpoint.windowRolledAt
+                })
+            };
+        };
+        const eventBatch = (calendarID, items, token, hasMore, nextCheckpoint)=>({
+                modelID: CALENDAR_EVENT_MODEL_ID,
+                // A sync-token delta can move an existing event outside the fetch
+                // window. Preserve its document with the new date; only a provider
+                // cancellation is an authoritative deletion.
+                entities: items.filter((event)=>event.status !== 'cancelled').map((event)=>({
+                        present: true,
+                        record: mapEventToEntity(event, calendarID),
+                        sourceFetchHLC: token
+                    })),
+                deleted: items.filter((event)=>event.status === 'cancelled').map((event)=>({
+                        present: false,
+                        sourceID: `${calendarID}/${event.id}`,
+                        sourceFetchHLC: token
+                    })),
+                hasMore,
+                checkpoint: nextCheckpoint
+            });
         for (const deletedID of deletedCalendarIDs){
-            delete prevCalendarTokens[deletedID];
+            yield {
+                modelID: CALENDAR_EVENT_MODEL_ID,
+                entities: [],
+                sweep: {
+                    modelID: CALENDAR_EVENT_MODEL_ID,
+                    scope: {
+                        calendarID: deletedID
+                    },
+                    keep: [],
+                    sourceFetchHLC: calendarListToken,
+                    partition: deletedID,
+                    provenance: calendarListToken,
+                    complete: true,
+                    predicate: null,
+                    kind: 'partition-removal'
+                },
+                hasMore: true
+            };
         }
-        // Collect new calendars that weren't in the previous checkpoint
-        const newlyDiscoveredCalendars = activeCalendars.filter((cal)=>!(cal.id in checkpoint.calendars));
-        // All calendars to sync: known (from prev checkpoint, minus deleted) + newly discovered
-        const knownCalendarIDs = Object.keys(prevCalendarTokens);
-        // Combine: known calendar IDs (we don't have resource objects for them, only IDs)
-        // plus newly discovered calendar resources
-        const allCalendarIDsToSync = [
-            ...knownCalendarIDs.map((id)=>({
-                    id,
-                    isNew: false
-                })),
-            ...newlyDiscoveredCalendars.map((cal)=>({
-                    id: cal.id,
-                    isNew: true
-                }))
-        ];
-        const updatedCalendarTokens = {};
-        for (const [i, entry] of allCalendarIDsToSync.entries()){
-            const { id: calendarID, isNew } = entry;
-            const isLastCalendar = i === allCalendarIDsToSync.length - 1;
-            // Use stored syncToken for known calendars; use timeMin for new ones
-            const storedToken = isNew ? undefined : prevCalendarTokens[calendarID]?.eventsSyncToken;
-            let eventsSyncToken;
-            for await (const page of fetchEventsForCalendar({
-                calendarID,
-                client,
-                syncToken: storedToken,
-                timeMin: isNew ? timeMin : undefined,
-                signal: params.signal
-            })){
-                if (page.nextSyncToken != null) {
-                    eventsSyncToken = page.nextSyncToken;
+        for (const [index, calendarID] of pendingCalendarIDs.entries()){
+            const prior = calendarTokens[calendarID];
+            const storedToken = prior?.eventsSyncToken;
+            const relist = prior?.relist;
+            if (rollDue && storedToken != null && relist == null) {
+                try {
+                    for await (const page of fetchEventsForCalendar({
+                        calendarID,
+                        client,
+                        syncToken: storedToken,
+                        signal: params.signal
+                    })){
+                        yield eventBatch(calendarID, page.items, mintFetchHLC(), true);
+                    }
+                } catch (err) {
+                    if (!(err instanceof ConnectorError && err.httpStatus === 410)) throw err;
                 }
-                const isLastPage = page.nextSyncToken != null;
-                const newCheckpoint = isLastCalendar && isLastPage ? {
-                    calendarListSyncToken: newCalendarListSyncToken,
-                    calendars: {
-                        ...updatedCalendarTokens,
-                        [calendarID]: {
+            }
+            const list = async function*(syncToken, currentRelist) {
+                let tracking = currentRelist;
+                if (syncToken == null && tracking == null) {
+                    const startedFetchHLC = mintFetchHLC();
+                    tracking = {
+                        relistID: startedFetchHLC,
+                        startedFetchHLC,
+                        seen: []
+                    };
+                }
+                for await (const page of fetchEventsForCalendar({
+                    calendarID,
+                    client,
+                    syncToken,
+                    pageToken: tracking?.pageToken,
+                    timeMin: syncToken == null ? window.windowStart : undefined,
+                    timeMax: syncToken == null ? window.windowEnd : undefined,
+                    showDeleted: syncToken == null ? true : undefined,
+                    signal: params.signal
+                })){
+                    const token = mintFetchHLC();
+                    const seen = tracking == null ? [] : [
+                        ...new Set([
+                            ...tracking.seen,
+                            ...page.items.map((item)=>`${calendarID}/${item.id}`)
+                        ])
+                    ];
+                    const finalPage = page.nextSyncToken != null;
+                    const complete = index === pendingCalendarIDs.length - 1 && finalPage;
+                    const nextTokens = {
+                        ...calendarTokens,
+                        [calendarID]: finalPage ? {
                             eventsSyncToken: page.nextSyncToken
+                        } : {
+                            ...syncToken == null ? {} : {
+                                eventsSyncToken: syncToken
+                            },
+                            relist: tracking == null ? undefined : {
+                                ...tracking,
+                                pageToken: page.nextPageToken,
+                                seen
+                            }
                         }
-                    },
-                    ...windowStart != null ? {
-                        windowStart
-                    } : {}
-                } : undefined;
-                // Split items: cancelled → deleted, others → entities
-                const activeItems = page.items.filter((e)=>e.status !== 'cancelled');
-                const cancelledItems = page.items.filter((e)=>e.status === 'cancelled');
-                const pageToken = mintFetchHLC();
-                yield {
-                    modelID: CALENDAR_EVENT_MODEL_ID,
-                    entities: activeItems.map((event)=>({
-                            present: true,
-                            record: mapEventToEntity(event, calendarID),
-                            sourceFetchHLC: pageToken
-                        })),
-                    // Match the composite identity mapEventToEntity assigns, so the
-                    // tombstone lookup hits the calendar-namespaced document.
-                    deleted: cancelledItems.map((e)=>({
-                            present: false,
-                            sourceID: `${calendarID}/${e.id}`,
-                            sourceFetchHLC: pageToken
-                        })),
-                    hasMore: !(isLastCalendar && isLastPage),
-                    checkpoint: newCheckpoint
-                };
-            }
-            updatedCalendarTokens[calendarID] = {
-                eventsSyncToken
+                    };
+                    const batch = eventBatch(calendarID, page.items, token, !complete, tracking != null || finalPage ? checkpointFor(nextTokens, complete, finalPage ? calendarID : undefined) : undefined);
+                    if (tracking != null && finalPage) {
+                        batch.sweep = {
+                            modelID: CALENDAR_EVENT_MODEL_ID,
+                            scope: {
+                                calendarID
+                            },
+                            keep: seen,
+                            sourceFetchHLC: tracking.startedFetchHLC,
+                            partition: calendarID,
+                            provenance: tracking.relistID,
+                            complete: true,
+                            predicate: {
+                                field: 'startAt',
+                                from: window.windowStart ?? null,
+                                to: window.windowEnd ?? null
+                            },
+                            kind: 'relist'
+                        };
+                    }
+                    yield batch;
+                    if (tracking != null) tracking = {
+                        ...tracking,
+                        pageToken: page.nextPageToken,
+                        seen
+                    };
+                    if (finalPage) calendarTokens[calendarID] = {
+                        eventsSyncToken: page.nextSyncToken
+                    };
+                }
             };
+            if (relist != null) {
+                try {
+                    yield* list(undefined, relist);
+                } catch (err) {
+                    if (!(err instanceof ConnectorError && err.httpStatus === 410)) throw err;
+                    yield* list(undefined, undefined);
+                }
+            } else if (rollDue || storedToken == null) {
+                yield* list(undefined, undefined);
+            } else {
+                try {
+                    yield* list(storedToken, undefined);
+                } catch (err) {
+                    if (!(err instanceof ConnectorError && err.httpStatus === 410)) throw err;
+                    yield* list(undefined, undefined);
+                }
+            }
         }
-        // If no event batches were yielded (zero calendars to sync), emit a final empty
-        // batch with hasMore: false and the composite checkpoint so the sync can complete.
-        if (allCalendarIDsToSync.length === 0) {
+        if (pendingCalendarIDs.length === 0) {
             yield {
                 modelID: CALENDAR_EVENT_MODEL_ID,
                 entities: [],
                 hasMore: false,
-                checkpoint: {
-                    calendarListSyncToken: newCalendarListSyncToken,
-                    calendars: updatedCalendarTokens,
-                    ...windowStart != null ? {
-                        windowStart
-                    } : {}
-                }
+                checkpoint: checkpointFor(calendarTokens, true)
             };
         }
     }
@@ -339,6 +547,71 @@ export function createGoogleCalendarProvider(config) {
             }
         });
     }
+    async function verifyEntity(model, sourceID) {
+        const sourceFetchHLC = mintFetchHLC();
+        if (model !== CALENDAR_EVENT_MODEL_ID) {
+            try {
+                return await fetchEntity(model, sourceID);
+            } catch  {
+                return {
+                    outcome: 'uncertain',
+                    sourceFetchHLC
+                };
+            }
+        }
+        try {
+            const { calendarID, eventID } = splitEventSourceID(sourceID);
+            try {
+                const event = await fetchEventResource({
+                    accessToken: config.credential.accessToken,
+                    calendarID,
+                    eventID,
+                    fetch: fetchFn
+                });
+                if (event.status === 'cancelled') return {
+                    outcome: 'cancelled',
+                    sourceFetchHLC
+                };
+                return {
+                    present: true,
+                    record: mapEventToEntity(event, calendarID),
+                    sourceFetchHLC
+                };
+            } catch (error) {
+                if (!(error instanceof ConnectorError && error.httpStatus === 404)) {
+                    return {
+                        outcome: 'uncertain',
+                        sourceFetchHLC
+                    };
+                }
+                try {
+                    const calendar = await getCalendarListEntry({
+                        accessToken: config.credential.accessToken,
+                        calendarID,
+                        fetch: fetchFn
+                    });
+                    return calendar.deleted === true ? {
+                        outcome: 'uncertain',
+                        sourceFetchHLC
+                    } : {
+                        present: false,
+                        sourceID,
+                        sourceFetchHLC
+                    };
+                } catch  {
+                    return {
+                        outcome: 'uncertain',
+                        sourceFetchHLC
+                    };
+                }
+            }
+        } catch  {
+            return {
+                outcome: 'uncertain',
+                sourceFetchHLC
+            };
+        }
+    }
     // Provider-authoritative re-read for write-back recovery. Unlike
     // fetchEntity, the present:true branch also surfaces a providerETag when the
     // provider reports one — the current revision an update's If-Match can
@@ -379,6 +652,7 @@ export function createGoogleCalendarProvider(config) {
         ],
         fetchAll: fetchAllEntities,
         fetchEntity,
+        verifyEntity,
         reconcile,
         async *fetchChanges (params) {
             const checkpoint = params.checkpoint;
@@ -386,17 +660,7 @@ export function createGoogleCalendarProvider(config) {
                 yield* fetchAllEntities(params);
                 return;
             }
-            try {
-                yield* fetchIncrementalEntities(params, checkpoint);
-            } catch (err) {
-                // 410 Gone = the stored syncToken has expired; Google requires a full
-                // resync. Discard the checkpoint by delegating to fetchAll.
-                if (err instanceof ConnectorError && err.httpStatus === 410) {
-                    yield* fetchAllEntities(params);
-                    return;
-                }
-                throw err;
-            }
+            yield* fetchIncrementalEntities(params, checkpoint);
         }
     };
 }