@mulmoclaude/core 1.2.1 → 1.4.0

package/dist/google/calendar.d.ts

@@ -14,6 +14,20 @@ export interface CalendarEventInput {
     /** Event colour (Google event palette id "1".."11"); omit to inherit the calendar's colour. */
     colorId?: string;
 }
+export interface UpdateCalendarEventInput {
+    eventId: string;
+    summary?: string;
+    startDateTime?: string;
+    endDateTime?: string;
+    /** `""` clears the description; omit to leave it untouched. */
+    description?: string;
+    calendarId?: string;
+    colorId?: string;
+}
+export interface DeleteCalendarEventInput {
+    eventId: string;
+    calendarId?: string;
+}
 export interface ListEventsInput {
     timeMin?: string;
     maxResults?: number;
@@ -58,6 +72,20 @@ export declare const toCalendarSummary: (value: unknown) => CalendarSummary;
  *  helper now carries the wording. */
 export declare const calendarApiError: (status: number, body: string) => Error;
 export declare function createCalendarEvent(accessToken: string, input: CalendarEventInput): Promise<CalendarEventSummary>;
+/** PATCH body for an event edit — only the fields the caller actually supplied.
+ *
+ *  `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. */
+export declare const buildEventPatch: (input: UpdateCalendarEventInput) => Record<string, unknown>;
+/** Edit an existing event in place. PATCH, not PUT — a PUT would need the whole
+ *  event and would drop every field the caller never read (attendees,
+ *  reminders, recurrence). */
+export declare function updateCalendarEvent(accessToken: string, input: UpdateCalendarEventInput): Promise<CalendarEventSummary>;
+/** 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. */
+export declare function deleteCalendarEvent(accessToken: string, input: DeleteCalendarEventInput): Promise<void>;
 export declare function listCalendarEvents(accessToken: string, input?: ListEventsInput): Promise<CalendarEventSummary[]>;
 export interface SyncEventsInput {
     /** Calendar to sync; defaults to the user's primary. */

package/dist/google/collectionSync.d.ts

@@ -39,6 +39,13 @@ type ApplyOutcome = {
 };
 export declare function classifyWrite(eventId: string, kind: WriteItemResult["kind"]): ApplyOutcome;
 export declare function classifyDelete(eventId: string, kind: DeleteItemResult["kind"]): ApplyOutcome;
+/** Serialise `run` against whatever is already running for `key`.
+ *
+ *  `locks` is passed in so the queuing rule is testable without module state;
+ *  the key is dropped once nothing is queued behind it, so the map cannot grow
+ *  an entry per calendar forever. A failed predecessor still releases the
+ *  queue — `then(run, run)`. */
+export declare function withKeyedLock<T>(locks: Map<string, Promise<unknown>>, key: string, run: () => Promise<T>): Promise<T>;
 /** Sync ONE calendar and fan its events out to every collection bound to it.
  *
  *  The fan-out is not an optimisation, it is correctness: the sync token is
@@ -46,8 +53,19 @@ export declare function classifyDelete(eventId: string, kind: DeleteItemResult["
  *  first collection advance the shared token and leave every later collection
  *  on the same calendar reading an already-consumed window — silently missing
  *  those events forever. Fetch once, apply to all, then advance the token.
- *  (Codex + CodeRabbit review on #2184.) */
+ *  (Codex + CodeRabbit review on #2184.)
+ *
+ *  Queued per calendar for the same reason the fan-out exists: two passes over
+ *  one calendar (a Refresh click landing during the scheduled run) would each
+ *  load the SAME stored token and walk the same window. That is idempotent —
+ *  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. */
 export declare function syncCalendarGroup(calendarId: string | undefined, collections: readonly LoadedCollection[], workspaceRoot: string): Promise<CalendarCollectionSyncResult[]>;
+/** Liveness of the collections a sync just wrote to, checked against the skill
+ *  dir `deleteCollection` removes. `exists` is injected so the rule is testable
+ *  without a filesystem. An empty group has no survivor by definition. */
+export declare function anySyncedCollectionSurvives(collections: readonly Pick<LoadedCollection, "skillDir">[], exists?: (absPath: string) => Promise<boolean>): Promise<boolean>;
 /** Group the declaring collections by the calendar they read, so each calendar
  *  is fetched exactly once.
  *
@@ -57,10 +75,76 @@ export declare function syncCalendarGroup(calendarId: string | undefined, collec
  *  from under the other — the very loss this grouping exists to prevent
  *  (Codex review #2184). */
 export declare function groupByCalendar(collections: readonly LoadedCollection[]): Map<string, LoadedCollection[]>;
-/** Sync every collection that declares `googleCalendar`. Failures are isolated
- *  per calendar — one unreachable calendar (or a revoked grant) must not stop
- *  the others. */
+/** The minimum a value needs for the orphan check: just the calendar it reads.
+ *  Structural so the rule can be exercised without building a LoadedCollection. */
+export interface CalendarDeclaring {
+    googleCalendar?: {
+        calendarId?: string;
+    };
+}
+/** The canonical calendar whose sync token nothing needs any more, or null.
+ *
+ *  Sync tokens are keyed by calendar, NOT by collection, so a deleted
+ *  collection's token outlives it. Recreating a collection on the same calendar
+ *  then resumes from that token and receives only the delta — the new
+ *  collection never gets the history (#2428).
+ *
+ *  Returns null while ANY remaining collection still reads that calendar:
+ *  clearing a live calendar's token costs a full re-walk on the next sync. The
+ *  comparison is on the CANONICAL id for the same reason `groupByCalendar` is —
+ *  an omitted `calendarId` and an explicit `"primary"` are one calendar. */
+export declare function orphanedCalendarId(deleted: CalendarDeclaring, remaining: readonly CalendarDeclaring[]): string | null;
+/** Drop the sync token of a just-deleted collection's calendar, unless another
+ *  collection still reads it. Call AFTER the delete lands — the check reads the
+ *  collections that survive it.
+ *
+ *  Returns the cleared calendar id, or null when nothing was cleared. Never
+ *  throws: a failed cleanup must not fail the delete it follows. */
+export declare function releaseOrphanedCalendarToken(deleted: CalendarDeclaring, workspaceRoot: string): Promise<string | null>;
+/** Sync every collection that declares `googleCalendar`. */
 export declare function syncDueCalendarCollections(workspaceRoot: string): Promise<CalendarCollectionSyncResult[]>;
+/** 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).
+ *
+ *  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. */
+export declare function unsyncedGroups<T>(groups: Map<string, T>, loadToken: (calendarId: string) => Promise<string | null>): Promise<Map<string, T>>;
+/** 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. */
+export declare function syncNewCalendarCollections(workspaceRoot: string): Promise<CalendarCollectionSyncResult[]>;
+/** A user-triggered sync's outcome. `not-a-calendar` and `not-linked` are
+ *  states the caller must report rather than swallow: a Refresh click that
+ *  quietly returns "0 written" reads as an empty calendar, not as a setup gap. */
+export type ManualCalendarSyncOutcome = {
+    kind: "synced";
+    results: CalendarCollectionSyncResult[];
+} | {
+    kind: "not-a-calendar";
+} | {
+    kind: "not-linked";
+};
+/** The I/O a manual sync crosses, injectable so the three outcomes can be
+ *  exercised with fakes instead of a workspace on disk and a live Google grant
+ *  (CodeRabbit review #2566). */
+export interface ManualCalendarSyncDeps {
+    loadGroups: (workspaceRoot: string) => Promise<Map<string, LoadedCollection[]>>;
+    isLinked: () => Promise<boolean>;
+    runGroups: (groups: Map<string, LoadedCollection[]>, workspaceRoot: string) => Promise<CalendarCollectionSyncResult[]>;
+}
+/** Sync the calendar ONE collection reads, on demand (the Refresh button).
+ *
+ *  Deliberately syncs the whole group, not just `slug`: the sync token is keyed
+ *  by calendar, so consuming a window for one collection would leave the others
+ *  on that calendar reading an already-consumed one. Returns every result of the
+ *  group so the caller can report the requested slug's own counts.
+ *
+ *  "Does this collection sync at all" is answered BEFORE "is Google linked":
+ *  telling someone to link their account for a collection that never declared a
+ *  calendar sends them fixing the wrong thing. */
+export declare function syncCalendarForCollection(slug: string, workspaceRoot: string, deps?: ManualCalendarSyncDeps): Promise<ManualCalendarSyncOutcome>;
 /** Scheduler registration, shaped like `feedRefreshTaskDef` so hosts wire it
  *  with a single line. */
 export declare function googleCalendarSyncTaskDef(opts?: {

package/dist/google/index.cjs

@@ -655,6 +655,34 @@ async function createCalendarEvent(accessToken, input) {
 		body: JSON.stringify(body)
 	}));
 }
+var eventUrl = (calendarId, eventId) => `${eventsUrl(calendarId)}/${encodeURIComponent(eventId)}`;
+/** PATCH body for an event edit — only the fields the caller actually supplied.
+*
+*  `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. */
+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 } } : {},
+	...input.colorId ? { colorId: input.colorId } : {}
+});
+/** Edit an existing event in place. PATCH, not PUT — a PUT would need the whole
+*  event and would drop every field the caller never read (attendees,
+*  reminders, recurrence). */
+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))
+	}));
+}
+/** 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. */
+async function deleteCalendarEvent(accessToken, input) {
+	await googleRequest(CALENDAR_API_LABEL, accessToken, eventUrl(input.calendarId, input.eventId), { method: "DELETE" });
+}
 async function listCalendarEvents(accessToken, input = {}) {
 	const params = new URLSearchParams({
 		timeMin: input.timeMin ?? (/* @__PURE__ */ new Date()).toISOString(),
@@ -883,6 +911,26 @@ async function restartFullSync(accessToken, calendarId, workspaceRoot) {
 	await clearCalendarSyncToken(calendarId, workspaceRoot);
 	return await syncCalendarEvents(accessToken, { calendarId });
 }
+/** Serialise `run` against whatever is already running for `key`.
+*
+*  `locks` is passed in so the queuing rule is testable without module state;
+*  the key is dropped once nothing is queued behind it, so the map cannot grow
+*  an entry per calendar forever. A failed predecessor still releases the
+*  queue — `then(run, run)`. */
+async function withKeyedLock(locks, key, run) {
+	const result = (locks.get(key) ?? Promise.resolve()).then(run, run);
+	const tail = result.then(() => void 0, () => void 0);
+	locks.set(key, tail);
+	try {
+		return await result;
+	} finally {
+		if (locks.get(key) === tail) locks.delete(key);
+	}
+}
+/** In-flight sync per canonical calendar id. Module state on purpose: the
+*  scheduler, the create trigger and the Refresh button are three doors into
+*  the same calendar (CodeRabbit review #2566). */
+var calendarLocks = /* @__PURE__ */ new Map();
 /** Sync ONE calendar and fan its events out to every collection bound to it.
 *
 *  The fan-out is not an optimisation, it is correctness: the sync token is
@@ -890,8 +938,18 @@ async function restartFullSync(accessToken, calendarId, workspaceRoot) {
 *  first collection advance the shared token and leave every later collection
 *  on the same calendar reading an already-consumed window — silently missing
 *  those events forever. Fetch once, apply to all, then advance the token.
-*  (Codex + CodeRabbit review on #2184.) */
+*  (Codex + CodeRabbit review on #2184.)
+*
+*  Queued per calendar for the same reason the fan-out exists: two passes over
+*  one calendar (a Refresh click landing during the scheduled run) would each
+*  load the SAME stored token and walk the same window. That is idempotent —
+*  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. */
 async function syncCalendarGroup(calendarId, collections, workspaceRoot) {
+	return await withKeyedLock(calendarLocks, canonicalCalendarId(calendarId), () => syncCalendarGroupNow(calendarId, collections, workspaceRoot));
+}
+async function syncCalendarGroupNow(calendarId, collections, workspaceRoot) {
 	const accessToken = await getGoogleAccessToken();
 	const first = await syncCalendarEvents(accessToken, {
 		calendarId,
@@ -906,13 +964,47 @@ async function syncCalendarGroup(calendarId, collections, workspaceRoot) {
 		unwritable
 	});
 	const failed = results.flatMap((entry) => entry.errors);
-	if (result.nextSyncToken && failed.length === 0) await saveCalendarSyncToken(calendarId, result.nextSyncToken, workspaceRoot);
-	else if (failed.length > 0) log.warn("google", "holding back calendar sync token after failed writes", {
-		calendarId,
-		failed: failed.length
-	});
+	if (failed.length > 0) {
+		log.warn("google", "holding back calendar sync token after failed writes", {
+			calendarId,
+			failed: failed.length
+		});
+		return results;
+	}
+	if (result.nextSyncToken) await advanceToken(calendarId, result.nextSyncToken, collections, workspaceRoot);
 	return results;
 }
+/** Save the window's token unless every collection that consumed it was deleted
+*  while the sync was in flight.
+*
+*  The sync opens with a `discoverCollections()` snapshot, so a delete landing
+*  mid-run has already cleared this calendar's token by the time we get here
+*  (`releaseOrphanedCalendarToken`). Saving anyway would resurrect exactly the
+*  orphan the delete removed, and the next collection on this calendar would
+*  resume from a token describing records it never received (#2428).
+*
+*  One survivor is enough: it still needs the incremental position. */
+async function advanceToken(calendarId, nextSyncToken, collections, workspaceRoot) {
+	if (!await anySyncedCollectionSurvives(collections)) {
+		log.info("google", "not advancing the sync token — every collection on this calendar was deleted mid-sync", { calendarId });
+		return;
+	}
+	await saveCalendarSyncToken(calendarId, nextSyncToken, workspaceRoot);
+}
+async function pathExists(absPath) {
+	try {
+		await (0, node_fs_promises.stat)(absPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Liveness of the collections a sync just wrote to, checked against the skill
+*  dir `deleteCollection` removes. `exists` is injected so the rule is testable
+*  without a filesystem. An empty group has no survivor by definition. */
+async function anySyncedCollectionSurvives(collections, exists = pathExists) {
+	return (await Promise.all(collections.map((collection) => exists(collection.skillDir)))).some(Boolean);
+}
 async function applyEventsToCollection(collection, events, workspaceRoot) {
 	const outcomes = [];
 	for (const event of events) outcomes.push(await applyEvent(collection, event, workspaceRoot));
@@ -945,18 +1037,62 @@ function groupByCalendar(collections) {
 	}
 	return groups;
 }
-/** Sync every collection that declares `googleCalendar`. Failures are isolated
-*  per calendar — one unreachable calendar (or a revoked grant) must not stop
-*  the others. */
-async function syncDueCalendarCollections(workspaceRoot) {
-	const declaring = (await require_discovery.discoverCollections({ workspaceRoot })).filter((collection) => collection.schema.googleCalendar);
-	if (declaring.length === 0) return [];
-	if (!await isGoogleLinked()) {
-		log.info("google", "skipping calendar sync — no Google account linked on this host", { collections: declaring.length });
-		return [];
+/** The canonical calendar whose sync token nothing needs any more, or null.
+*
+*  Sync tokens are keyed by calendar, NOT by collection, so a deleted
+*  collection's token outlives it. Recreating a collection on the same calendar
+*  then resumes from that token and receives only the delta — the new
+*  collection never gets the history (#2428).
+*
+*  Returns null while ANY remaining collection still reads that calendar:
+*  clearing a live calendar's token costs a full re-walk on the next sync. The
+*  comparison is on the CANONICAL id for the same reason `groupByCalendar` is —
+*  an omitted `calendarId` and an explicit `"primary"` are one calendar. */
+function orphanedCalendarId(deleted, remaining) {
+	if (!deleted.googleCalendar) return null;
+	const key = canonicalCalendarId(deleted.googleCalendar.calendarId);
+	return remaining.some((other) => other.googleCalendar && canonicalCalendarId(other.googleCalendar.calendarId) === key) ? null : key;
+}
+/** Drop the sync token of a just-deleted collection's calendar, unless another
+*  collection still reads it. Call AFTER the delete lands — the check reads the
+*  collections that survive it.
+*
+*  Returns the cleared calendar id, or null when nothing was cleared. Never
+*  throws: a failed cleanup must not fail the delete it follows. */
+async function releaseOrphanedCalendarToken(deleted, workspaceRoot) {
+	try {
+		if (!deleted.googleCalendar) return null;
+		const orphaned = orphanedCalendarId(deleted, (await require_discovery.discoverCollections({ workspaceRoot })).map((collection) => collection.schema));
+		if (orphaned === null) return null;
+		await clearCalendarSyncToken(orphaned, workspaceRoot);
+		log.info("google", "cleared the sync token of a calendar no collection reads any more", { calendarId: orphaned });
+		return orphaned;
+	} catch (error) {
+		log.warn("google", "could not release the deleted collection's calendar sync token", { error: String(error) });
+		return null;
 	}
+}
+/** Every declaring collection, grouped by the calendar it reads. */
+async function declaringGroups(workspaceRoot) {
+	return groupByCalendar((await require_discovery.discoverCollections({ workspaceRoot })).filter((collection) => collection.schema.googleCalendar));
+}
+/** Whether a background sync of these groups may run at all.
+*
+*  Authoring the collection before linking the account is an expected state,
+*  not a failure. Checking once here keeps it a quiet skip instead of an
+*  access-token throw per calendar, every hour, until the user links (#2188).
+*  A user-triggered sync answers differently — it says so out loud. */
+async function backgroundSyncAllowed(groups) {
+	if (groups.size === 0) return false;
+	if (await isGoogleLinked()) return true;
+	log.info("google", "skipping calendar sync — no Google account linked on this host", { calendars: groups.size });
+	return false;
+}
+/** Run each group, isolating failures per calendar — one unreachable calendar
+*  (or a revoked grant) must not stop the others. */
+async function runCalendarGroups(groups, workspaceRoot) {
 	const results = [];
-	for (const [calendarId, collections] of groupByCalendar(declaring)) try {
+	for (const [calendarId, collections] of groups) try {
 		results.push(...await syncCalendarGroup(calendarId, collections, workspaceRoot));
 	} catch (error) {
 		log.warn("google", "calendar sync failed", {
@@ -973,6 +1109,55 @@ async function syncDueCalendarCollections(workspaceRoot) {
 	}
 	return results;
 }
+/** Sync every collection that declares `googleCalendar`. */
+async function syncDueCalendarCollections(workspaceRoot) {
+	const groups = await declaringGroups(workspaceRoot);
+	return await backgroundSyncAllowed(groups) ? await runCalendarGroups(groups, workspaceRoot) : [];
+}
+/** 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).
+*
+*  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));
+	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. */
+async function syncNewCalendarCollections(workspaceRoot) {
+	const pending = await unsyncedGroups(await declaringGroups(workspaceRoot), (calendarId) => loadCalendarSyncToken(calendarId, workspaceRoot));
+	if (!await backgroundSyncAllowed(pending)) return [];
+	log.info("google", "running the first sync for newly declared calendars", { calendars: [...pending.keys()] });
+	return await runCalendarGroups(pending, workspaceRoot);
+}
+var liveManualSyncDeps = {
+	loadGroups: declaringGroups,
+	isLinked: isGoogleLinked,
+	runGroups: runCalendarGroups
+};
+/** Sync the calendar ONE collection reads, on demand (the Refresh button).
+*
+*  Deliberately syncs the whole group, not just `slug`: the sync token is keyed
+*  by calendar, so consuming a window for one collection would leave the others
+*  on that calendar reading an already-consumed one. Returns every result of the
+*  group so the caller can report the requested slug's own counts.
+*
+*  "Does this collection sync at all" is answered BEFORE "is Google linked":
+*  telling someone to link their account for a collection that never declared a
+*  calendar sends them fixing the wrong thing. */
+async function syncCalendarForCollection(slug, workspaceRoot, deps = liveManualSyncDeps) {
+	const owning = [...await deps.loadGroups(workspaceRoot)].filter(([, collections]) => collections.some((collection) => collection.slug === slug));
+	if (owning.length === 0) return { kind: "not-a-calendar" };
+	if (!await deps.isLinked()) return { kind: "not-linked" };
+	return {
+		kind: "synced",
+		results: await deps.runGroups(new Map(owning), workspaceRoot)
+	};
+}
 /** Scheduler registration, shaped like `feedRefreshTaskDef` so hosts wire it
 *  with a single line. */
 function googleCalendarSyncTaskDef(opts) {
@@ -1012,7 +1197,12 @@ var toTaskSummary = (value) => {
 		notes: stringField(record, "notes")
 	};
 };
-var tasksUrl = (taskListId, suffix = "") => `${TASKS_BASE_URL}/lists/${encodeURIComponent(taskListId ?? DEFAULT_TASK_LIST_ID)}/tasks${suffix}`;
+/** Resolve a declared taskListId to the one the API addresses. `||` (not `??`)
+*  so a blank string also falls back instead of building a malformed
+*  `/lists//tasks` URL — the same rule, and the same reason, as
+*  `canonicalCalendarId`. */
+var canonicalTaskListId = (taskListId) => taskListId?.trim() || DEFAULT_TASK_LIST_ID;
+var tasksUrl = (taskListId, suffix = "") => `${TASKS_BASE_URL}/lists/${encodeURIComponent(canonicalTaskListId(taskListId))}/tasks${suffix}`;
 async function listTaskLists(accessToken) {
 	return itemsOf(await googleRequest(TASKS_API_LABEL, accessToken, `${TASKS_BASE_URL}/users/@me/lists?maxResults=${MAX_TASK_LISTS}`)).map(toTaskListSummary);
 }
@@ -1034,6 +1224,21 @@ async function createTask(accessToken, input) {
 		body: JSON.stringify(body)
 	}));
 }
+/** PATCH body for a task edit — only the fields the caller supplied. As with
+*  events, `undefined` means "leave as is" and `""` means "clear it", so the
+*  two must stay distinct. `status` is deliberately absent: `completeTask`
+*  owns that transition, and two ways to set it would drift apart. */
+var buildTaskPatch = (input) => ({
+	...input.title !== void 0 ? { title: input.title } : {},
+	...input.notes !== void 0 ? { notes: input.notes } : {},
+	...input.due !== void 0 ? { due: input.due } : {}
+});
+async function updateTask(accessToken, input) {
+	return toTaskSummary(await googleRequest(TASKS_API_LABEL, accessToken, tasksUrl(input.taskListId, `/${encodeURIComponent(input.taskId)}`), {
+		method: "PATCH",
+		body: JSON.stringify(buildTaskPatch(input))
+	}));
+}
 async function completeTask(accessToken, input) {
 	return toTaskSummary(await googleRequest(TASKS_API_LABEL, accessToken, tasksUrl(input.taskListId, `/${encodeURIComponent(input.taskId)}`), {
 		method: "PATCH",
@@ -1147,16 +1352,20 @@ exports.GOOGLE_SCOPES = GOOGLE_SCOPES;
 exports.GOOGLE_TASKS_SCOPE = GOOGLE_TASKS_SCOPE;
 exports.GoogleApiError = GoogleApiError;
 exports.MAX_LIST_RESULTS = MAX_LIST_RESULTS;
+exports.anySyncedCollectionSurvives = anySyncedCollectionSurvives;
 exports.assertSafeMimeType = assertSafeMimeType;
 exports.authorizeGoogle = authorizeGoogle;
 exports.brokerBaseUrl = brokerBaseUrl;
 exports.brokerExchange = brokerExchange;
 exports.brokerRefresh = brokerRefresh;
 exports.brokerStart = brokerStart;
+exports.buildEventPatch = buildEventPatch;
 exports.buildMultipartBody = buildMultipartBody;
+exports.buildTaskPatch = buildTaskPatch;
 exports.calendarApiError = calendarApiError;
 exports.calendarSyncStatePath = calendarSyncStatePath;
 exports.canonicalCalendarId = canonicalCalendarId;
+exports.canonicalTaskListId = canonicalTaskListId;
 exports.classifyDelete = classifyDelete;
 exports.classifyWrite = classifyWrite;
 exports.clearCalendarSyncToken = clearCalendarSyncToken;
@@ -1169,6 +1378,7 @@ exports.createCalendarEvent = createCalendarEvent;
 exports.createDriveFile = createDriveFile;
 exports.createGoogleAuthFlow = createGoogleAuthFlow;
 exports.createTask = createTask;
+exports.deleteCalendarEvent = deleteCalendarEvent;
 exports.deleteDriveFile = deleteDriveFile;
 exports.deleteGoogleTokens = deleteGoogleTokens;
 exports.deleteTask = deleteTask;
@@ -1195,13 +1405,17 @@ exports.loadCalendarSyncToken = loadCalendarSyncToken;
 exports.loadClientSecret = loadClientSecret;
 exports.loadGoogleTokens = loadGoogleTokens;
 exports.mergeGoogleTokens = mergeGoogleTokens;
+exports.orphanedCalendarId = orphanedCalendarId;
 exports.pickBoundary = pickBoundary;
 exports.readDriveFile = readDriveFile;
+exports.releaseOrphanedCalendarToken = releaseOrphanedCalendarToken;
 exports.saveCalendarSyncToken = saveCalendarSyncToken;
 exports.saveGoogleTokens = saveGoogleTokens;
 exports.syncCalendarEvents = syncCalendarEvents;
+exports.syncCalendarForCollection = syncCalendarForCollection;
 exports.syncCalendarGroup = syncCalendarGroup;
 exports.syncDueCalendarCollections = syncDueCalendarCollections;
+exports.syncNewCalendarCollections = syncNewCalendarCollections;
 exports.toCalendarSummary = toCalendarSummary;
 exports.toCollectionDateTime = toCollectionDateTime;
 exports.toCollectionRecord = toCollectionRecord;
@@ -1210,6 +1424,10 @@ exports.toEventSummary = toEventSummary;
 exports.toTaskListSummary = toTaskListSummary;
 exports.toTaskSummary = toTaskSummary;
 exports.unlinkGoogle = unlinkGoogle;
+exports.unsyncedGroups = unsyncedGroups;
+exports.updateCalendarEvent = updateCalendarEvent;
+exports.updateTask = updateTask;
 exports.waitForAuthCode = waitForAuthCode;
+exports.withKeyedLock = withKeyedLock;
 
 //# sourceMappingURL=index.cjs.map