@mulmoclaude/core 3.2.0 → 3.4.0

package/dist/google/index.d.ts

@@ -7,9 +7,10 @@ export { brokerBaseUrl, brokerExchange, brokerRefresh, brokerStart, type BrokerS
 export { authorizeGoogle, commitLinkedTokens, getGoogleAccessToken, unlinkGoogle, waitForAuthCode, GOOGLE_AUTH_CANCELLED, GOOGLE_CALENDAR_SCOPE, GOOGLE_CALENDARLIST_SCOPE, GOOGLE_TASKS_SCOPE, GOOGLE_DRIVE_FILE_SCOPE, GOOGLE_SCOPES, type AuthorizeGoogleOptions, type RevokeFetch, } from './auth.js';
 export { createGoogleAuthFlow, googleAuthFlow, type GoogleAuthFlow, type GoogleAuthFlowStatus } from './authFlow.js';
 export { googleApiError, isGoogleApiError, GoogleApiError, DEFAULT_LIST_MAX_RESULTS, HTTP_FORBIDDEN, MAX_LIST_RESULTS } from './apiClient.js';
-export { buildEventPatch, calendarApiError, collectCalendarPages, createCalendarEvent, deleteCalendarEvent, getCalendarColors, canonicalCalendarId, listCalendarEvents, listCalendars, syncCalendarEvents, toCalendarMeta, toCalendarSummary, toEventSummary, updateCalendarEvent, getCalendarEvent, getCalendarMeta, resolveEventSpan, CANCELLED_EVENT_STATUS, HTTP_CONFLICT, HTTP_PRECONDITION_FAILED, type CalendarColorEntry, type CalendarColors, type CalendarEventInput, type CalendarEventSpan, type CalendarEventSummary, type CalendarEventTime, type CalendarListPage, type CalendarMeta, type CalendarSummary, type CalendarSyncResult, type DeleteCalendarEventInput, type FetchedCalendarEvent, type ListEventsInput, type SyncEventsInput, type UpdateCalendarEventInput, } from './calendar.js';
-export { calendarSyncStatePath, claimCalendarSyncIfDue, clearCalendarLastSyncedAt, clearCalendarSyncToken, loadCalendarLastSyncedAt, loadCalendarSyncToken, saveCalendarSyncToken, } from './calendarSyncStore.js';
+export { buildEventPatch, calendarApiError, collectCalendarPages, createCalendarEvent, deleteCalendarEvent, getCalendarColors, canonicalCalendarId, listCalendarEvents, listCalendars, syncCalendarEvents, toCalendarMeta, toCalendarSummary, toEventSummary, updateCalendarEvent, getCalendarEvent, getCalendarMeta, resolveEventSpan, CANCELLED_EVENT_STATUS, HTTP_CONFLICT, HTTP_PRECONDITION_FAILED, type CalendarColorEntry, type CalendarColors, type CalendarEventInput, type CalendarEventSpan, type CalendarEventSummary, type CalendarEventTime, type CalendarListPage, type CalendarMeta, type CalendarSummary, type CalendarSyncResult, type DeleteCalendarEventInput, type FetchedCalendarEvent, type ListEventsInput, type SyncEventsInput, type UpdateCalendarEventInput, syncPageParams, } from './calendar.js';
+export { calendarSyncStatePath, claimCalendarSyncIfDue, clearCalendarLastSyncedAt, clearCalendarSyncToken, loadCalendarLastSyncedAt, loadCalendarSyncToken, saveCalendarSyncToken, toolCalendarSyncKey, } from './calendarSyncStore.js';
 export { calendarSyncDueWindowMs, isCalendarSyncDue } from './calendarSyncDue.js';
+export { calendarBackfillPath, markCalendarBackfilled, needsCalendarBackfill } from './calendarBackfillState.js';
 export { stateLockPath, withCalendarStateLock, liveLockClock, type LockClock } from './calendarStateLock.js';
 export { calendarPushStatePath, clearCalendarShadow, loadCalendarShadow, mergeShadow, saveCalendarShadow, toShadowEvent, type ShadowEvent, } from './calendarPushState.js';
 export { isDeniedAccessRole, isUnpushed, locallyEditedIds, pushCalendarForCollection, pushCollectionNow, reportedAccessRole, unsentLocalEdits, type PushOutcomeKind, type CalendarCollectionPushResult, type CalendarPushDeps, type CalendarPushOutcome, type CalendarWriteTarget, } from './collectionPush.js';
@@ -19,6 +20,6 @@ export { toCollectionDateTime } from './collectionDateTime.js';
 export { withCalendarLock, withKeyedLock } from './calendarLock.js';
 export { toCollectionRecord, type GoogleCalendarSourceField } from './collectionProjection.js';
 export { mergeIntoExisting } from '../collection/core/project.js';
-export { googleCalendarSyncTaskDef, classifyDelete, classifyWrite, anySyncedCollectionSurvives, applyPlanFor, groupByCalendar, allUnpushed, unsentEditGuard, heldBack, orphanedCalendarId, pullableEvents, pullProtectionFor, pushAndProtect, releaseOrphanedCalendarToken, unpushedFor, PROTECTION_UNKNOWN, type ClaimGuard, type PullProtectionDeps, type UnpushedBySlug, syncCalendarForCollection, syncCalendarGroup, syncDueCalendarCollections, syncNewCalendarCollections, shadowUpdates, unsyncedGroups, GOOGLE_CALENDAR_SYNC_TASK_ID, type CalendarCollectionSyncResult, type CalendarDeclaring, type ManualCalendarSyncDeps, type ManualCalendarSyncOutcome, } from './collectionSync.js';
+export { googleCalendarSyncTaskDef, classifyDelete, classifyWrite, anySyncedCollectionSurvives, applyPlanFor, groupByCalendar, allUnpushed, unsentEditGuard, heldBack, orphanedCalendarId, pullableEvents, pullProtectionFor, pushAndProtect, releaseOrphanedCalendarToken, unpushedFor, PROTECTION_UNKNOWN, type ClaimGuard, type PullProtectionDeps, type UnpushedBySlug, syncCalendarForCollection, syncCalendarGroup, syncDueCalendarCollections, syncNewCalendarCollections, shadowUpdates, collectionsNeedingBackfill, resumableToken, windowAdvance, type WindowAdvance, groupsNeedingBackfill, withPartialWindowError, PARTIAL_CALENDAR_WINDOW, GOOGLE_CALENDAR_SYNC_TASK_ID, type CalendarCollectionSyncResult, type CalendarDeclaring, type ManualCalendarSyncDeps, type ManualCalendarSyncOutcome, } from './collectionSync.js';
 export { buildTaskPatch, canonicalTaskListId, completeTask, createTask, deleteTask, listTaskLists, listTasks, toTaskListSummary, toTaskSummary, uncompleteTask, updateTask, type CompleteTaskInput, type CreateTaskInput, type ListTasksInput, type TaskListSummary, type TaskSummary, type UpdateTaskInput, } from './tasks.js';
 export { assertSafeMimeType, buildMultipartBody, createDriveFile, deleteDriveFile, isTextMimeType, listDriveFiles, pickBoundary, readDriveFile, toDriveFileSummary, type CreateDriveFileInput, type DriveFileSummary, type ListDriveFilesInput, type ReadDriveFileInput, } from './driveFile.js';

package/dist/google/index.js

@@ -4,7 +4,7 @@ import { n as writeFileAtomic } from "../root-BMroU_mB.js";
 import { fetchWithTimeout } from "../utils/fetch.js";
 import { l as parseIsoDate, u as parseIsoDateTime } from "../calendarGrid-Csy2rpjp.js";
 import { t as mergeIntoExisting } from "../project-B0j_Vf_Q.js";
-import { Y as getWorkspaceRoot, at as createHostSlot, d as storeFor, it as createForwardingLogger, n as discoverCollections } from "../discovery-CC7kuwHf.js";
+import { Y as getWorkspaceRoot, at as createHostSlot, d as storeFor, it as createForwardingLogger, n as discoverCollections } from "../discovery-D7LCN8gJ.js";
 import { t as mulmoConfigDir } from "../paths-CkJxNZ7T.js";
 import { promises } from "node:fs";
 import path, { join } from "node:path";
@@ -762,33 +762,42 @@ async function fetchSyncPage(accessToken, calendarId, params) {
 *
 *  `nextSyncToken` is only present on the LAST page, so every page must be
 *  walked before the token is worth storing. */
+/** The query for one page of the walk. `showDeleted` must stay true or
+*  deletions would be invisible; `pageToken` is sent ALONGSIDE `syncToken`,
+*  which is what Google requires to page an incremental sync. */
+function syncPageParams(input, pageToken) {
+	const params = new URLSearchParams({
+		singleEvents: "true",
+		showDeleted: "true",
+		maxResults: String(input.maxResults ?? EVENT_SYNC_PAGE_SIZE)
+	});
+	if (input.syncToken) params.set("syncToken", input.syncToken);
+	if (pageToken) params.set("pageToken", pageToken);
+	return params;
+}
 async function syncCalendarEvents(accessToken, input = {}) {
 	const events = [];
 	let pageToken;
 	let nextSyncToken;
 	for (let page = 0; page < MAX_EVENT_SYNC_PAGES; page += 1) {
-		const params = new URLSearchParams({
-			singleEvents: "true",
-			showDeleted: "true",
-			maxResults: String(input.maxResults ?? EVENT_SYNC_PAGE_SIZE)
-		});
-		if (input.syncToken) params.set("syncToken", input.syncToken);
-		if (pageToken) params.set("pageToken", pageToken);
-		const payload = await fetchSyncPage(accessToken, input.calendarId, params);
+		const payload = await fetchSyncPage(accessToken, input.calendarId, syncPageParams(input, pageToken));
 		if (payload === GONE) return {
 			events: [],
-			fullResyncRequired: true
+			fullResyncRequired: true,
+			pagesExhausted: false
 		};
 		const record = asRecord(payload);
 		events.push(...itemsOf(payload).map(toEventSummary));
 		nextSyncToken = stringField(record, "nextSyncToken") || void 0;
 		pageToken = stringField(record, "nextPageToken") || void 0;
 		if (!pageToken) break;
+		nextSyncToken = void 0;
 	}
 	return {
 		events,
 		nextSyncToken,
-		fullResyncRequired: false
+		fullResyncRequired: false,
+		pagesExhausted: pageToken !== void 0
 	};
 }
 /** Pagination loop for CalendarList.list, extracted so it can be tested without
@@ -1013,6 +1022,21 @@ function calendarSyncStatePath(workspaceRoot) {
 	return path.join(workspaceRoot ?? getWorkspaceRoot(), "data", "calendar", ".sync-state.json");
 }
 var calendarKey = canonicalCalendarId;
+/** The key for a consumer that reads a calendar without KEEPING what it reads.
+*
+*  A sync token is a claim about which events the consumer already holds, but
+*  the key above names only the calendar — so every consumer of one calendar
+*  shares one cursor. That is right for the collections bound to it (one fetch
+*  fans out to all of them in the same pass) and wrong for the standalone
+*  `google` tool's `calendarSync`, which walks the calendar, reports a summary
+*  to the LLM and discards the events.
+*
+*  Sharing it lost data both ways (#2850): the tool consumed windows the
+*  collections then never received, and a collection created afterwards resumed
+*  from the tool's cursor — so its "first sync" was a delta of a window it had
+*  never held, and the calendar's history never arrived. Same file, separate
+*  keyspace. Idempotent through `calendarKey`, since the result is non-empty. */
+var toolCalendarSyncKey = (calendarId) => `tool:${canonicalCalendarId(calendarId)}`;
 /** Read one map out of whatever is on disk. Tolerant on purpose: a file written
 *  before `lastSyncedAt` existed simply lacks the key, and a hand-edited one may
 *  hold anything. A dropped entry costs a full re-walk or a duplicate run, never
@@ -1138,6 +1162,46 @@ function isCalendarSyncDue(lastSyncedAt, windowMs, now = Date.now()) {
 	return elapsed >= windowMs;
 }
 //#endregion
+//#region src/google/calendarBackfillState.ts
+var BACKFILL_STATE_MODE = 384;
+var BACKFILL_FILE = ".calendar-sync.json";
+/** `<dataDir>/.calendar-sync.json` */
+var calendarBackfillPath = (dataDir) => path.join(dataDir, BACKFILL_FILE);
+/** Whether these records still need the whole calendar walked into them.
+*
+*  Compared against the calendar the marker NAMES, not merely its presence: a
+*  schema repointed at another calendar holds a backfill of the wrong one, and
+*  resuming that calendar's cursor would leave the same silent gap this exists
+*  to close.
+*
+*  Unreadable, absent or INCOMPLETE all answer "yes" — every field must be
+*  there, not just the one being compared. A redundant full walk costs API
+*  calls and rewrites records that already match; skipping a needed one loses
+*  the history silently, which is the failure being fixed, so the bias only
+*  ever goes one way (CodeRabbit review #2853). */
+async function needsCalendarBackfill(dataDir, calendarId) {
+	const stored = await readJsonOrNull(calendarBackfillPath(dataDir));
+	if (typeof stored?.walkedAt !== "string" || stored.walkedAt === "") return true;
+	return stored.calendarId !== canonicalCalendarId(calendarId);
+}
+/** Record that these records now cover the whole calendar. Never throws: the
+*  marker is an optimisation over re-walking, so a workspace that cannot write
+*  it syncs correctly and simply walks in full again next time. */
+async function markCalendarBackfilled(dataDir, calendarId, walkedAt) {
+	const state = {
+		calendarId: canonicalCalendarId(calendarId),
+		walkedAt
+	};
+	try {
+		await writeJsonAtomicWithMode(calendarBackfillPath(dataDir), state, BACKFILL_STATE_MODE);
+	} catch (error) {
+		log.warn("google", "could not record the calendar backfill marker — the next sync will walk the calendar again", {
+			dataDir,
+			error: String(error)
+		});
+	}
+}
+//#endregion
 //#region src/google/calendarPushState.ts
 var PUSH_STATE_MODE = 384;
 /** `<workspace>/data/calendar/.push-state.json` */
@@ -2183,21 +2247,114 @@ async function releaseCalendarSyncClaim(calendarId, workspaceRoot) {
 *  would advance the baseline past a record the pull deliberately left holding a
 *  local edit, which is the silent overwrite this whole path exists to stop. */
 var heldBack = (unpushed, results) => /* @__PURE__ */ new Set([...allUnpushed(unpushed), ...results.flatMap((result) => result.withheld)]);
-async function syncCalendarGroupNow(calendarId, collections, workspaceRoot) {
-	const unpushed = await pushAndProtect(collections, workspaceRoot);
-	const baseline = await loadCalendarShadow(calendarId, workspaceRoot);
+/** The collections in this group that have never received the whole calendar,
+*  by slug. Asked of each collection's OWN records (`calendarBackfillState.ts`),
+*  because the sync token cannot answer it — it is keyed by calendar and shared
+*  by every consumer of that calendar (#2850). */
+async function collectionsNeedingBackfill(collections) {
+	return (await Promise.all(collections.map(async (collection) => {
+		return await needsCalendarBackfill(collection.dataDir, collection.schema.googleCalendar?.calendarId) ? collection.slug : null;
+	}))).filter((slug) => slug !== null);
+}
+/** The token this run may resume from — none while any collection in the group
+*  still needs the whole calendar.
+*
+*  A stored token says how far THE CALENDAR has been read, by whoever read it:
+*  the standalone `google` tool's `calendarSync`, or a sibling collection that
+*  synced before this one existed. Resuming from it hands a brand-new collection
+*  a delta of a window it never received — a handful of records, reported as a
+*  success with no error, and never the history the docs promise (#2850).
+*
+*  The full walk fans out to the whole group, which is free: writes are upserts,
+*  so the collections that were already current simply rewrite what they hold. */
+async function resumableToken(calendarId, collections, workspaceRoot) {
+	const pending = await collectionsNeedingBackfill(collections);
+	if (pending.length === 0) return await loadCalendarSyncToken(calendarId, workspaceRoot) ?? void 0;
+	log.info("google", "walking the whole calendar — these collections have never received it", {
+		calendarId,
+		collections: pending
+	});
+}
+/** Record the backfill for every collection the window landed in. Called only
+*  after a FULL walk that fully landed: marking one after an incremental window
+*  would claim a history the records do not hold. */
+async function markGroupBackfilled(calendarId, collections) {
+	const walkedAt = (/* @__PURE__ */ new Date()).toISOString();
+	await Promise.all(collections.map((collection) => markCalendarBackfilled(collection.dataDir, collection.schema.googleCalendar?.calendarId, walkedAt)));
+}
+/** What a partial window reports. Names the cause the user can actually act on:
+*  a page guard is reached when Google has to expand an enormous number of
+*  recurring instances, and one series with no end date is enough. */
+var PARTIAL_CALENDAR_WINDOW = "Google returned more pages of events than one sync pass walks, so only part of the calendar was copied. Give any recurring event with no end date a finite end date, then sync again.";
+/** A truncated walk must not read as a completed one (#2850).
+*
+*  Added AFTER the token/baseline gate, not through it. A short fetch is not a
+*  failed write: the events that did arrive are Google's own and landed
+*  correctly, so their baseline is true and holding it back would freeze them —
+*  a record with no baseline reads as an unsent local edit, which the next pull
+*  then refuses to touch (#2683). What must not happen is the walk claiming
+*  completeness, and that is covered without the gate: `nextSyncToken` only
+*  appears on Google's last page, so a truncated walk has no token to advance,
+*  and the backfill marker is withheld separately. */
+var withPartialWindowError = (results, pagesExhausted) => pagesExhausted ? results.map((result) => ({
+	...result,
+	errors: [...result.errors, PARTIAL_CALENDAR_WINDOW]
+})) : [...results];
+/** `landed` is the write-side verdict (`windowFullyLanded`); the rest describe
+*  the window Google returned.
+*
+*  A page-capped walk (`pagesExhausted`) keeps its baseline — the events that
+*  arrived are Google's own and were written correctly — but must NOT claim the
+*  backfill, or the collection would stop asking for the rest of its calendar.
+*  Its token is refused too, though Google makes that moot by sending
+*  `nextSyncToken` only on the last page. */
+function windowAdvance(window) {
+	if (!window.landed) return {
+		baseline: false,
+		backfill: false,
+		token: false
+	};
+	const complete = !window.pagesExhausted;
+	return {
+		baseline: true,
+		backfill: window.walkedInFull && complete,
+		token: complete && window.nextSyncToken !== void 0
+	};
+}
+/** The window this run should read, and whether it was a full walk. A 410
+*  restart is a full walk too, so it backfills just as well as a forced one. */
+async function readWindow(calendarId, collections, workspaceRoot) {
 	const accessToken = await getGoogleAccessToken();
+	const resumeFrom = await resumableToken(calendarId, collections, workspaceRoot);
 	const first = await syncCalendarEvents(accessToken, {
 		calendarId,
-		syncToken: await loadCalendarSyncToken(calendarId, workspaceRoot) ?? void 0
+		syncToken: resumeFrom
 	});
 	const result = first.fullResyncRequired ? await restartFullSync(accessToken, calendarId, workspaceRoot) : first;
-	const results = await applyWindowToGroup(collections, result.events, workspaceRoot, unpushed, baseline);
-	if (windowFullyLanded(calendarId, results)) {
-		await saveCalendarShadow(calendarId, shadowUpdates(result.events, heldBack(unpushed, results), baseline), workspaceRoot);
-		if (result.nextSyncToken) await advanceToken(calendarId, result.nextSyncToken, collections, workspaceRoot);
-	}
-	return results;
+	if (result.pagesExhausted) log.warn("google", "the calendar walk ran out of pages — only part of it was copied", {
+		calendarId,
+		events: result.events.length
+	});
+	return {
+		result,
+		walkedInFull: resumeFrom === void 0 || first.fullResyncRequired
+	};
+}
+async function syncCalendarGroupNow(calendarId, collections, workspaceRoot) {
+	const unpushed = await pushAndProtect(collections, workspaceRoot);
+	const baseline = await loadCalendarShadow(calendarId, workspaceRoot);
+	const { result, walkedInFull } = await readWindow(calendarId, collections, workspaceRoot);
+	const applied = await applyWindowToGroup(collections, result.events, workspaceRoot, unpushed, baseline);
+	const advance = windowAdvance({
+		landed: windowFullyLanded(calendarId, applied),
+		walkedInFull,
+		pagesExhausted: result.pagesExhausted,
+		nextSyncToken: result.nextSyncToken
+	});
+	if (advance.baseline) await saveCalendarShadow(calendarId, shadowUpdates(result.events, heldBack(unpushed, applied), baseline), workspaceRoot);
+	if (advance.backfill) await markGroupBackfilled(calendarId, collections);
+	if (advance.token && result.nextSyncToken) await advanceToken(calendarId, result.nextSyncToken, collections, workspaceRoot);
+	return withPartialWindowError(applied, result.pagesExhausted);
 }
 /** Apply one window to every collection on the calendar, honouring what each
 *  one's own push protected. A collection whose protection could not be worked
@@ -2433,24 +2590,29 @@ async function syncDueCalendarCollections(workspaceRoot, intervalMs = DEFAULT_SY
 	const windowMs = calendarSyncDueWindowMs(intervalMs);
 	return await runCalendarGroups(groups, workspaceRoot, (lastSyncedAt) => isCalendarSyncDue(lastSyncedAt, windowMs));
 }
-/** The groups whose calendar has never synced. A missing token IS the "created
-*  since the last sync" signal — nothing else distinguishes a new collection
-*  from an edited one on the write path this feeds (#2427).
+/** The groups holding a collection that still needs the whole calendar.
+*
+*  This used to ask whether the CALENDAR had a stored token, which is not the
+*  same question and is why the trigger silently did nothing for the #2850
+*  reporter: their calendar already had a token — from the standalone `google`
+*  tool, and on later attempts from the collection they had just deleted by
+*  hand — so the brand-new collection matched nothing and its first sync never
+*  ran at all. `pending` is injected so the rule is testable without a
+*  workspace on disk.
 *
-*  Self-silencing by construction: the first sync stores a token, so a calendar
-*  matches at most once. `loadToken` is injected so the rule is testable without
-*  a workspace on disk. */
-async function unsyncedGroups(groups, loadToken) {
-	const checked = await Promise.all([...groups].map(async (entry) => await loadToken(entry[0]) === null ? entry : null));
+*  Still self-silencing: a landed full walk marks its collections, so a group
+*  stops matching once every collection in it holds the history. */
+async function groupsNeedingBackfill(groups, pending) {
+	const checked = await Promise.all([...groups].map(async (entry) => await pending(entry[1]) ? entry : null));
 	return new Map(checked.filter((entry) => entry !== null));
 }
-/** Sync only the calendars that have never synced — the first sync for a
-*  just-created collection, which otherwise stays empty until the hourly
-*  scheduler run (#2427). Cheap and safe to call on every config write. */
+/** Sync only the calendars a collection has never received in full — the first
+*  sync for a just-created collection, which otherwise stays empty until the
+*  hourly scheduler run (#2427). Cheap and safe to call on every config write. */
 async function syncNewCalendarCollections(workspaceRoot) {
-	const pending = await unsyncedGroups(await declaringGroups(workspaceRoot), (calendarId) => loadCalendarSyncToken(calendarId, workspaceRoot));
+	const pending = await groupsNeedingBackfill(await declaringGroups(workspaceRoot), async (collections) => (await collectionsNeedingBackfill(collections)).length > 0);
 	if (!await backgroundSyncAllowed(pending)) return [];
-	log.info("google", "running the first sync for newly declared calendars", { calendars: [...pending.keys()] });
+	log.info("google", "running the first sync for calendars a collection has never received in full", { calendars: [...pending.keys()] });
 	return await runCalendarGroups(pending, workspaceRoot);
 }
 var liveManualSyncDeps = {
@@ -2699,6 +2861,6 @@ async function deleteDriveFile(accessToken, input) {
 	await googleRequest(DRIVE_API_LABEL, accessToken, `${DRIVE_FILES_URL}/${encodeURIComponent(input.fileId)}`, { method: "DELETE" });
 }
 //#endregion
-export { CANCELLED_EVENT_STATUS, DEFAULT_LIST_MAX_RESULTS, GOOGLE_AUTH_CANCELLED, GOOGLE_CALENDARLIST_SCOPE, GOOGLE_CALENDAR_SCOPE, GOOGLE_CALENDAR_SYNC_TASK_ID, GOOGLE_DRIVE_FILE_SCOPE, GOOGLE_SCOPES, GOOGLE_TASKS_SCOPE, GoogleApiError, HTTP_CONFLICT, HTTP_FORBIDDEN, HTTP_PRECONDITION_FAILED, MAX_LIST_RESULTS, PROTECTION_UNKNOWN, PUSHABLE_SOURCE_FIELDS, allUnpushed, anySyncedCollectionSurvives, applyPlanFor, assertSafeMimeType, authorizeGoogle, baselineRecord, brokerBaseUrl, brokerExchange, brokerRefresh, brokerStart, buildEventPatch, buildMultipartBody, buildTaskPatch, bySourceField, calendarApiError, calendarPushStatePath, calendarSyncDueWindowMs, calendarSyncStatePath, canonicalCalendarId, canonicalTaskListId, claimCalendarSyncIfDue, classifyDelete, classifyWrite, clearCalendarLastSyncedAt, clearCalendarShadow, clearCalendarSyncToken, clientSecretPresence, collectCalendarPages, commitLinkedTokens, completeTask, configureGoogleHost, conflictingFields, createCalendarEvent, createDriveFile, createGoogleAuthFlow, createTask, deleteCalendarEvent, deleteDriveFile, deleteGoogleTokens, deleteTask, fieldText, findClientSecretPath, getCalendarColors, getCalendarEvent, getCalendarMeta, getGoogleAccessToken, googleApiError, googleAuthFlow, googleCalendarSyncTaskDef, googleConfigDir, googleSecretsDir, googleTokenPath, groupByCalendar, heldBack, isCalendarSyncDue, isClientSettableEventId, isDeniedAccessRole, isGoogleApiError, isIsoDateTimeWithOffset, isTextMimeType, isUnpushed, legacyGoogleTokenPath, listCalendarEvents, listCalendars, listDriveFiles, listTaskLists, listTasks, liveLockClock, loadCalendarLastSyncedAt, loadCalendarShadow, loadCalendarSyncToken, loadClientSecret, loadGoogleTokens, locallyChangedFields, locallyDeletedIds, locallyEditedIds, mayAdoptExisting, mergeGoogleTokens, mergeIntoExisting, mergeShadow, orphanedCalendarId, pickBoundary, planRecord, pullProtectionFor, pullableEvents, pushAndProtect, pushCalendarForCollection, pushCollectionNow, pushableMap, readDriveFile, releaseOrphanedCalendarToken, reportedAccessRole, resolveEventSpan, saveCalendarShadow, saveCalendarSyncToken, saveGoogleTokens, shadowUpdates, stateLockPath, syncCalendarEvents, syncCalendarForCollection, syncCalendarGroup, syncDueCalendarCollections, syncNewCalendarCollections, toCalendarMeta, toCalendarSummary, toCollectionDateTime, toCollectionRecord, toDriveFileSummary, toEventSummary, toGoogleEventTime, toShadowEvent, toTaskListSummary, toTaskSummary, uncompleteTask, unlinkGoogle, unpushedFor, unsentEditGuard, unsentLocalEdits, unsyncedGroups, updateCalendarEvent, updateTask, waitForAuthCode, withCalendarLock, withCalendarStateLock, withKeyedLock, zoneSuffixOf };
+export { CANCELLED_EVENT_STATUS, DEFAULT_LIST_MAX_RESULTS, GOOGLE_AUTH_CANCELLED, GOOGLE_CALENDARLIST_SCOPE, GOOGLE_CALENDAR_SCOPE, GOOGLE_CALENDAR_SYNC_TASK_ID, GOOGLE_DRIVE_FILE_SCOPE, GOOGLE_SCOPES, GOOGLE_TASKS_SCOPE, GoogleApiError, HTTP_CONFLICT, HTTP_FORBIDDEN, HTTP_PRECONDITION_FAILED, MAX_LIST_RESULTS, PARTIAL_CALENDAR_WINDOW, PROTECTION_UNKNOWN, PUSHABLE_SOURCE_FIELDS, allUnpushed, anySyncedCollectionSurvives, applyPlanFor, assertSafeMimeType, authorizeGoogle, baselineRecord, brokerBaseUrl, brokerExchange, brokerRefresh, brokerStart, buildEventPatch, buildMultipartBody, buildTaskPatch, bySourceField, calendarApiError, calendarBackfillPath, calendarPushStatePath, calendarSyncDueWindowMs, calendarSyncStatePath, canonicalCalendarId, canonicalTaskListId, claimCalendarSyncIfDue, classifyDelete, classifyWrite, clearCalendarLastSyncedAt, clearCalendarShadow, clearCalendarSyncToken, clientSecretPresence, collectCalendarPages, collectionsNeedingBackfill, commitLinkedTokens, completeTask, configureGoogleHost, conflictingFields, createCalendarEvent, createDriveFile, createGoogleAuthFlow, createTask, deleteCalendarEvent, deleteDriveFile, deleteGoogleTokens, deleteTask, fieldText, findClientSecretPath, getCalendarColors, getCalendarEvent, getCalendarMeta, getGoogleAccessToken, googleApiError, googleAuthFlow, googleCalendarSyncTaskDef, googleConfigDir, googleSecretsDir, googleTokenPath, groupByCalendar, groupsNeedingBackfill, heldBack, isCalendarSyncDue, isClientSettableEventId, isDeniedAccessRole, isGoogleApiError, isIsoDateTimeWithOffset, isTextMimeType, isUnpushed, legacyGoogleTokenPath, listCalendarEvents, listCalendars, listDriveFiles, listTaskLists, listTasks, liveLockClock, loadCalendarLastSyncedAt, loadCalendarShadow, loadCalendarSyncToken, loadClientSecret, loadGoogleTokens, locallyChangedFields, locallyDeletedIds, locallyEditedIds, markCalendarBackfilled, mayAdoptExisting, mergeGoogleTokens, mergeIntoExisting, mergeShadow, needsCalendarBackfill, orphanedCalendarId, pickBoundary, planRecord, pullProtectionFor, pullableEvents, pushAndProtect, pushCalendarForCollection, pushCollectionNow, pushableMap, readDriveFile, releaseOrphanedCalendarToken, reportedAccessRole, resolveEventSpan, resumableToken, saveCalendarShadow, saveCalendarSyncToken, saveGoogleTokens, shadowUpdates, stateLockPath, syncCalendarEvents, syncCalendarForCollection, syncCalendarGroup, syncDueCalendarCollections, syncNewCalendarCollections, syncPageParams, toCalendarMeta, toCalendarSummary, toCollectionDateTime, toCollectionRecord, toDriveFileSummary, toEventSummary, toGoogleEventTime, toShadowEvent, toTaskListSummary, toTaskSummary, toolCalendarSyncKey, uncompleteTask, unlinkGoogle, unpushedFor, unsentEditGuard, unsentLocalEdits, updateCalendarEvent, updateTask, waitForAuthCode, windowAdvance, withCalendarLock, withCalendarStateLock, withKeyedLock, withPartialWindowError, zoneSuffixOf };
 
 //# sourceMappingURL=index.js.map