@mulmoclaude/core 5.1.0 → 5.4.0

package/dist/google/index.d.ts

@@ -1,5 +1,7 @@
 export { configureGoogleHost, type GoogleLogger } from './host.js';
 export { isIsoDateTimeWithOffset } from './datetime.js';
+export { deleteRefusalMessage, planDelete, type DeleteDecision, type DeleteRefusal } from './deletePlan.js';
+export { conferenceVideoUri, selfResponseStatus } from './eventDerived.js';
 export { isCalendarDateOnly, resolvePartialSpanInput, resolveSpanInput, toEventTimeInput, eventTimeHint, EVENT_TIME_HINT, ALL_DAY_END_HINT, LONE_ALL_DAY_HINT, MIXED_SPAN_HINT, type PartialSpanResult, type PartialSpanTimes, type SpanResult, type SpanTimes, } from './eventSpanInput.js';
 export { googleConfigDir, googleSecretsDir, googleTokenPath, legacyGoogleTokenPath } from './paths.js';
 export { clientSecretPresence, findClientSecretPath, loadClientSecret, type ClientSecretPresence, type InstalledClientSecret } from './clientSecret.js';
@@ -8,13 +10,13 @@ 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, syncPageParams, } from './calendar.js';
+export { buildEventPatch, calendarApiError, collectCalendarPages, createCalendarEvent, deleteCalendarEvent, getCalendarColors, canonicalCalendarId, listCalendarEvents, listCalendars, syncCalendarEvents, toCalendarMeta, toCalendarSummary, toEventSummary, updateCalendarEvent, getCalendarEvent, getCalendarMeta, resolveEventSpan, CANCELLED_EVENT_STATUS, EVENT_ABSENT_STATUSES, 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';
+export { isDeniedAccessRole, isUnpushed, locallyEditedIds, pushCalendarForCollection, pushCollectionNow, reportedAccessRole, sweepDeletes, unsentLocalEdits, type DeleteSweep, type DeleteSweepDeps, type PushOutcomeKind, type CalendarCollectionPushResult, type CalendarPushDeps, type CalendarPushOutcome, type CalendarWriteTarget, } from './collectionPush.js';
 export { toGoogleEventTime, zoneSuffixOf } from './pushDateTime.js';
 export { baselineRecord, bySourceField, conflictingFields, fieldText, isClientSettableEventId, locallyChangedFields, locallyDeletedIds, mayAdoptExisting, planRecord, pushableMap, PUSHABLE_SOURCE_FIELDS, type PushableSourceField, type RecordPlan, } from './pushPlan.js';
 export { toCollectionDateTime } from './collectionDateTime.js';

package/dist/google/index.js

@@ -5,7 +5,7 @@ import { n as writeFileAtomic } from "../root-BcS4-Kge.js";
 import { fetchWithTimeout } from "../utils/fetch.js";
 import { d as parseIsoDate, f as parseIsoDateTime } from "../itemId-4P9S_ehz.js";
 import { t as mergeIntoExisting } from "../project-B0j_Vf_Q.js";
-import { _t as createForwardingLogger, d as storeFor, n as discoverCollections, rt as getWorkspaceRoot, vt as createHostSlot } from "../discovery-CBjI1lx9.js";
+import { _t as createForwardingLogger, d as storeFor, n as discoverCollections, rt as getWorkspaceRoot, vt as createHostSlot } from "../discovery-DIGau7M8.js";
 import { t as mulmoConfigDir } from "../paths-CkJxNZ7T.js";
 import { promises } from "node:fs";
 import path, { join } from "node:path";
@@ -41,6 +41,74 @@ var isIsoDateTimeWithOffset = (value) => {
 	return isRealCalendarDate(year, month, day) && timeInRange && offsetInRange;
 };
 //#endregion
+//#region src/google/deletePlan.ts
+var ATTENDEES_REASON = "it carries attendees — deleting an invited event withdraws it from their calendars too";
+var ALREADY_GONE_REASON = "it is no longer in Google";
+/** The message the push reports for a refusal, with the event named. */
+var deleteRefusalMessage = (eventId, refusal) => `${eventId}: left in Google because ${refusal.kind === "has-attendees" ? ATTENDEES_REASON : ALREADY_GONE_REASON}`;
+/** Decide one deletion against what Google currently holds.
+*
+*  `null` means the event is already absent — a 404/410 on the read. Nothing to
+*  delete, and reported apart from a refusal so "we chose not to" never reads
+*  as "we could not".
+*
+*  ANY attendee refuses, including the entry Google adds for the organiser. A
+*  rule that tried to exclude "only me" would have to work out which entry is
+*  the user from a payload that may not say, and being wrong there withdraws a
+*  real invitation. Solo events — the ones this feature exists for — carry no
+*  attendees at all, so the blunt rule costs them nothing. */
+function planDelete(fetched) {
+	if (fetched === null) return {
+		ok: false,
+		kind: "already-gone"
+	};
+	return fetched.attendeeCount > 0 ? {
+		ok: false,
+		kind: "has-attendees"
+	} : {
+		ok: true,
+		etag: fetched.etag
+	};
+}
+//#endregion
+//#region src/google/util.ts
+var ONE_SECOND_MS = 1e3;
+var ONE_MINUTE_MS = 6e4;
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/google/eventDerived.ts
+var stringAt = (record, key) => typeof record[key] === "string" ? record[key] : "";
+var recordsIn = (value) => Array.isArray(value) ? value.filter(isRecord) : [];
+/** The signed-in user's own `responseStatus` on this event, `""` when Google
+*  reported none.
+*
+*  `""` is the common case, not an edge one: an event with no attendees has no
+*  entry to mark `self`, which is most of a personal calendar. So it means
+*  "Google said nothing", never "not going" — filter with `!= "declined"`, not
+*  with `== "accepted"`, or every solo event disappears too.
+*
+*  Google's values: `needsAction`, `declined`, `tentative`, `accepted`. */
+function selfResponseStatus(attendees) {
+	const self = recordsIn(attendees).find((attendee) => attendee.self === true);
+	return self === void 0 ? "" : stringAt(self, "responseStatus");
+}
+var VIDEO_ENTRY_POINT = "video";
+/** The URL that joins this event's meeting, `""` when it has none.
+*
+*  Only the `video` entry point. The others are a phone number and a dial-in
+*  PIN page, and a column named for joining that sometimes holds `tel:` would
+*  be worse than one that is empty — the caller can see empty and fall back.
+*
+*  `hangoutLink` (#3229) already carries this for Google Meet; this is what
+*  reaches the events whose conference is Zoom or Teams. */
+function conferenceVideoUri(conferenceData) {
+	if (!isRecord(conferenceData)) return "";
+	const video = recordsIn(conferenceData.entryPoints).find((entry) => entry.entryPointType === VIDEO_ENTRY_POINT);
+	return video === void 0 ? "" : stringAt(video, "uri");
+}
+//#endregion
 //#region src/google/eventSpanInput.ts
 var DATE_ONLY_RE$1 = /^\d{4}-\d{2}-\d{2}$/;
 /** Whether `value` is a bare calendar day — the all-day spelling of an event
@@ -156,13 +224,6 @@ function googleSecretsDir(home) {
 	return join(home ?? homedir(), ".secrets");
 }
 //#endregion
-//#region src/google/util.ts
-var ONE_SECOND_MS = 1e3;
-var ONE_MINUTE_MS = 6e4;
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-//#endregion
 //#region src/google/clientSecret.ts
 var isNonEmptyString = (value) => typeof value === "string" && value !== "";
 var isInstalledClientSecret = (value) => {
@@ -693,6 +754,10 @@ var EVENT_SYNC_PAGE_SIZE = 2500;
 var MAX_EVENT_SYNC_PAGES = 200;
 var CALENDAR_META_PAGE_SIZE = 1;
 var HTTP_GONE = 410;
+/** A GET or DELETE on an event that is not there. Exported because the push's
+*  delete sweep has to read "already gone" as success, not as a failure to
+*  retry — a retained baseline would announce the same phantom deletion on
+*  every run. */
 var EVENT_ABSENT_STATUSES = [404, HTTP_GONE];
 /** An `If-Match` write whose etag no longer matches — someone else changed the
 *  event since it was read. */
@@ -710,6 +775,10 @@ var CANCELLED_EVENT_STATUS = "cancelled";
 *  apart while they share a sync token silently loses events (#2184). */
 var canonicalCalendarId = (calendarId) => calendarId || DEFAULT_CALENDAR_ID;
 var eventsUrl = (calendarId) => `${CALENDAR_BASE_URL}/calendars/${encodeURIComponent(canonicalCalendarId(calendarId))}/events`;
+/** People Google lists on the event, `0` when it carries none. Counts EVERY
+*  entry, including the one Google adds for the organiser: see `deletePlan.ts`
+*  for why the guard is not cleverer than that. */
+var attendeeCount = (record) => Array.isArray(record.attendees) ? record.attendees.length : 0;
 var eventTime$1 = (value) => {
 	if (!isRecord(value)) return "";
 	if (typeof value.dateTime === "string") return value.dateTime;
@@ -733,7 +802,9 @@ var toEventSummary = (value) => {
 		updated: stringField(record, "updated"),
 		transparency: stringField(record, "transparency"),
 		eventType: stringField(record, "eventType"),
-		hangoutLink: stringField(record, "hangoutLink")
+		hangoutLink: stringField(record, "hangoutLink"),
+		selfResponseStatus: selfResponseStatus(record.attendees),
+		conferenceVideoUri: conferenceVideoUri(record.conferenceData)
 	};
 };
 var toCalendarSummary = (value) => {
@@ -824,9 +895,11 @@ async function updateCalendarEvent(accessToken, input) {
 async function getCalendarEvent(accessToken, input) {
 	try {
 		const fetched = await googleRequest(CALENDAR_API_LABEL, accessToken, eventUrl(input.calendarId, input.eventId));
+		const record = asRecord(fetched);
 		return {
 			event: toEventSummary(fetched),
-			etag: stringField(asRecord(fetched), "etag")
+			etag: stringField(record, "etag"),
+			attendeeCount: attendeeCount(record)
 		};
 	} catch (error) {
 		if (isGoogleApiError(error) && EVENT_ABSENT_STATUSES.includes(error.status)) return null;
@@ -837,7 +910,10 @@ async function getCalendarEvent(accessToken, input) {
 *  return; a second delete of the same id answers 410, which surfaces as a
 *  GoogleApiError rather than being swallowed. */
 async function deleteCalendarEvent(accessToken, input) {
-	await googleRequest(CALENDAR_API_LABEL, accessToken, eventUrl(input.calendarId, input.eventId), { method: "DELETE" });
+	await googleRequest(CALENDAR_API_LABEL, accessToken, eventUrl(input.calendarId, input.eventId), {
+		method: "DELETE",
+		...input.ifMatch ? { extraHeaders: { "If-Match": input.ifMatch } } : {}
+	});
 }
 async function listCalendarEvents(accessToken, input = {}) {
 	const params = new URLSearchParams({
@@ -1619,7 +1695,9 @@ var UNPUSHABLE_EVENT_FIELDS = {
 	updated: "",
 	transparency: "",
 	eventType: "",
-	hangoutLink: ""
+	hangoutLink: "",
+	selfResponseStatus: "",
+	conferenceVideoUri: ""
 };
 /** A baseline shaped as the event it came from, so the comparison can run
 *  through the very projection that wrote the record. */
@@ -1740,7 +1818,9 @@ var liveDeps = {
 	findCollection: findCalendarCollection,
 	isLinked: async () => Boolean((await loadGoogleTokens())?.refresh_token),
 	accessToken: getGoogleAccessToken,
-	calendarMeta: liveCalendarMeta
+	calendarMeta: liveCalendarMeta,
+	fetchEvent: getCalendarEvent,
+	deleteEvent: deleteCalendarEvent
 };
 var localValue = (ctx, record, source) => {
 	const field = ctx.bySource[source];
@@ -1950,7 +2030,7 @@ var UNPUSHED_KINDS = ["conflict", "error"];
 /** Whether this outcome leaves a local edit that only exists locally, so the
 *  pull must not overwrite the record and the baseline must not advance. */
 var isUnpushed = (kind) => UNPUSHED_KINDS.includes(kind);
-function tally(slug, attempts, localDeletes) {
+function tally(slug, attempts, deletes) {
 	const outcomes = attempts.map((attempt) => attempt.outcome);
 	const count = (kind) => outcomes.filter((outcome) => outcome.kind === kind).length;
 	return {
@@ -1958,9 +2038,10 @@ function tally(slug, attempts, localDeletes) {
 		created: count("created"),
 		updated: count("updated"),
 		conflicts: count("conflict"),
-		localDeletes,
-		skipped: outcomes.flatMap((outcome) => outcome.kind === "skipped" ? [outcome.message] : []),
-		errors: outcomes.flatMap((outcome) => outcome.kind === "error" ? [outcome.message] : []),
+		localDeletes: deletes.seen,
+		deletedInGoogle: deletes.deleted.length,
+		skipped: [...outcomes.flatMap((outcome) => outcome.kind === "skipped" ? [outcome.message] : []), ...deletes.skipped],
+		errors: [...outcomes.flatMap((outcome) => outcome.kind === "error" ? [outcome.message] : []), ...deletes.errors],
 		unpushedIds: attempts.filter((attempt) => isUnpushed(attempt.outcome.kind)).map((attempt) => attempt.eventId)
 	};
 }
@@ -1989,6 +2070,69 @@ async function unsentLocalEdits(collection, workspaceRoot) {
 	const shadow = await loadCalendarShadow(schema.googleCalendar?.calendarId, workspaceRoot);
 	return locallyEditedIds(await storeFor(collection, { workspaceRoot }).list(), shadow, pushableMap(schema.googleCalendar?.map ?? {}), schema.primaryKey, schema.fields);
 }
+var noDeletes = (seen) => ({
+	seen,
+	deleted: [],
+	skipped: [],
+	errors: []
+});
+/** A delete whose event changed in Google between the guard reading it and the
+*  delete landing. Reported rather than retried: what changed may be the very
+*  thing the guard refuses, and re-reading in a loop would race the same way. */
+var staleDeleteMessage = (eventId) => `${eventId}: left in Google because it changed there while this push was checking it — press Push again to re-check`;
+/** Delete ONE event and forget its baseline, or say why it was left alone.
+*
+*  The baseline entry goes only after Google confirms, and it must go: the
+*  baseline is what `locallyDeletedIds` reads, so a kept entry would re-report
+*  the same deletion on every run forever. A refusal keeps its entry on
+*  purpose — the event IS still standing in Google, and the report is the only
+*  thing saying so.
+*
+*  The delete carries the etag the guard read. Without it, an attendee added
+*  between the two requests would be withdrawn by a decision taken before they
+*  existed — the same race `updateCalendarEvent` already guards, and it costs
+*  more here because a delete cannot be undone from this side. */
+async function propagateOneDelete(eventId, deps) {
+	const decision = planDelete(await deps.fetchEvent(eventId));
+	if (!decision.ok) {
+		if (decision.kind === "already-gone") {
+			await deps.forget(eventId);
+			return {};
+		}
+		return { skipped: [deleteRefusalMessage(eventId, decision)] };
+	}
+	try {
+		await deps.deleteEvent(eventId, decision.etag);
+	} catch (error) {
+		if (!isGoogleApiError(error)) throw error;
+		if (EVENT_ABSENT_STATUSES.includes(error.status)) {
+			await deps.forget(eventId);
+			return {};
+		}
+		if (error.status !== 412) throw error;
+		return { skipped: [staleDeleteMessage(eventId)] };
+	}
+	await deps.forget(eventId);
+	log.info("google", "calendar event deleted by push", { id: eventId });
+	return { deleted: [eventId] };
+}
+/** Carry every local deletion, when the collection opted in.
+*
+*  Sequential rather than concurrent: each one writes the shared baseline file,
+*  and an interrupted run has to leave a state the next run resumes from rather
+*  than a partially applied batch. */
+async function sweepDeletes(eventIds, propagate, deps) {
+	if (!propagate || eventIds.length === 0) return noDeletes(eventIds.length);
+	const sweep = noDeletes(eventIds.length);
+	for (const eventId of eventIds) try {
+		const one = await propagateOneDelete(eventId, deps);
+		sweep.deleted.push(...one.deleted ?? []);
+		sweep.skipped.push(...one.skipped ?? []);
+	} catch (error) {
+		sweep.errors.push(`${eventId}: could not be deleted in Google — ${errorMessage(error)}`);
+	}
+	return sweep;
+}
 /** Push one collection WITHOUT taking the calendar lock.
 *
 *  The caller must already hold it. The scheduled push→pull cycle
@@ -2027,7 +2171,18 @@ async function pushCollectionNow(collection, workspaceRoot, deps = liveDeps) {
 		});
 		await saveCalendarShadow(calendarId, pushedShadow([outcome]), workspaceRoot);
 	}
-	const result = tally(slug, attempts, locallyDeletedIds(shadow, records.map((record) => fieldText(record[schema.primaryKey]))).length);
+	const result = tally(slug, attempts, await sweepDeletes(locallyDeletedIds(shadow, records.map((record) => fieldText(record[schema.primaryKey]))), schema.googleCalendar?.propagateDeletes === true, {
+		fetchEvent: (eventId) => (deps.fetchEvent ?? getCalendarEvent)(accessToken, {
+			calendarId,
+			eventId
+		}),
+		deleteEvent: (eventId, ifMatch) => (deps.deleteEvent ?? deleteCalendarEvent)(accessToken, {
+			calendarId,
+			eventId,
+			ifMatch
+		}),
+		forget: (eventId) => saveCalendarShadow(calendarId, { [eventId]: null }, workspaceRoot)
+	}));
 	if (result.errors.length > 0) log.warn("google", "calendar push finished with errors", {
 		slug,
 		errors: result.errors.length
@@ -2985,6 +3140,6 @@ async function deleteDriveFile(accessToken, input) {
 	await googleRequest(DRIVE_API_LABEL, accessToken, `${DRIVE_FILES_URL}/${encodeURIComponent(input.fileId)}`, { method: "DELETE" });
 }
 //#endregion
-export { ALL_DAY_END_HINT, CANCELLED_EVENT_STATUS, DEFAULT_LIST_MAX_RESULTS, EVENT_TIME_HINT, 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, LONE_ALL_DAY_HINT, MAX_LIST_RESULTS, MIXED_SPAN_HINT, 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, eventTimeHint, fieldText, findClientSecretPath, getCalendarColors, getCalendarEvent, getCalendarMeta, getGoogleAccessToken, googleApiError, googleAuthFlow, googleCalendarSyncTaskDef, googleConfigDir, googleSecretsDir, googleTokenPath, groupByCalendar, groupsNeedingBackfill, heldBack, isCalendarDateOnly, 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, resolvePartialSpanInput, resolveSpanInput, resumableToken, saveCalendarShadow, saveCalendarSyncToken, saveGoogleTokens, shadowUpdates, stateLockPath, syncCalendarEvents, syncCalendarForCollection, syncCalendarGroup, syncDueCalendarCollections, syncNewCalendarCollections, syncPageParams, toCalendarMeta, toCalendarSummary, toCollectionDateTime, toCollectionRecord, toDriveFileSummary, toEventSummary, toEventTimeInput, toGoogleEventTime, toShadowEvent, toTaskListSummary, toTaskSummary, toolCalendarSyncKey, uncompleteTask, unlinkGoogle, unpushedFor, unsentEditGuard, unsentLocalEdits, updateCalendarEvent, updateTask, waitForAuthCode, windowAdvance, withCalendarLock, withCalendarStateLock, withKeyedLock, withPartialWindowError, zoneSuffixOf };
+export { ALL_DAY_END_HINT, CANCELLED_EVENT_STATUS, DEFAULT_LIST_MAX_RESULTS, EVENT_ABSENT_STATUSES, EVENT_TIME_HINT, 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, LONE_ALL_DAY_HINT, MAX_LIST_RESULTS, MIXED_SPAN_HINT, 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, conferenceVideoUri, configureGoogleHost, conflictingFields, createCalendarEvent, createDriveFile, createGoogleAuthFlow, createTask, deleteCalendarEvent, deleteDriveFile, deleteGoogleTokens, deleteRefusalMessage, deleteTask, eventTimeHint, fieldText, findClientSecretPath, getCalendarColors, getCalendarEvent, getCalendarMeta, getGoogleAccessToken, googleApiError, googleAuthFlow, googleCalendarSyncTaskDef, googleConfigDir, googleSecretsDir, googleTokenPath, groupByCalendar, groupsNeedingBackfill, heldBack, isCalendarDateOnly, 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, planDelete, planRecord, pullProtectionFor, pullableEvents, pushAndProtect, pushCalendarForCollection, pushCollectionNow, pushableMap, readDriveFile, releaseOrphanedCalendarToken, reportedAccessRole, resolveEventSpan, resolvePartialSpanInput, resolveSpanInput, resumableToken, saveCalendarShadow, saveCalendarSyncToken, saveGoogleTokens, selfResponseStatus, shadowUpdates, stateLockPath, sweepDeletes, syncCalendarEvents, syncCalendarForCollection, syncCalendarGroup, syncDueCalendarCollections, syncNewCalendarCollections, syncPageParams, toCalendarMeta, toCalendarSummary, toCollectionDateTime, toCollectionRecord, toDriveFileSummary, toEventSummary, toEventTimeInput, toGoogleEventTime, toShadowEvent, toTaskListSummary, toTaskSummary, toolCalendarSyncKey, uncompleteTask, unlinkGoogle, unpushedFor, unsentEditGuard, unsentLocalEdits, updateCalendarEvent, updateTask, waitForAuthCode, windowAdvance, withCalendarLock, withCalendarStateLock, withKeyedLock, withPartialWindowError, zoneSuffixOf };
 
 //# sourceMappingURL=index.js.map