@mulmoclaude/core 1.5.0 → 1.7.0

package/dist/google/index.js

@@ -2,7 +2,8 @@ import { t as errorMessage } from "../dist-Cwk0e12G.js";
 import { t as truncate } from "../text-CjDbP2O1.js";
 import { t as writeFileAtomic } from "../atomic-DPpdrJzO.js";
 import { fetchWithTimeout } from "../utils/fetch.js";
-import { J as getWorkspaceRoot, d as storeFor, et as createForwardingLogger, n as discoverCollections, tt as createHostSlot } from "../discovery-CKR4TOX3.js";
+import { l as parseIsoDate, u as parseIsoDateTime } from "../calendarGrid-CrGxeCOG.js";
+import { J as getWorkspaceRoot, d as storeFor, et as createForwardingLogger, n as discoverCollections, tt as createHostSlot } from "../discovery-_fjsluLx.js";
 import { promises } from "node:fs";
 import path, { join } from "node:path";
 import { randomBytes } from "node:crypto";
@@ -20,7 +21,7 @@ var log = createForwardingLogger(() => hostSlot.peek());
 //#endregion
 //#region src/google/datetime.ts
 var ISO_DATE_TIME_WITH_OFFSET_RE = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:Z|[+-](\d{2}):(\d{2}))$/;
-var FRACTIONAL_SECONDS_RE$1 = /\.\d+(?=Z|[+-])/;
+var FRACTIONAL_SECONDS_RE$2 = /\.\d+(?=Z|[+-])/;
 var MAX_HOUR = 23;
 var MAX_MINUTE = 59;
 var MAX_SECOND = 59;
