@mulmoclaude/core 5.0.1 → 5.3.0

package/dist/google/index.d.ts

@@ -1,5 +1,8 @@
 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';
 export { deleteGoogleTokens, loadGoogleTokens, mergeGoogleTokens, saveGoogleTokens, type IssuedVia, type StoredGoogleTokens } from './tokenStore.js';
@@ -7,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-B_64PBZU.js";
 import { t as mulmoConfigDir } from "../paths-CkJxNZ7T.js";
 import { promises } from "node:fs";
 import path, { join } from "node:path";
@@ -41,6 +41,172 @@ 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
+*  time, and the one shape `isIsoDateTimeWithOffset` is built to refuse.
+*
+*  Realness comes from the parser the record lint, the calendar grid and the
+*  push already share, so every surface agrees that `2026-02-30` is not a day.
+*  The regex runs first because that parser trims, and a value with whitespace
+*  around it would validate here and then reach Google verbatim. */
+var isCalendarDateOnly = (value) => DATE_ONLY_RE$1.test(value) && parseIsoDate(value) !== null;
+/** One end of a span, or null when it is neither shape Calendar accepts. */
+var toEventTimeInput = (value) => {
+	if (isCalendarDateOnly(value)) return { date: value };
+	return isIsoDateTimeWithOffset(value) ? { dateTime: value } : null;
+};
+/** The rule every surface states for a value that is neither shape. Shared so
+*  the tool, the remote host and their tests cannot drift apart. */
+var EVENT_TIME_HINT = "must be an ISO 8601 date-time with a timezone offset (e.g. 2026-07-17T09:00:00+09:00), or a date for an all-day event (e.g. 2026-07-17)";
+/** The same rule with the offending key named, for a surface whose error text
+*  carries no path of its own. */
+var eventTimeHint = (key) => `${key} ${EVENT_TIME_HINT}`;
+/** All-day `end` is exclusive, so a one-day event ends on the NEXT day. Spelled
+*  out because the natural reading of "all day on the 17th" is `end` = the
+*  17th, which Calendar refuses. */
+var ALL_DAY_END_HINT = "an all-day `end` is EXCLUSIVE — it is the day AFTER the last day, so a single day on 2026-07-17 needs end 2026-07-18";
+var MIXED_SPAN_HINT = "start and end must both be date-times with an offset, or both be dates for an all-day event — not one of each";
+/** A lone all-day end cannot be patched: the stored event's kind is unknown
+*  here, and giving one end of a timed event a `date` makes an event Calendar
+*  rejects — with a message that names neither end. Both together are
+*  unambiguous, so that is what the caller is asked for. */
+var LONE_ALL_DAY_HINT = `pass BOTH start and end to move an all-day event — ${ALL_DAY_END_HINT}`;
+var isAllDay = (time) => "date" in time;
+/** Both ends of a create, validated together.
+*
+*  Only the all-day ordering is checked: a timed span's ordering depends on the
+*  two offsets, which Calendar resolves and reports on clearly, while an all-day
+*  `end <= start` comes back as an opaque 400. Lexicographic comparison is exact
+*  for `YYYY-MM-DD` — fixed-width, most significant part first. */
+function resolveSpanInput(start, end) {
+	const startTime = toEventTimeInput(start);
+	if (startTime === null) return {
+		ok: false,
+		reason: eventTimeHint("start")
+	};
+	const endTime = toEventTimeInput(end);
+	if (endTime === null) return {
+		ok: false,
+		reason: eventTimeHint("end")
+	};
+	if (isAllDay(startTime) !== isAllDay(endTime)) return {
+		ok: false,
+		reason: MIXED_SPAN_HINT
+	};
+	if (isAllDay(startTime) && isAllDay(endTime) && endTime.date <= startTime.date) return {
+		ok: false,
+		reason: ALL_DAY_END_HINT
+	};
+	return {
+		ok: true,
+		span: {
+			start: startTime,
+			end: endTime
+		}
+	};
+}
+/** One end of an EDIT, where the other end is absent. */
+function resolveLoneEnd(key, value) {
+	const time = toEventTimeInput(value);
+	if (time === null) return {
+		ok: false,
+		reason: eventTimeHint(key)
+	};
+	if (isAllDay(time)) return {
+		ok: false,
+		reason: LONE_ALL_DAY_HINT
+	};
+	return {
+		ok: true,
+		times: { [key]: time }
+	};
+}
+/** The span of an EDIT, where either end may be absent. */
+function resolvePartialSpanInput(start, end) {
+	if (start !== void 0 && end !== void 0) {
+		const resolved = resolveSpanInput(start, end);
+		return resolved.ok ? {
+			ok: true,
+			times: resolved.span
+		} : resolved;
+	}
+	if (start !== void 0) return resolveLoneEnd("start", start);
+	if (end !== void 0) return resolveLoneEnd("end", end);
+	return {
+		ok: true,
+		times: {}
+	};
+}
+//#endregion
 //#region src/google/paths.ts
 /** Same directory as every other cross-app per-user file — see
 *  `../global-config/paths.ts`, which owns the spelling. */
