@mulmoclaude/core 5.0.1 → 5.3.0

package/dist/google/index.cjs

@@ -7,7 +7,7 @@ const require_root = require("../root-BvwBUcol.cjs");
 const require_utils_fetch = require("../utils/fetch.cjs");
 const require_itemId = require("../itemId-CGT2J7YK.cjs");
 const require_project = require("../project-C1ep9pvo.cjs");
-const require_discovery = require("../discovery-DCMW05Bp.cjs");
+const require_discovery = require("../discovery-CDXYswtw.cjs");
 const require_paths = require("../paths-C8-jxR0s.cjs");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
@@ -45,6 +45,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) && require_itemId.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. */
@@ -62,13 +228,6 @@ function googleSecretsDir(home) {
 	return (0, node_path.join)(home ?? (0, node_os.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) => {
@@ -599,6 +758,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. */
@@ -616,6 +779,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;
@@ -639,7 +806,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) => {
@@ -730,9 +899,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;
@@ -743,7 +914,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({
@@ -1525,7 +1699,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. */
@@ -1646,7 +1822,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];
@@ -1856,7 +2034,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 {
@@ -1864,9 +2042,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)
 	};
 }
@@ -1895,6 +2074,69 @@ async function unsentLocalEdits(collection, workspaceRoot) {
 	const shadow = await loadCalendarShadow(schema.googleCalendar?.calendarId, workspaceRoot);
 	return locallyEditedIds(await require_discovery.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 — ${require_dist.errorMessage(error)}`);
+	}
+	return sweep;
+}
 /** Push one collection WITHOUT taking the calendar lock.
 *
 *  The caller must already hold it. The scheduled push→pull cycle
@@ -1933,7 +2175,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
@@ -2891,8 +3144,11 @@ async function deleteDriveFile(accessToken, input) {
 	await googleRequest(DRIVE_API_LABEL, accessToken, `${DRIVE_FILES_URL}/${encodeURIComponent(input.fileId)}`, { method: "DELETE" });
 }
 //#endregion
+exports.ALL_DAY_END_HINT = ALL_DAY_END_HINT;
 exports.CANCELLED_EVENT_STATUS = CANCELLED_EVENT_STATUS;
 exports.DEFAULT_LIST_MAX_RESULTS = DEFAULT_LIST_MAX_RESULTS;
+exports.EVENT_ABSENT_STATUSES = EVENT_ABSENT_STATUSES;
+exports.EVENT_TIME_HINT = EVENT_TIME_HINT;
 exports.GOOGLE_AUTH_CANCELLED = GOOGLE_AUTH_CANCELLED;
 exports.GOOGLE_CALENDARLIST_SCOPE = GOOGLE_CALENDARLIST_SCOPE;
 exports.GOOGLE_CALENDAR_SCOPE = GOOGLE_CALENDAR_SCOPE;
@@ -2904,7 +3160,9 @@ exports.GoogleApiError = GoogleApiError;
 exports.HTTP_CONFLICT = HTTP_CONFLICT;
 exports.HTTP_FORBIDDEN = HTTP_FORBIDDEN;
 exports.HTTP_PRECONDITION_FAILED = HTTP_PRECONDITION_FAILED;
+exports.LONE_ALL_DAY_HINT = LONE_ALL_DAY_HINT;
 exports.MAX_LIST_RESULTS = MAX_LIST_RESULTS;
+exports.MIXED_SPAN_HINT = MIXED_SPAN_HINT;
 exports.PARTIAL_CALENDAR_WINDOW = PARTIAL_CALENDAR_WINDOW;
 exports.PROTECTION_UNKNOWN = PROTECTION_UNKNOWN;
 exports.PUSHABLE_SOURCE_FIELDS = PUSHABLE_SOURCE_FIELDS;
@@ -2940,6 +3198,7 @@ exports.collectCalendarPages = collectCalendarPages;
 exports.collectionsNeedingBackfill = collectionsNeedingBackfill;
 exports.commitLinkedTokens = commitLinkedTokens;
 exports.completeTask = completeTask;
+exports.conferenceVideoUri = conferenceVideoUri;
 exports.configureGoogleHost = configureGoogleHost;
 exports.conflictingFields = conflictingFields;
 exports.createCalendarEvent = createCalendarEvent;
@@ -2949,7 +3208,9 @@ exports.createTask = createTask;
 exports.deleteCalendarEvent = deleteCalendarEvent;
 exports.deleteDriveFile = deleteDriveFile;
 exports.deleteGoogleTokens = deleteGoogleTokens;
+exports.deleteRefusalMessage = deleteRefusalMessage;
 exports.deleteTask = deleteTask;
+exports.eventTimeHint = eventTimeHint;
 exports.fieldText = fieldText;
 exports.findClientSecretPath = findClientSecretPath;
 exports.getCalendarColors = getCalendarColors;
@@ -2965,6 +3226,7 @@ exports.googleTokenPath = googleTokenPath;
 exports.groupByCalendar = groupByCalendar;
 exports.groupsNeedingBackfill = groupsNeedingBackfill;
 exports.heldBack = heldBack;
+exports.isCalendarDateOnly = isCalendarDateOnly;
 exports.isCalendarSyncDue = isCalendarSyncDue;
 exports.isClientSettableEventId = isClientSettableEventId;
 exports.isDeniedAccessRole = isDeniedAccessRole;
@@ -2995,6 +3257,7 @@ exports.mergeShadow = mergeShadow;
 exports.needsCalendarBackfill = needsCalendarBackfill;
 exports.orphanedCalendarId = orphanedCalendarId;
 exports.pickBoundary = pickBoundary;
+exports.planDelete = planDelete;
 exports.planRecord = planRecord;
 exports.pullProtectionFor = pullProtectionFor;
 exports.pullableEvents = pullableEvents;
@@ -3006,12 +3269,16 @@ exports.readDriveFile = readDriveFile;
 exports.releaseOrphanedCalendarToken = releaseOrphanedCalendarToken;
 exports.reportedAccessRole = reportedAccessRole;
 exports.resolveEventSpan = resolveEventSpan;
+exports.resolvePartialSpanInput = resolvePartialSpanInput;
+exports.resolveSpanInput = resolveSpanInput;
 exports.resumableToken = resumableToken;
 exports.saveCalendarShadow = saveCalendarShadow;
 exports.saveCalendarSyncToken = saveCalendarSyncToken;
 exports.saveGoogleTokens = saveGoogleTokens;
+exports.selfResponseStatus = selfResponseStatus;
 exports.shadowUpdates = shadowUpdates;
 exports.stateLockPath = stateLockPath;
+exports.sweepDeletes = sweepDeletes;
 exports.syncCalendarEvents = syncCalendarEvents;
 exports.syncCalendarForCollection = syncCalendarForCollection;
 exports.syncCalendarGroup = syncCalendarGroup;
@@ -3024,6 +3291,7 @@ exports.toCollectionDateTime = toCollectionDateTime;
 exports.toCollectionRecord = toCollectionRecord;
 exports.toDriveFileSummary = toDriveFileSummary;
 exports.toEventSummary = toEventSummary;
+exports.toEventTimeInput = toEventTimeInput;
 exports.toGoogleEventTime = toGoogleEventTime;
 exports.toShadowEvent = toShadowEvent;
 exports.toTaskListSummary = toTaskListSummary;