@@ -29,7 +30,7 @@ var isRealCalendarDate = (year, month, day) => {
 	return roundTrip.getUTCFullYear() === year && roundTrip.getUTCMonth() === month - 1 && roundTrip.getUTCDate() === day;
 };
 var isIsoDateTimeWithOffset = (value) => {
-	const match = ISO_DATE_TIME_WITH_OFFSET_RE.exec(value.replace(FRACTIONAL_SECONDS_RE$1, ""));
+	const match = ISO_DATE_TIME_WITH_OFFSET_RE.exec(value.replace(FRACTIONAL_SECONDS_RE$2, ""));
 	if (!match) return false;
 	const [year = 0, month = 0, day = 0, hour = 0, minute = 0, second = 0] = match.slice(1, 7).map(Number);
 	const timeInRange = hour <= MAX_HOUR && minute <= MAX_MINUTE && second <= MAX_SECOND;
@@ -551,14 +552,15 @@ var isGoogleApiError = (value) => value instanceof GoogleApiError;
 /** 403 usually means the API is not enabled for the user's Cloud project —
 *  name the API so the agent's recovery guidance can be specific. */
 var googleApiError = (apiLabel, status, body) => {
-	return new GoogleApiError(status, `${apiLabel}: HTTP ${status}${status === HTTP_FORBIDDEN ? ` (is the ${apiLabel} enabled for the Cloud project?)` : ""}${body ? ` — ${truncate(body, ERROR_BODY_MAX_CHARS)}` : ""}`);
+	return new GoogleApiError(status, `${apiLabel}: HTTP ${status}${status === 403 ? ` (is the ${apiLabel} enabled for the Cloud project?)` : ""}${body ? ` — ${truncate(body, ERROR_BODY_MAX_CHARS)}` : ""}`);
 };
 async function googleRequest(apiLabel, accessToken, url, init = {}) {
-	const { contentType = "application/json", expectText = false, ...rest } = init;
+	const { contentType = "application/json", expectText = false, extraHeaders, ...rest } = init;
 	const response = await fetchWithTimeout(url, {
 		...rest,
 		timeoutMs: GOOGLE_API_TIMEOUT_MS,
 		headers: {
+			...extraHeaders,
 			Authorization: `Bearer ${accessToken}`,
 			"Content-Type": contentType
 		}
@@ -587,6 +589,16 @@ var MAX_CALENDAR_LIST_PAGES = 40;
 var EVENT_SYNC_PAGE_SIZE = 2500;
 var MAX_EVENT_SYNC_PAGES = 200;
 var HTTP_GONE = 410;
+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. */
+var HTTP_PRECONDITION_FAILED = 412;
+/** An `insert` whose caller-supplied event id is already taken. */
+var HTTP_CONFLICT = 409;
+/** Google's status for an event that was deleted; a sync window reports it so
+*  consumers can remove their copy. Single-sourced — the pull and the push both
+*  branch on it. */
+var CANCELLED_EVENT_STATUS = "cancelled";
 /** Resolve a declared calendarId to the one the API and the sync-token store
 *  both address. `||` (not `??`) so an empty string also falls back instead of
 *  building a malformed `/calendars//events` URL. Single-sourced because an
@@ -594,7 +606,7 @@ var HTTP_GONE = 410;
 *  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`;
-var eventTime = (value) => {
+var eventTime$1 = (value) => {
 	if (!isRecord(value)) return "";
 	if (typeof value.dateTime === "string") return value.dateTime;
 	if (typeof value.date === "string") return value.date;
@@ -605,8 +617,8 @@ var toEventSummary = (value) => {
 	return {
 		id: stringField(record, "id"),
 		summary: stringField(record, "summary"),
-		start: eventTime(record.start),
-		end: eventTime(record.end),
+		start: eventTime$1(record.start),
+		end: eventTime$1(record.end),
 		htmlLink: stringField(record, "htmlLink"),
 		status: stringField(record, "status"),
 		colorId: stringField(record, "colorId")
@@ -622,7 +634,8 @@ var toCalendarSummary = (value) => {
 		accessRole: stringField(record, "accessRole"),
 		backgroundColor: stringField(record, "backgroundColor"),
 		foregroundColor: stringField(record, "foregroundColor"),
-		colorId: stringField(record, "colorId")
+		colorId: stringField(record, "colorId"),
+		timeZone: stringField(record, "timeZone")
 	};
 };
 var toColorMap = (value) => {
@@ -638,13 +651,21 @@ var toColorMap = (value) => {
 /** Kept as a named export for the existing unit tests / callers; the shared
 *  helper now carries the wording. */
 var calendarApiError = (status, body) => googleApiError(CALENDAR_API_LABEL, status, body);
+/** Normalise either spelling of a span into the pair the API body carries. */
+var resolveEventSpan = (span) => "start" in span ? {
+	start: span.start,
+	end: span.end
+} : {
+	start: { dateTime: span.startDateTime },
+	end: { dateTime: span.endDateTime }
+};
 async function createCalendarEvent(accessToken, input) {
 	const body = {
 		summary: input.summary,
 		description: input.description,
-		start: { dateTime: input.startDateTime },
-		end: { dateTime: input.endDateTime },
-		...input.colorId ? { colorId: input.colorId } : {}
+		...resolveEventSpan(input),
+		...input.colorId ? { colorId: input.colorId } : {},
+		...input.eventId ? { id: input.eventId } : {}
 	};
 	return toEventSummary(await googleRequest(CALENDAR_API_LABEL, accessToken, eventsUrl(input.calendarId), {
 		method: "POST",
@@ -657,11 +678,17 @@ var eventUrl = (calendarId, eventId) => `${eventsUrl(calendarId)}/${encodeURICom
 *  `undefined` means "leave as is" and `""` means "clear it", so the two cannot
 *  be collapsed: dropping `description: ""` would silently ignore a request to
 *  empty the body text. Pure so the distinction is testable without network. */
+/** One end of the patch: the structured value if given, else the flat one
+*  wrapped, else absent (= leave it alone). */
+var eventEnd = (key, structured, flat) => {
+	if (structured !== void 0) return { [key]: structured };
+	return flat !== void 0 ? { [key]: { dateTime: flat } } : {};
+};
 var buildEventPatch = (input) => ({
 	...input.summary !== void 0 ? { summary: input.summary } : {},
 	...input.description !== void 0 ? { description: input.description } : {},
-	...input.startDateTime !== void 0 ? { start: { dateTime: input.startDateTime } } : {},
-	...input.endDateTime !== void 0 ? { end: { dateTime: input.endDateTime } } : {},
+	...eventEnd("start", input.start, input.startDateTime),
+	...eventEnd("end", input.end, input.endDateTime),
 	...input.colorId ? { colorId: input.colorId } : {}
 });
 /** Edit an existing event in place. PATCH, not PUT — a PUT would need the whole
@@ -670,9 +697,28 @@ var buildEventPatch = (input) => ({
 async function updateCalendarEvent(accessToken, input) {
 	return toEventSummary(await googleRequest(CALENDAR_API_LABEL, accessToken, eventUrl(input.calendarId, input.eventId), {
 		method: "PATCH",
-		body: JSON.stringify(buildEventPatch(input))
+		body: JSON.stringify(buildEventPatch(input)),
+		...input.ifMatch ? { extraHeaders: { "If-Match": input.ifMatch } } : {}
 	}));
 }
+/** Read ONE event, or null when it is gone (404 / 410).
+*
+*  A push needs Google's current value per changed record to tell a local-only
+*  edit from a both-sides conflict. Deliberately not `syncCalendarEvents`: that
+*  consumes the calendar's sync token, and the token's window is served once —
+*  spending it here would make the next pull miss everything in it. */
+async function getCalendarEvent(accessToken, input) {
+	try {
+		const fetched = await googleRequest(CALENDAR_API_LABEL, accessToken, eventUrl(input.calendarId, input.eventId));
+		return {
+			event: toEventSummary(fetched),
+			etag: stringField(asRecord(fetched), "etag")
+		};
+	} catch (error) {
+		if (isGoogleApiError(error) && EVENT_ABSENT_STATUSES.includes(error.status)) return null;
+		throw error;
+	}
+}
 /** Remove an event. Google answers 204 with no body, so there is nothing to
 *  return; a second delete of the same id answers 410, which surfaces as a
 *  GoogleApiError rather than being swallowed. */
@@ -752,6 +798,17 @@ async function collectCalendarPages(fetchPage, maxPages = MAX_CALENDAR_LIST_PAGE
 /** The calendars the user has added/subscribed to (primary + secondary +
 *  shared), each with its id, name and colour, following pagination. Needs the
 *  calendar-list read scope (GOOGLE_CALENDARLIST_SCOPE). */
+/** One calendar's own resource, addressed by id rather than looked up in the
+*  user's list.
+*
+*  `calendarList` only holds calendars the user has ADDED; a calendar shared
+*  with them can be readable and writable by id without appearing there. This is
+*  how a push learns such a calendar's `timeZone`. Note the resource carries no
+*  `accessRole` — that is a calendarList property — so reachability here says
+*  nothing about writability. */
+async function getCalendar(accessToken, calendarId) {
+	return toCalendarSummary(await googleRequest(CALENDAR_API_LABEL, accessToken, `${CALENDAR_BASE_URL}/calendars/${encodeURIComponent(canonicalCalendarId(calendarId))}`));
+}
 async function listCalendars(accessToken) {
 	return collectCalendarPages(async (pageToken) => {
 		const params = new URLSearchParams({ maxResults: String(CALENDAR_LIST_PAGE_SIZE) });
@@ -780,25 +837,25 @@ function calendarSyncStatePath(workspaceRoot) {
 	return path.join(workspaceRoot ?? getWorkspaceRoot(), "data", "calendar", ".sync-state.json");
 }
 var calendarKey = canonicalCalendarId;
-async function readState(workspaceRoot) {
+async function readState$1(workspaceRoot) {
 	const stored = await readJsonOrNull(calendarSyncStatePath(workspaceRoot));
 	return stored?.tokens ? stored : { tokens: {} };
 }
-var writeQueue = { tail: Promise.resolve() };
-async function updateState(mutate, workspaceRoot) {
-	const run = writeQueue.tail.then(async () => {
-		const state = await readState(workspaceRoot);
+var writeQueue$1 = { tail: Promise.resolve() };
+async function updateState$1(mutate, workspaceRoot) {
+	const run = writeQueue$1.tail.then(async () => {
+		const state = await readState$1(workspaceRoot);
 		await writeJsonAtomicWithMode(calendarSyncStatePath(workspaceRoot), { tokens: mutate(state.tokens) }, SYNC_STATE_MODE);
 	});
-	writeQueue.tail = run.catch(() => void 0);
+	writeQueue$1.tail = run.catch(() => void 0);
 	return await run;
 }
 async function loadCalendarSyncToken(calendarId, workspaceRoot) {
-	return (await readState(workspaceRoot)).tokens[calendarKey(calendarId)] ?? null;
+	return (await readState$1(workspaceRoot)).tokens[calendarKey(calendarId)] ?? null;
 }
 async function saveCalendarSyncToken(calendarId, syncToken, workspaceRoot) {
 	const stored = calendarKey(calendarId);
-	await updateState((tokens) => ({
+	await updateState$1((tokens) => ({
 		...tokens,
 		[stored]: syncToken
 	}), workspaceRoot);
@@ -807,7 +864,60 @@ async function saveCalendarSyncToken(calendarId, syncToken, workspaceRoot) {
 *  starts a clean full sync. */
 async function clearCalendarSyncToken(calendarId, workspaceRoot) {
 	const dropped = calendarKey(calendarId);
-	await updateState((tokens) => Object.fromEntries(Object.entries(tokens).filter(([key]) => key !== dropped)), workspaceRoot);
+	await updateState$1((tokens) => Object.fromEntries(Object.entries(tokens).filter(([key]) => key !== dropped)), workspaceRoot);
+}
+//#endregion
+//#region src/google/calendarPushState.ts
+var PUSH_STATE_MODE = 384;
+/** `<workspace>/data/calendar/.push-state.json` */
+function calendarPushStatePath(workspaceRoot) {
+	return path.join(workspaceRoot ?? getWorkspaceRoot(), "data", "calendar", ".push-state.json");
+}
+var toShadowEvent = (event) => ({
+	summary: event.summary,
+	start: event.start,
+	end: event.end,
+	colorId: event.colorId
+});
+async function readState(workspaceRoot) {
+	const stored = await readJsonOrNull(calendarPushStatePath(workspaceRoot));
+	return stored?.events ? stored : { events: {} };
+}
+var writeQueue = { tail: Promise.resolve() };
+async function updateState(mutate, workspaceRoot) {
+	const run = writeQueue.tail.then(async () => {
+		const state = await readState(workspaceRoot);
+		await writeJsonAtomicWithMode(calendarPushStatePath(workspaceRoot), { events: mutate(state.events) }, PUSH_STATE_MODE);
+	});
+	writeQueue.tail = run.catch(() => void 0);
+	return await run;
+}
+async function loadCalendarShadow(calendarId, workspaceRoot) {
+	return (await readState(workspaceRoot)).events[canonicalCalendarId(calendarId)] ?? {};
+}
+/** Apply a batch to one calendar's baseline. `null` removes an entry (the event
+*  was cancelled), so a cancel-then-recreate cannot resume from a stale one.
+*  Merged rather than replaced: a sync window describes only what changed. */
+function mergeShadow(current, updates) {
+	const removed = new Set(Object.entries(updates).filter(([, entry]) => entry === null).map(([eventId]) => eventId));
+	const kept = Object.entries(current).filter(([eventId]) => !removed.has(eventId));
+	const written = Object.entries(updates).filter((entry) => entry[1] !== null);
+	return Object.fromEntries([...kept, ...written]);
+}
+async function saveCalendarShadow(calendarId, updates, workspaceRoot) {
+	if (Object.keys(updates).length === 0) return;
+	const key = canonicalCalendarId(calendarId);
+	await updateState((events) => ({
+		...events,
+		[key]: mergeShadow(events[key] ?? {}, updates)
+	}), workspaceRoot);
+}
+/** Drop one calendar's whole baseline. Called wherever the sync token is
+*  cleared: a baseline outliving its token would let a push diff against events
+*  the workspace no longer holds. */
+async function clearCalendarShadow(calendarId, workspaceRoot) {
+	const dropped = canonicalCalendarId(calendarId);
+	await updateState((events) => Object.fromEntries(Object.entries(events).filter(([key]) => key !== dropped)), workspaceRoot);
 }
 //#endregion
 //#region src/google/collectionDateTime.ts
@@ -815,9 +925,9 @@ async function clearCalendarSyncToken(calendarId, workspaceRoot) {
 var ALL_DAY_CLOCK = "00:00";
 var DATE_ONLY_RE = /^\d{4}-\d{2}-\d{2}$/;
 /** RFC3339 zone designator: `Z`, `+09:00`, `-0500`. */
-var ZONE_SUFFIX_RE = /(?:Z|[+-]\d{2}:?\d{2})$/;
+var ZONE_SUFFIX_RE$1 = /(?:Z|[+-]\d{2}:?\d{2})$/;
 /** Fractional seconds have no place in the collection datetime shape. */
-var FRACTIONAL_SECONDS_RE = /\.\d+$/;
+var FRACTIONAL_SECONDS_RE$1 = /\.\d+$/;
 /** Normalise one Google Calendar time value for storage in a `datetime` field.
 *  Anything that isn't a recognisable Google shape (empty string, non-string,
 *  free text) is returned untouched — the record lint should report it rather
@@ -827,13 +937,12 @@ function toCollectionDateTime(value) {
 	const trimmed = value.trim();
 	if (DATE_ONLY_RE.test(trimmed)) return `${trimmed}T${ALL_DAY_CLOCK}`;
 	if (!trimmed.includes("T")) return value;
-	return trimmed.replace(ZONE_SUFFIX_RE, "").replace(FRACTIONAL_SECONDS_RE, "");
+	return trimmed.replace(ZONE_SUFFIX_RE$1, "").replace(FRACTIONAL_SECONDS_RE$1, "");
 }
 //#endregion
 //#region src/google/collectionSync.ts
 var GOOGLE_CALENDAR_SYNC_TASK_ID = "system:google-calendar-sync";
 var DEFAULT_SYNC_INTERVAL_MS = 3600 * 1e3;
-var CANCELLED_STATUS = "cancelled";
 var DATETIME_FIELD_TYPE = "datetime";
 /** Own-property lookup, mirroring what the record lint reads: a spec reachable
 *  only through the prototype chain is not a DECLARED field, so it must not
@@ -889,7 +998,7 @@ async function applyEvent(collection, event, workspaceRoot) {
 			kind: "unwritable",
 			message: `collection '${collection.slug}' is read-only`
 		};
-		if (event.status === CANCELLED_STATUS) {
+		if (event.status === "cancelled") {
 			const deleted = await store.delete(event.id);
 			return classifyDelete(event.id, deleted.kind);
 		}
@@ -905,6 +1014,7 @@ async function applyEvent(collection, event, workspaceRoot) {
 }
 async function restartFullSync(accessToken, calendarId, workspaceRoot) {
 	await clearCalendarSyncToken(calendarId, workspaceRoot);
+	await clearCalendarShadow(calendarId, workspaceRoot);
 	return await syncCalendarEvents(accessToken, { calendarId });
 }
 /** Serialise `run` against whatever is already running for `key`.
@@ -942,8 +1052,16 @@ var calendarLocks = /* @__PURE__ */ new Map();
 *  writes are upserts by event id — but it is a wasted full walk. Queued, the
 *  second pass resumes from the token the first just stored and fetches only
 *  what is genuinely new. */
+/** Serialise anything that touches ONE calendar's sync state.
+*
+*  Shared with the push path (#2598), not only the pull doors: a push that
+*  overtakes an in-flight pull would record a baseline for events the pull is
+*  still writing, so the next push would diff against a future it never saw. */
+async function withCalendarLock(calendarId, run) {
+	return await withKeyedLock(calendarLocks, canonicalCalendarId(calendarId), run);
+}
 async function syncCalendarGroup(calendarId, collections, workspaceRoot) {
-	return await withKeyedLock(calendarLocks, canonicalCalendarId(calendarId), () => syncCalendarGroupNow(calendarId, collections, workspaceRoot));
+	return await withCalendarLock(calendarId, () => syncCalendarGroupNow(calendarId, collections, workspaceRoot));
 }
 async function syncCalendarGroupNow(calendarId, collections, workspaceRoot) {
 	const accessToken = await getGoogleAccessToken();
@@ -967,9 +1085,15 @@ async function syncCalendarGroupNow(calendarId, collections, workspaceRoot) {
 		});
 		return results;
 	}
+	await saveCalendarShadow(calendarId, shadowUpdates(result.events), workspaceRoot);
 	if (result.nextSyncToken) await advanceToken(calendarId, result.nextSyncToken, collections, workspaceRoot);
 	return results;
 }
+/** The baseline this window establishes: what Google now says per event, and
+*  `null` for a cancelled one so a recreate cannot resume from a dead baseline. */
+function shadowUpdates(events) {
+	return Object.fromEntries(events.map((event) => [event.id, event.status === "cancelled" ? null : toShadowEvent(event)]));
+}
 /** Save the window's token unless every collection that consumed it was deleted
 *  while the sync was in flight.
 *
@@ -1061,6 +1185,7 @@ async function releaseOrphanedCalendarToken(deleted, workspaceRoot) {
 		const orphaned = orphanedCalendarId(deleted, (await discoverCollections({ workspaceRoot })).map((collection) => collection.schema));
 		if (orphaned === null) return null;
 		await clearCalendarSyncToken(orphaned, workspaceRoot);
+		await clearCalendarShadow(orphaned, workspaceRoot);
 		log.info("google", "cleared the sync token of a calendar no collection reads any more", { calendarId: orphaned });
 		return orphaned;
 	} catch (error) {
@@ -1170,6 +1295,522 @@ function googleCalendarSyncTaskDef(opts) {
 	};
 }
 //#endregion
+//#region src/google/pushDateTime.ts
+/** RFC3339 zone designator: `Z`, `+09:00`, `-0500`. */
+var ZONE_SUFFIX_RE = /(?:Z|[+-]\d{2}:?\d{2})$/;
+var FRACTIONAL_SECONDS_RE = /\.\d+$/;
+var TWO_DIGITS_RE = /^\d{2}$/;
+var CLOCK_SEPARATOR = ":";
+var DATE_TIME_SEPARATOR = "T";
+var MIN_CLOCK_SEGMENTS = 2;
+var MAX_CLOCK_SEGMENTS = 3;
+var WHOLE_MINUTE_SECONDS = "00";
+var MAX_SECONDS = 59;
+/** Whether `value` is a real calendar day (`2026-02-30` is not).
+*
+*  Delegated to the parser the record lint, the calendar grid and the day view
+*  already share, so the push agrees with the rest of the app on what a valid
+*  stored date IS — and rejects an impossible one here instead of turning it
+*  into an opaque Google 400. */
+var isCalendarDate = (value) => parseIsoDate(value) !== null;
+/** A value Google already accepts verbatim, as the event time to send, or null.
+*
+*  Reached when the schema maps `start` onto a `string` field: `projectValue`
+*  normalises only `datetime` fields, so that column holds Google's own text,
+*  zone and all. The civil part is still validated — matching a trailing `Z` is
+*  not evidence that the rest is a date-time. */
+function rawGoogleTime(value) {
+	if (isCalendarDate(value)) return { date: value };
+	const zone = value.match(ZONE_SUFFIX_RE)?.[0];
+	if (zone === void 0) return null;
+	return parseIsoDateTime(value.slice(0, value.length - zone.length).replace(FRACTIONAL_SECONDS_RE, "")) === null ? null : { dateTime: value };
+}
+/** Google's own all-day `end` is EXCLUSIVE — a single day on the 12th ends on
+*  the 13th. The pull stores that as `2026-05-13T00:00` and this takes the date
+*  part straight back, so the exclusive end round-trips untouched. Looks
+*  off-by-one; adjusting it would shorten every all-day event by a day. */
+function allDayFrom(datePart) {
+	return { date: datePart };
+}
+/** Split `HH:MM[:SS]` into RFC3339's always-three segments, or null.
+*
+*  Split rather than one regex: expressing the optional seconds as `(?::(\d{2}))?`
+*  nests a quantifier inside a quantified group, which the ReDoS lint rejects. */
+function clockSegments(clockPart) {
+	const segments = clockPart.split(CLOCK_SEPARATOR);
+	if (segments.length < MIN_CLOCK_SEGMENTS || segments.length > MAX_CLOCK_SEGMENTS) return null;
+	if (!segments.every((segment) => TWO_DIGITS_RE.test(segment))) return null;
+	const [hours, minutes, seconds] = segments;
+	if (seconds !== void 0 && Number(seconds) > MAX_SECONDS) return null;
+	return [
+		hours,
+		minutes,
+		seconds ?? WHOLE_MINUTE_SECONDS
+	].join(CLOCK_SEPARATOR);
+}
+/** `YYYY-MM-DDTHH:MM[:SS]` → its date and its RFC3339 clock, or null.
+*
+*  Validity comes from the shared strict parser, so an out-of-range clock or an
+*  impossible day is refused here rather than sent to Google. */
+function parseStoredDateTime(value) {
+	if (parseIsoDateTime(value) === null) return null;
+	const [datePart, clockPart, ...extra] = value.split(DATE_TIME_SEPARATOR);
+	if (datePart === void 0 || clockPart === void 0 || extra.length > 0) return null;
+	const clock = clockSegments(clockPart);
+	return clock === null ? null : {
+		datePart,
+		clock
+	};
+}
+/** The zone designator to re-attach, or null when `previous` carries none. */
+function zoneSuffixOf(previous) {
+	if (previous === void 0) return null;
+	return previous.match(ZONE_SUFFIX_RE)?.[0] ?? null;
+}
+/** Build the event time to send for one field.
+*
+*  `previous` is the value Google last reported for this event, absent for a
+*  locally-created record. Returns null when `local` is neither a stored
+*  datetime nor a raw Google value — the caller reports that record rather than
+*  letting this invent a time Google would silently accept. */
+function toGoogleEventTime(local, previous, calendarTimeZone) {
+	if (typeof local !== "string") return null;
+	const trimmed = local.trim();
+	if (trimmed.length === 0) return null;
+	const raw = rawGoogleTime(trimmed);
+	if (raw !== null) return raw;
+	const parts = parseStoredDateTime(trimmed);
+	if (parts === null) return null;
+	if (previous !== void 0 && isCalendarDate(previous)) return allDayFrom(parts.datePart);
+	const zone = zoneSuffixOf(previous);
+	const dateTime = `${parts.datePart}${DATE_TIME_SEPARATOR}${parts.clock}`;
+	return zone === null ? {
+		dateTime,
+		timeZone: calendarTimeZone
+	} : { dateTime: `${dateTime}${zone}` };
+}
+//#endregion
+//#region src/google/pushPlan.ts
+/** The event fields Google lets a caller write. `htmlLink` and `status` are
+*  read-only, so a record column mapped to either is ignored here rather than
+*  rejected — the mapping was authored for the pull, and a push has no business
+*  invalidating it. */
+var PUSHABLE_SOURCE_FIELDS = [
+	"summary",
+	"start",
+	"end",
+	"colorId"
+];
+var isPushableSource = (source) => PUSHABLE_SOURCE_FIELDS.includes(source);
+/** The subset of a schema's `map` a push can act on: collection field → event field. */
+function pushableMap(map) {
+	return Object.fromEntries(Object.entries(map).filter((entry) => isPushableSource(entry[1])));
+}
+/** Event field → the record column feeding it. The schema authors the map the
+*  other way round (for the pull); a push looks up by event field. Two columns
+*  mapped to one event field is already ambiguous for the pull — last wins. */
+function bySourceField(map) {
+	return Object.fromEntries(Object.entries(map).map(([field, source]) => [source, field]));
+}
+/** Google accepts a caller-chosen event id of 5-1024 base32hex characters. A
+*  record id outside that (a semantic id like `team-standup`) cannot be used,
+*  and v1 reports it instead of re-keying the record — see the plan. */
+var CLIENT_EVENT_ID_RE = /^[0-9a-v]{5,1024}$/;
+var isClientSettableEventId = (eventId) => CLIENT_EVENT_ID_RE.test(eventId);
+/** A field's value as comparable/sendable text.
+*
+*  Absent, null and `""` all collapse to `""`: Google reports an inherited colour
+*  as `""` while the record file may omit the key entirely, and treating those as
+*  different would report a local edit on every single push.
+*
+*  A non-primitive is JSON-encoded rather than left to `String`, whose
+*  `[object Object]` would make two DIFFERENT objects compare equal — a
+*  silently-skipped edit. */
+var fieldText = (value) => {
+	if (value === void 0 || value === null) return "";
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return String(value);
+	return JSON.stringify(value) ?? "";
+};
+/** A stored datetime with no seconds — what the collection's own date-time input
+*  produces. Google's values always carry seconds, so the pull writes them and a
+*  hand-typed value does not. */
+var SECONDLESS_DATETIME_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}$/;
+var WHOLE_MINUTE = ":00";
+/** Field text with `…T09:30` and `…T09:30:00` collapsed to one spelling.
+*
+*  Without this, a record the user typed a time into never stops looking edited:
+*  the push writes it, Google answers with seconds, the baseline projection keeps
+*  them, and the seconds-less record then differs from its own baseline on every
+*  later push — re-PATCHing the same event on every click, forever.
+*
+*  A value that carries a zone offset (a `start` mapped onto a `string` field) is
+*  left alone: it is Google's own text on both sides already. */
+var comparableText = (value) => {
+	const text = fieldText(value);
+	return SECONDLESS_DATETIME_RE.test(text) ? `${text}${WHOLE_MINUTE}` : text;
+};
+/** A baseline shaped as the event it came from, so the comparison can run
+*  through the very projection that wrote the record. `htmlLink`/`status` are
+*  never pushable, so their absence from the baseline cannot matter. */
+var asEventSummary = (eventId, shadow) => ({
+	id: eventId,
+	htmlLink: "",
+	status: "",
+	...shadow
+});
+/** What the record WOULD hold if nobody had edited it since the baseline.
+*
+*  Deliberately `toCollectionRecord` — the same function the pull writes with —
+*  so "unchanged" here means exactly "the pull would produce this". A private
+*  re-implementation would drift from it and report phantom edits. */
+function baselineRecord(eventId, shadow, map, primaryKey, fields) {
+	return toCollectionRecord(asEventSummary(eventId, shadow), map, primaryKey, fields);
+}
+/** The mapped fields whose local value no longer matches the baseline. */
+function locallyChangedFields(record, baseline, map) {
+	return Object.entries(map).filter(([field]) => comparableText(record[field]) !== comparableText(baseline[field])).map(([, source]) => source);
+}
+/** The fields Google changed since the baseline, restricted to the ones the
+*  local edit touches.
+*
+*  Field-level on purpose: Google moving an event the user retitled locally is
+*  not a conflict, because the patch only carries the title. Comparing whole
+*  events would refuse those pushes for no reason. */
+function conflictingFields(shadow, current, changed) {
+	return changed.filter((source) => comparableText(shadow[source]) !== comparableText(current[source]));
+}
+/** Classify one record against its baseline, before Google is consulted.
+*
+*  No baseline means the record never came from a sync, so it is local-only and
+*  has to be created. Google is queried ONLY for a `changed` record, which is
+*  what keeps a push over a large collection cheap. */
+function planRecord(eventId, record, shadow, map, primaryKey, fields) {
+	if (shadow === void 0) return { kind: "create" };
+	const changed = locallyChangedFields(record, baselineRecord(eventId, shadow, map, primaryKey, fields), map);
+	return changed.length === 0 ? { kind: "unchanged" } : {
+		kind: "changed",
+		fields: changed
+	};
+}
+/** Whether an event that already holds this record's id may be adopted as its
+*  baseline.
+*
+*  A 409 from `insert` usually means a previous push created the event but its
+*  baseline never landed. It can ALSO mean an unrelated event happens to hold
+*  this id, and adopting that would bind the record to a stranger's event — so
+*  adoption needs evidence the two are the same logical event, not just the same
+*  id (Codex review).
+*
+*  The evidence is that the remote event ALREADY equals what this record would
+*  write. Adoption then records a baseline and writes nothing, so it cannot
+*  modify whatever that event is. Anything else is refused. */
+function mayAdoptExisting(eventId, record, existing, map, primaryKey, fields) {
+	return locallyChangedFields(record, baselineRecord(eventId, existing, map, primaryKey, fields), map).length === 0;
+}
+/** Record ids the baseline knows but the collection no longer holds — deleted
+*  locally. v1 reports the count and pushes nothing: `calendarDeleteEvent`
+*  removes the event for every attendee and cannot be undone. */
+function locallyDeletedIds(shadow, presentIds) {
+	const present = new Set(presentIds);
+	return Object.keys(shadow).filter((eventId) => !present.has(eventId));
+}
+//#endregion
+//#region src/google/collectionPush.ts
+/** Access roles that may write events. `reader` / `freeBusyReader` cannot, and a
+*  push under them fails per event with an opaque 403 — checked once up front so
+*  the user is told the real reason. */
+var WRITABLE_ACCESS_ROLES = ["owner", "writer"];
+/** Whether to refuse the whole push before touching a single event.
+*
+*  Only on POSITIVE evidence of a non-writable role. An unlisted calendar is
+*  unknown and must fall through: hard-denying it would block the feature
+*  outright for a calendar the user can in fact write to. Those attempts surface
+*  Google's own 403 per record if the write really is not allowed. */
+var isDeniedAccessRole = (accessRole) => accessRole !== null && !WRITABLE_ACCESS_ROLES.includes(accessRole);
+/** Resolve the calendar a schema names, for its writability and its timezone.
+*
+*  The list is consulted first because only it reports `accessRole`, which is
+*  what lets a read-only calendar be refused with the real reason instead of an
+*  opaque per-event 403. `"primary"` is matched on the `primary` flag, not the
+*  id — the primary calendar's own id is the account's email address, which never
+*  equals the literal the schema declares.
+*
+*  A calendar absent from the list is NOT denied: it is fetched by id for its
+*  timezone and its role left unknown. A 404 there means the calendar really is
+*  unreachable, and propagates as a `failed` outcome. */
+async function liveCalendarMeta(accessToken, calendarId) {
+	const key = canonicalCalendarId(calendarId);
+	const calendars = await listCalendars(accessToken);
+	const listed = key === "primary" ? calendars.find((calendar) => calendar.primary) : calendars.find((calendar) => calendar.id === key);
+	if (listed) return {
+		accessRole: listed.accessRole,
+		timeZone: listed.timeZone
+	};
+	const direct = await getCalendar(accessToken, calendarId);
+	log.info("google", "calendar is not in the user's list — pushing without an up-front role check", { calendarId: key });
+	return {
+		accessRole: null,
+		timeZone: direct.timeZone
+	};
+}
+async function findCalendarCollection(slug, workspaceRoot) {
+	return (await discoverCollections({ workspaceRoot })).find((collection) => collection.slug === slug && collection.schema.googleCalendar) ?? null;
+}
+var liveDeps = {
+	findCollection: findCalendarCollection,
+	isLinked: async () => Boolean((await loadGoogleTokens())?.refresh_token),
+	accessToken: getGoogleAccessToken,
+	calendarMeta: liveCalendarMeta
+};
+var localValue = (ctx, record, source) => {
+	const field = ctx.bySource[source];
+	return field === void 0 ? void 0 : record[field];
+};
+/** One end of the span, rebuilt from the stored clock plus whatever the baseline
+*  remembers about the original (zone, all-day). */
+function eventTime(ctx, record, source, previous) {
+	const value = localValue(ctx, record, source);
+	if (value === void 0) return {
+		ok: false,
+		reason: `no \`${source}\` field is mapped`
+	};
+	const time = toGoogleEventTime(value, previous, ctx.timeZone);
+	if (time === null) return {
+		ok: false,
+		reason: `\`${source}\` is not a date-time Google accepts (got ${JSON.stringify(value)})`
+	};
+	if ("dateTime" in time && time.timeZone === "") return {
+		ok: false,
+		reason: `the calendar reports no timezone, so \`${source}\` cannot be sent without one`
+	};
+	return {
+		ok: true,
+		time
+	};
+}
+async function createFromRecord(ctx, eventId, record) {
+	if (!isClientSettableEventId(eventId)) return {
+		kind: "skipped",
+		message: `${eventId}: the record id cannot be used as a Google event id (needs 5-1024 characters from 0-9a-v)`
+	};
+	const start = eventTime(ctx, record, "start", void 0);
+	const end = eventTime(ctx, record, "end", void 0);
+	if (!start.ok) return {
+		kind: "skipped",
+		message: `${eventId}: ${start.reason}`
+	};
+	if (!end.ok) return {
+		kind: "skipped",
+		message: `${eventId}: ${end.reason}`
+	};
+	const colorId = fieldText(localValue(ctx, record, "colorId"));
+	return {
+		kind: "created",
+		event: await createCalendarEvent(ctx.accessToken, {
+			eventId,
+			calendarId: ctx.calendarId,
+			summary: fieldText(localValue(ctx, record, "summary")),
+			start: start.time,
+			end: end.time,
+			...colorId ? { colorId } : {}
+		})
+	};
+}
+/** Only the fields the local edit touched — PATCH semantics, so an untouched
+*  attendee list / recurrence rule is left alone. */
+function buildPatch(ctx, record, changed, shadow) {
+	const resolved = ["start", "end"].filter((source) => changed.includes(source)).map((source) => ({
+		source,
+		result: eventTime(ctx, record, source, shadow[source])
+	}));
+	const [failure] = resolved.flatMap((entry) => entry.result.ok ? [] : [entry.result.reason]);
+	if (failure !== void 0) return {
+		ok: false,
+		reason: failure
+	};
+	const colorId = fieldText(localValue(ctx, record, "colorId"));
+	if (changed.includes("colorId") && colorId === "") return {
+		ok: false,
+		reason: "Google cannot clear an event colour once set"
+	};
+	return {
+		ok: true,
+		patch: {
+			...changed.includes("summary") ? { summary: fieldText(localValue(ctx, record, "summary")) } : {},
+			...changed.includes("colorId") ? { colorId } : {},
+			...Object.fromEntries(resolved.flatMap((entry) => entry.result.ok ? [[entry.source, entry.result.time]] : []))
+		}
+	};
+}
+async function updateFromRecord(ctx, eventId, record, changed, shadow) {
+	const fetched = await getCalendarEvent(ctx.accessToken, {
+		calendarId: ctx.calendarId,
+		eventId
+	});
+	if (fetched === null || fetched.event.status === "cancelled") return {
+		kind: "skipped",
+		message: `${eventId}: the event no longer exists in Google — sync first, then re-create it`
+	};
+	if (conflictingFields(shadow, toShadowEvent(fetched.event), changed).length > 0) return { kind: "conflict" };
+	const built = buildPatch(ctx, record, changed, shadow);
+	if (!built.ok) return {
+		kind: "skipped",
+		message: `${eventId}: ${built.reason}`
+	};
+	try {
+		return {
+			kind: "updated",
+			event: await updateCalendarEvent(ctx.accessToken, {
+				eventId,
+				calendarId: ctx.calendarId,
+				ifMatch: fetched.etag,
+				...built.patch
+			})
+		};
+	} catch (error) {
+		if (isGoogleApiError(error) && error.status === 412) return { kind: "conflict" };
+		throw error;
+	}
+}
+/** Create, recovering from the one 409 that is provably safe to recover from.
+*
+*  A 409 means the id is taken, which is USUALLY a previous push whose baseline
+*  never landed. It can also be an unrelated event that happens to hold this id,
+*  so the recovery never writes: it adopts the baseline only when the remote
+*  event already equals what this record would write, and otherwise reports the
+*  fix. Patching whatever answered the 409 would let a push modify a stranger's
+*  event (Codex review).
+*
+*  Refusal is not a dead end — a Sync writes both the record and its baseline,
+*  after which the record pushes normally. */
+async function createOrAdopt(ctx, eventId, record) {
+	try {
+		return await createFromRecord(ctx, eventId, record);
+	} catch (error) {
+		if (!isGoogleApiError(error) || error.status !== 409) throw error;
+		const fetched = await getCalendarEvent(ctx.accessToken, {
+			calendarId: ctx.calendarId,
+			eventId
+		});
+		if (fetched === null) throw error;
+		if (mayAdoptExisting(eventId, record, toShadowEvent(fetched.event), ctx.map, ctx.primaryKey, ctx.fields)) return {
+			kind: "unchanged",
+			event: fetched.event
+		};
+		return {
+			kind: "skipped",
+			message: `${eventId}: an event with this id already exists in Google and differs from this record — press Sync to adopt it, then push again`
+		};
+	}
+}
+/** A 403 on a write is a permissions answer, but `googleApiError` appends the
+*  "is the API enabled for the Cloud project?" hint to every 403 — true for a
+*  disabled API, misleading here. Reached when the up-front role check could not
+*  run because the calendar is not in the user's list, which is exactly when the
+*  user needs the real reason. */
+function writeFailure(eventId, error) {
+	if (isGoogleApiError(error) && error.status === 403) return {
+		kind: "skipped",
+		message: `${eventId}: Google refused the write — you may not have permission to change events on this calendar`
+	};
+	return {
+		kind: "error",
+		message: `${eventId}: ${String(error)}`
+	};
+}
+async function pushRecord(ctx, eventId, record) {
+	try {
+		const shadow = ctx.shadow[eventId];
+		const plan = planRecord(eventId, record, shadow, ctx.map, ctx.primaryKey, ctx.fields);
+		if (plan.kind === "unchanged") return { kind: "unchanged" };
+		if (plan.kind === "create" || shadow === void 0) return await createOrAdopt(ctx, eventId, record);
+		return await updateFromRecord(ctx, eventId, record, plan.fields, shadow);
+	} catch (error) {
+		return writeFailure(eventId, error);
+	}
+}
+/** The baseline an outcome establishes, so the next push sees the record as
+*  unchanged instead of pushing it again. Empty for anything that wrote nothing
+*  and had no baseline to repair. */
+function pushedShadow(outcomes) {
+	const written = outcomes.flatMap((outcome) => "event" in outcome && outcome.event !== void 0 ? [outcome.event] : []);
+	return Object.fromEntries(written.map((event) => [event.id, toShadowEvent(event)]));
+}
+function tally(slug, outcomes, localDeletes) {
+	const count = (kind) => outcomes.filter((outcome) => outcome.kind === kind).length;
+	return {
+		slug,
+		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] : [])
+	};
+}
+async function pushNow(collection, workspaceRoot, deps) {
+	const { schema, slug } = collection;
+	const calendarId = schema.googleCalendar?.calendarId;
+	const accessToken = await deps.accessToken();
+	const meta = await deps.calendarMeta(accessToken, calendarId);
+	if (isDeniedAccessRole(meta.accessRole)) return {
+		kind: "read-only",
+		accessRole: meta.accessRole ?? ""
+	};
+	const map = pushableMap(schema.googleCalendar?.map ?? {});
+	const shadow = await loadCalendarShadow(calendarId, workspaceRoot);
+	const records = await storeFor(collection, { workspaceRoot }).list();
+	const ctx = {
+		accessToken,
+		calendarId,
+		timeZone: meta.timeZone,
+		map,
+		bySource: bySourceField(map),
+		primaryKey: schema.primaryKey,
+		fields: schema.fields,
+		shadow
+	};
+	const outcomes = [];
+	for (const record of records) {
+		const outcome = await pushRecord(ctx, fieldText(record[schema.primaryKey]), record);
+		outcomes.push(outcome);
+		await saveCalendarShadow(calendarId, pushedShadow([outcome]), workspaceRoot);
+	}
+	const result = tally(slug, outcomes, locallyDeletedIds(shadow, records.map((record) => fieldText(record[schema.primaryKey]))).length);
+	if (result.errors.length > 0) log.warn("google", "calendar push finished with errors", {
+		slug,
+		errors: result.errors.length
+	});
+	return {
+		kind: "pushed",
+		result
+	};
+}
+/** Push ONE collection's records to the calendar it declares.
+*
+*  "Does this collection sync at all" is answered before "is Google linked", for
+*  the reason `syncCalendarForCollection` gives: telling someone to link their
+*  account for a collection that never declared a calendar sends them fixing the
+*  wrong thing. */
+async function pushCalendarForCollection(slug, workspaceRoot, deps = liveDeps) {
+	try {
+		const collection = await deps.findCollection(slug, workspaceRoot);
+		if (collection === null) return { kind: "not-a-calendar" };
+		if (!await deps.isLinked()) return { kind: "not-linked" };
+		return await withCalendarLock(collection.schema.googleCalendar?.calendarId, () => pushNow(collection, workspaceRoot, deps));
+	} catch (error) {
+		log.warn("google", "calendar push could not start", {
+			slug,
+			error: String(error)
+		});
+		return {
+			kind: "failed",
+			message: String(error)
+		};
+	}
+}
+//#endregion
 //#region src/google/tasks.ts
 var TASKS_BASE_URL = "https://tasks.googleapis.com/tasks/v1";
 var TASKS_API_LABEL = "Google Tasks API";
@@ -1237,12 +1878,20 @@ async function updateTask(accessToken, input) {
 		body: JSON.stringify(buildTaskPatch(input))
 	}));
 }
-async function completeTask(accessToken, input) {
+/** Shared body of the two status transitions. PATCH keeps the rest of the task
+*  intact — a PUT would need the full body and would silently drop fields the
+*  caller never read. Private on purpose: the exported `completeTask` /
+*  `uncompleteTask` names are the API, so no caller can invent a third target
+*  state by passing an arbitrary status through. */
+async function patchTaskStatus(accessToken, input, status) {
 	return toTaskSummary(await googleRequest(TASKS_API_LABEL, accessToken, tasksUrl(input.taskListId, `/${encodeURIComponent(input.taskId)}`), {
 		method: "PATCH",
-		body: JSON.stringify({ status: TASK_STATUS_COMPLETED })
+		body: JSON.stringify({ status })
 	}));
 }
+async function completeTask(accessToken, input) {
+	return patchTaskStatus(accessToken, input, TASK_STATUS_COMPLETED);
+}
 /** Send a completed task back to the to-do list.
 *
 *  Its own function rather than a flag on `completeTask`, and deliberately not
@@ -1257,10 +1906,7 @@ async function completeTask(accessToken, input) {
 *  reopened task ever displays a completion date in Google's own UI, this is
 *  the place to add `completed: null` to the patch. */
 async function uncompleteTask(accessToken, input) {
-	return toTaskSummary(await googleRequest(TASKS_API_LABEL, accessToken, tasksUrl(input.taskListId, `/${encodeURIComponent(input.taskId)}`), {
-		method: "PATCH",
-		body: JSON.stringify({ status: TASK_STATUS_NEEDS_ACTION })
-	}));
+	return patchTaskStatus(accessToken, input, TASK_STATUS_NEEDS_ACTION);
 }
 async function deleteTask(accessToken, input) {
 	await googleRequest(TASKS_API_LABEL, accessToken, tasksUrl(input.taskListId, `/${encodeURIComponent(input.taskId)}`), { method: "DELETE" });
@@ -1359,6 +2005,6 @@ async function deleteDriveFile(accessToken, input) {
 	await googleRequest(DRIVE_API_LABEL, accessToken, `${DRIVE_FILES_URL}/${encodeURIComponent(input.fileId)}`, { method: "DELETE" });
 }
 //#endregion
-export { 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, MAX_LIST_RESULTS, anySyncedCollectionSurvives, assertSafeMimeType, authorizeGoogle, brokerBaseUrl, brokerExchange, brokerRefresh, brokerStart, buildEventPatch, buildMultipartBody, buildTaskPatch, calendarApiError, calendarSyncStatePath, canonicalCalendarId, canonicalTaskListId, classifyDelete, classifyWrite, clearCalendarSyncToken, clientSecretPresence, collectCalendarPages, commitLinkedTokens, completeTask, configureGoogleHost, createCalendarEvent, createDriveFile, createGoogleAuthFlow, createTask, deleteCalendarEvent, deleteDriveFile, deleteGoogleTokens, deleteTask, findClientSecretPath, getCalendarColors, getGoogleAccessToken, googleApiError, googleAuthFlow, googleCalendarSyncTaskDef, googleConfigDir, googleSecretsDir, googleTokenPath, groupByCalendar, isGoogleApiError, isIsoDateTimeWithOffset, isTextMimeType, legacyGoogleTokenPath, listCalendarEvents, listCalendars, listDriveFiles, listTaskLists, listTasks, loadCalendarSyncToken, loadClientSecret, loadGoogleTokens, mergeGoogleTokens, orphanedCalendarId, pickBoundary, readDriveFile, releaseOrphanedCalendarToken, saveCalendarSyncToken, saveGoogleTokens, syncCalendarEvents, syncCalendarForCollection, syncCalendarGroup, syncDueCalendarCollections, syncNewCalendarCollections, toCalendarSummary, toCollectionDateTime, toCollectionRecord, toDriveFileSummary, toEventSummary, toTaskListSummary, toTaskSummary, uncompleteTask, unlinkGoogle, unsyncedGroups, updateCalendarEvent, updateTask, waitForAuthCode, withKeyedLock };
+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, PUSHABLE_SOURCE_FIELDS, anySyncedCollectionSurvives, assertSafeMimeType, authorizeGoogle, baselineRecord, brokerBaseUrl, brokerExchange, brokerRefresh, brokerStart, buildEventPatch, buildMultipartBody, buildTaskPatch, bySourceField, calendarApiError, calendarPushStatePath, calendarSyncStatePath, canonicalCalendarId, canonicalTaskListId, classifyDelete, classifyWrite, clearCalendarShadow, clearCalendarSyncToken, clientSecretPresence, collectCalendarPages, commitLinkedTokens, completeTask, configureGoogleHost, conflictingFields, createCalendarEvent, createDriveFile, createGoogleAuthFlow, createTask, deleteCalendarEvent, deleteDriveFile, deleteGoogleTokens, deleteTask, fieldText, findClientSecretPath, getCalendar, getCalendarColors, getCalendarEvent, getGoogleAccessToken, googleApiError, googleAuthFlow, googleCalendarSyncTaskDef, googleConfigDir, googleSecretsDir, googleTokenPath, groupByCalendar, isClientSettableEventId, isDeniedAccessRole, isGoogleApiError, isIsoDateTimeWithOffset, isTextMimeType, legacyGoogleTokenPath, listCalendarEvents, listCalendars, listDriveFiles, listTaskLists, listTasks, loadCalendarShadow, loadCalendarSyncToken, loadClientSecret, loadGoogleTokens, locallyChangedFields, locallyDeletedIds, mayAdoptExisting, mergeGoogleTokens, mergeShadow, orphanedCalendarId, pickBoundary, planRecord, pushCalendarForCollection, pushableMap, readDriveFile, releaseOrphanedCalendarToken, resolveEventSpan, saveCalendarShadow, saveCalendarSyncToken, saveGoogleTokens, shadowUpdates, syncCalendarEvents, syncCalendarForCollection, syncCalendarGroup, syncDueCalendarCollections, syncNewCalendarCollections, toCalendarSummary, toCollectionDateTime, toCollectionRecord, toDriveFileSummary, toEventSummary, toGoogleEventTime, toShadowEvent, toTaskListSummary, toTaskSummary, uncompleteTask, unlinkGoogle, unsyncedGroups, updateCalendarEvent, updateTask, waitForAuthCode, withCalendarLock, withKeyedLock, zoneSuffixOf };
 
 //# sourceMappingURL=index.js.map