@@ -58,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) => {
@@ -595,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. */
@@ -612,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;
@@ -635,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) => {
@@ -726,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;
@@ -739,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({
@@ -1521,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. */
@@ -1642,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];
@@ -1852,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 {
@@ -1860,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)
 	};
 }
@@ -1891,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
@@ -1929,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
@@ -2887,6 +3140,6 @@ async function deleteDriveFile(accessToken, input) {
 	await googleRequest(DRIVE_API_LABEL, accessToken, `${DRIVE_FILES_URL}/${encodeURIComponent(input.fileId)}`, { method: "DELETE" });
 }
 //#endregion
-export { CANCELLED_EVENT_STATUS, DEFAULT_LIST_MAX_RESULTS, GOOGLE_AUTH_CANCELLED, GOOGLE_CALENDARLIST_SCOPE, GOOGLE_CALENDAR_SCOPE, GOOGLE_CALENDAR_SYNC_TASK_ID, GOOGLE_DRIVE_FILE_SCOPE, GOOGLE_SCOPES, GOOGLE_TASKS_SCOPE, GoogleApiError, HTTP_CONFLICT, HTTP_FORBIDDEN, HTTP_PRECONDITION_FAILED, MAX_LIST_RESULTS, PARTIAL_CALENDAR_WINDOW, PROTECTION_UNKNOWN, PUSHABLE_SOURCE_FIELDS, allUnpushed, anySyncedCollectionSurvives, applyPlanFor, assertSafeMimeType, authorizeGoogle, baselineRecord, brokerBaseUrl, brokerExchange, brokerRefresh, brokerStart, buildEventPatch, buildMultipartBody, buildTaskPatch, bySourceField, calendarApiError, calendarBackfillPath, calendarPushStatePath, calendarSyncDueWindowMs, calendarSyncStatePath, canonicalCalendarId, canonicalTaskListId, claimCalendarSyncIfDue, classifyDelete, classifyWrite, clearCalendarLastSyncedAt, clearCalendarShadow, clearCalendarSyncToken, clientSecretPresence, collectCalendarPages, collectionsNeedingBackfill, commitLinkedTokens, completeTask, configureGoogleHost, conflictingFields, createCalendarEvent, createDriveFile, createGoogleAuthFlow, createTask, deleteCalendarEvent, deleteDriveFile, deleteGoogleTokens, deleteTask, fieldText, findClientSecretPath, getCalendarColors, getCalendarEvent, getCalendarMeta, getGoogleAccessToken, googleApiError, googleAuthFlow, googleCalendarSyncTaskDef, googleConfigDir, googleSecretsDir, googleTokenPath, groupByCalendar, groupsNeedingBackfill, heldBack, isCalendarSyncDue, isClientSettableEventId, isDeniedAccessRole, isGoogleApiError, isIsoDateTimeWithOffset, isTextMimeType, isUnpushed, legacyGoogleTokenPath, listCalendarEvents, listCalendars, listDriveFiles, listTaskLists, listTasks, liveLockClock, loadCalendarLastSyncedAt, loadCalendarShadow, loadCalendarSyncToken, loadClientSecret, loadGoogleTokens, locallyChangedFields, locallyDeletedIds, locallyEditedIds, markCalendarBackfilled, mayAdoptExisting, mergeGoogleTokens, mergeIntoExisting, mergeShadow, needsCalendarBackfill, orphanedCalendarId, pickBoundary, planRecord, pullProtectionFor, pullableEvents, pushAndProtect, pushCalendarForCollection, pushCollectionNow, pushableMap, readDriveFile, releaseOrphanedCalendarToken, reportedAccessRole, resolveEventSpan, resumableToken, saveCalendarShadow, saveCalendarSyncToken, saveGoogleTokens, shadowUpdates, stateLockPath, syncCalendarEvents, syncCalendarForCollection, syncCalendarGroup, syncDueCalendarCollections, syncNewCalendarCollections, syncPageParams, toCalendarMeta, toCalendarSummary, toCollectionDateTime, toCollectionRecord, toDriveFileSummary, toEventSummary, toGoogleEventTime, toShadowEvent, toTaskListSummary, toTaskSummary, toolCalendarSyncKey, uncompleteTask, unlinkGoogle, unpushedFor, unsentEditGuard, unsentLocalEdits, updateCalendarEvent, updateTask, waitForAuthCode, windowAdvance, withCalendarLock, withCalendarStateLock, withKeyedLock, withPartialWindowError, zoneSuffixOf };
+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