mysticals 0.3.0 → 0.4.0

package/dist/cli.js

@@ -5,7 +5,7 @@ import { createElement } from "react";
 import { render } from "ink";
 
 // package.json
-var version = "0.3.0";
+var version = "0.4.0";
 
 // src/client.ts
 import { spawn } from "child_process";
@@ -53,6 +53,7 @@ var methodSet = {
   "events.update": true,
   "events.delete": true,
   "events.respond": true,
+  "events.recurrence": true,
   "sync.now": true
 };
 var METHODS = Object.keys(methodSet);
@@ -474,6 +475,15 @@ var color = z.string().regex(/^#[0-9a-fA-F]{6}$/);
 var text = (max2) => z.string().max(max2);
 var ordered = (v) => Date.parse(v.end) >= Date.parse(v.start);
 var Range = z.object({ start: isoDateOrTime, end: isoDateOrTime }).refine(ordered, "end before start");
+var Recurrence = z.object({
+  freq: z.enum(["daily", "weekly", "monthly", "yearly"]),
+  interval: z.number().int().min(1).max(999).optional(),
+  byDay: z.array(z.enum(["MO", "TU", "WE", "TH", "FR", "SA", "SU"])).max(7).optional(),
+  until: z.iso.date().optional(),
+  count: z.number().int().min(1).max(999).optional(),
+  // An RRULE value kept from the provider: one line of plain RRULE parts only.
+  rule: z.string().max(1e3).regex(/^[A-Z0-9=;,+-]+$/i).optional()
+}).strict();
 var NewEvent = z.object({
   accountId: id,
   calendarId: id,
@@ -483,7 +493,8 @@ var NewEvent = z.object({
   allDay: z.boolean(),
   location: text(1e3).optional(),
   description: text(2e4).optional(),
-  attendees: z.array(z.email()).max(500).optional()
+  attendees: z.array(z.email()).max(500).optional(),
+  recurrence: Recurrence.optional()
 }).refine(ordered, "end before start");
 var Attendee = z.object({
   email: text(320).min(1),
@@ -500,7 +511,9 @@ var EventEdit = EventRef.extend({
   allDay: z.boolean(),
   location: text(1e3).optional(),
   description: text(2e4).optional(),
-  attendees: z.array(Attendee).max(500)
+  attendees: z.array(Attendee).max(500),
+  // Absent keeps the series' rule; null stops repeating.
+  recurrence: Recurrence.nullish()
 }).refine(ordered, "end before start");
 var LOOPBACK = /* @__PURE__ */ new Set(["127.0.0.1", "localhost"]);
 var CaldavInput = z.object({
@@ -516,7 +529,7 @@ var CaldavInput = z.object({
 });
 var AccountPatch = z.object({ label: text(200).min(1).optional(), color: color.optional() }).strict();
 var RsvpStatus = z.enum(["accepted", "declined", "tentative"]);
-var Scope = z.enum(["one", "following", "all"]).default("one");
+var Scope = z.enum(["one", "following", "all"]).nullish().transform((s) => s ?? "one");
 function createApi(store, sync, deps) {
   const account = (accountId) => {
     const a = store.get(id.parse(accountId));
@@ -612,12 +625,19 @@ function createApi(store, sync, deps) {
         syncOne(a.id);
         return ev;
       },
-      update: async (raw) => {
+      update: async (raw, scope) => {
         const edit = EventEdit.parse(raw);
         const cached2 = writable(cachedEvent(edit));
-        const { title: title2, start, end, allDay, location, description, attendees } = edit;
-        const ev = await store.getProvider(cached2.accountId).updateEvent({ ...cached2, title: title2, start, end, allDay, location, description, attendees });
-        upsert(ev, cached2.accountId, cached2.calendarId);
+        const how = cached2.recurringEventId ? Scope.parse(scope) : "one";
+        const { title: title2, start, end, allDay, location, description, attendees, recurrence } = edit;
+        if (recurrence !== void 0 && cached2.recurringEventId && how === "one")
+          throw new Error("The repeat rule belongs to the series: choose \u201CThis and following\u201D or \u201CAll events\u201D");
+        const ev = await store.getProvider(cached2.accountId).updateEvent({ ...cached2, title: title2, start, end, allDay, location, description, attendees, ...recurrence !== void 0 ? { recurrence } : {} }, how);
+        if (how === "one") upsert(ev, cached2.accountId, cached2.calendarId);
+        else {
+          const own = { ...ev, accountId: cached2.accountId, calendarId: cached2.calendarId };
+          applyLocal(cached2.accountId, (events) => [...events.filter((e) => e.id !== own.id && !deletedBy(cached2, how, e)), own]);
+        }
         syncOne(cached2.accountId);
         return ev;
       },
@@ -628,6 +648,10 @@ function createApi(store, sync, deps) {
         applyLocal(cached2.accountId, (events) => events.filter((e) => !deletedBy(cached2, how, e)));
         syncOne(cached2.accountId);
       },
+      recurrence: async (raw) => {
+        const cached2 = cachedEvent(EventRef.parse(raw));
+        return store.getProvider(cached2.accountId).getRecurrence(cached2);
+      },
       respond: async (raw, status) => {
         const cached2 = cachedEvent(EventRef.parse(raw));
         const ev = await store.getProvider(cached2.accountId).respond(cached2, RsvpStatus.parse(status));
@@ -829,11 +853,171 @@ var AccountStore = class {
 };
 
 // ../../packages/core/src/mock/mockApi.ts
-import { addDays, format as format2 } from "date-fns";
+import { addDays as addDays2, format as format4 } from "date-fns";
 
 // ../../packages/core/src/mock/MockProvider.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { parseISO as parseISO3 } from "date-fns";
+import { addDays, differenceInCalendarDays, differenceInCalendarMonths, format as format3, parseISO as parseISO4, startOfWeek } from "date-fns";
+
+// ../../packages/core/src/logic/recurrence.ts
+import { format as format2, isValid, parseISO as parseISO3 } from "date-fns";
+var WEEKDAYS = ["MO", "TU", "WE", "TH", "FR", "SA", "SU"];
+var JS_DAY = ["SU", "MO", "TU", "WE", "TH", "FR", "SA"];
+var SHORT = { MO: "Mon", TU: "Tue", WE: "Wed", TH: "Thu", FR: "Fri", SA: "Sat", SU: "Sun" };
+var WORKWEEK = ["MO", "TU", "WE", "TH", "FR"];
+var FREQS = ["daily", "weekly", "monthly", "yearly"];
+var UNIT = { daily: "day", weekly: "week", monthly: "month", yearly: "year" };
+var asDate = (start) => start.length === 10 ? parseISO3(start) : new Date(start);
+var weekdayOf = (start) => JS_DAY[asDate(start).getDay()];
+var shortDay = (d) => SHORT[d];
+function normalize(r, start) {
+  if (r.rule) return { freq: r.freq, rule: r.rule };
+  const out = { freq: r.freq };
+  if (r.interval && r.interval > 1) out.interval = r.interval;
+  if (r.freq === "weekly" && r.byDay?.length) {
+    const days = WEEKDAYS.filter((d) => r.byDay.includes(d));
+    if (!(days.length === 1 && days[0] === weekdayOf(start))) out.byDay = days;
+  }
+  if (r.until) out.until = r.until;
+  else if (r.count) out.count = r.count;
+  return out;
+}
+function sameRecurrence(a, b, start) {
+  if (!a || !b) return a === b;
+  return JSON.stringify(normalize(a, start)) === JSON.stringify(normalize(b, start));
+}
+function toRRule(r, allDay) {
+  if (r.rule) return r.rule;
+  const parts = [`FREQ=${r.freq.toUpperCase()}`];
+  if (r.interval && r.interval > 1) parts.push(`INTERVAL=${r.interval}`);
+  if (r.freq === "weekly" && r.byDay?.length) parts.push(`BYDAY=${WEEKDAYS.filter((d) => r.byDay.includes(d)).join(",")}`);
+  if (r.until) {
+    const until = allDay ? r.until.replace(/-/g, "") : (/* @__PURE__ */ new Date(`${r.until}T23:59:59`)).toISOString().replace(/[-:]|\.\d{3}/g, "");
+    parts.push(`UNTIL=${until}`);
+  } else if (r.count) parts.push(`COUNT=${r.count}`);
+  return parts.join(";");
+}
+var EDITABLE = /* @__PURE__ */ new Set(["FREQ", "INTERVAL", "BYDAY", "UNTIL", "COUNT", "WKST"]);
+function fromRRule(text2, start) {
+  const rule = text2.replace(/^RRULE:/i, "").trim();
+  const kv = new Map(rule.split(";").filter(Boolean).map((p) => {
+    const i = p.indexOf("=");
+    return [p.slice(0, i).toUpperCase(), p.slice(i + 1).toUpperCase()];
+  }));
+  const freq = (kv.get("FREQ") ?? "").toLowerCase();
+  const custom = () => ({ freq: FREQS.includes(freq) ? freq : "daily", rule });
+  if (!FREQS.includes(freq) || [...kv.keys()].some((k) => !EDITABLE.has(k))) return custom();
+  const out = { freq };
+  const interval = Number(kv.get("INTERVAL") ?? 1);
+  if (!Number.isInteger(interval) || interval < 1) return custom();
+  if (interval > 1) out.interval = interval;
+  if (kv.has("BYDAY")) {
+    const days = kv.get("BYDAY").split(",");
+    if (freq !== "weekly" || days.some((d) => !WEEKDAYS.includes(d))) return custom();
+    out.byDay = WEEKDAYS.filter((d) => days.includes(d));
+  }
+  const until = kv.get("UNTIL");
+  if (until) {
+    const m = /^(\d{4})(\d{2})(\d{2})(?:T(\d{2})(\d{2})(\d{2})(Z?))?$/.exec(until);
+    if (!m) return custom();
+    if (!m[4]) out.until = `${m[1]}-${m[2]}-${m[3]}`;
+    else {
+      const at3 = m[7] ? new Date(Date.UTC(+m[1], +m[2] - 1, +m[3], +m[4], +m[5], +m[6])) : new Date(+m[1], +m[2] - 1, +m[3], +m[4], +m[5], +m[6]);
+      const s = start && start.length > 10 ? asDate(start) : void 0;
+      const minutes = (d) => d.getHours() * 60 + d.getMinutes();
+      if (s && minutes(at3) < minutes(s)) at3.setDate(at3.getDate() - 1);
+      out.until = format2(at3, "yyyy-MM-dd");
+    }
+  } else if (kv.has("COUNT")) {
+    const count = Number(kv.get("COUNT"));
+    if (!Number.isInteger(count) || count < 1) return custom();
+    out.count = count;
+  }
+  return out;
+}
+function presets(start) {
+  const d = asDate(start);
+  return [
+    { id: "none", label: "Does not repeat", recurrence: null },
+    { id: "daily", label: "Every day", recurrence: { freq: "daily" } },
+    { id: "weekly", label: `Every week on ${format2(d, "EEEE")}`, recurrence: { freq: "weekly" } },
+    { id: "monthly", label: `Every month on day ${d.getDate()}`, recurrence: { freq: "monthly" } },
+    { id: "yearly", label: `Every year on ${format2(d, "d MMMM")}`, recurrence: { freq: "yearly" } },
+    { id: "weekdays", label: "Every weekday (Mon\u2013Fri)", recurrence: { freq: "weekly", byDay: WORKWEEK } }
+  ];
+}
+function presetOf(r, start) {
+  if (!r) return "none";
+  if (r.rule) return "custom";
+  const { until: _u, count: _c, ...base } = normalize(r, start);
+  const hit = presets(start).find((p) => p.recurrence && JSON.stringify(normalize(p.recurrence, start)) === JSON.stringify(base));
+  return hit?.id ?? "custom";
+}
+var withEnd = (r, from) => from?.until ? { ...r, until: from.until, count: void 0 } : from?.count ? { ...r, count: from.count, until: void 0 } : r;
+function describe(r, start) {
+  if (!r) return "Does not repeat";
+  if (r.rule) return `Custom rule (${r.rule})`;
+  const n = normalize(r, start);
+  const d = asDate(start);
+  const every = n.interval ? `Every ${n.interval} ${UNIT[n.freq]}s` : `Every ${UNIT[n.freq]}`;
+  const on = n.freq === "weekly" ? !n.interval && n.byDay?.join() === WORKWEEK.join() ? "" : ` on ${(n.byDay ?? [weekdayOf(start)]).map(shortDay).join(", ")}` : n.freq === "monthly" ? ` on day ${d.getDate()}` : n.freq === "yearly" ? ` on ${format2(d, "d MMMM")}` : "";
+  const head = n.freq === "weekly" && !n.interval && n.byDay?.join() === WORKWEEK.join() ? "Every weekday (Mon\u2013Fri)" : `${every}${on}`;
+  const end = n.until ? ` \xB7 until ${format2(parseISO3(n.until), "d MMM yyyy")}` : n.count ? ` \xB7 ${n.count} time${n.count > 1 ? "s" : ""}` : "";
+  return head + end;
+}
+var everyText = (r) => `${r.interval ?? 1} ${UNIT[r.freq]}${(r.interval ?? 1) > 1 ? "s" : ""}`;
+function parseEvery(text2) {
+  const m = /^\s*(\d+)?\s*(day|week|month|year)s?\s*$/i.exec(text2);
+  const n = Number(m?.[1] ?? 1);
+  if (!m || n < 1 || n > 999) throw new Error('Repeat every: use e.g. "2 weeks" (day, week, month or year)');
+  const freq = FREQS.find((f) => UNIT[f] === m[2].toLowerCase());
+  return { freq, interval: n > 1 ? n : void 0 };
+}
+var daysText = (days) => days.map((d) => d.toLowerCase()).join(" ");
+function parseDays(text2) {
+  const words = text2.split(/[\s,;]+/).filter(Boolean).map((w) => w.slice(0, 2).toUpperCase());
+  const bad = words.filter((w) => !WEEKDAYS.includes(w));
+  if (!words.length || bad.length) throw new Error('Repeat on: use days like "mo th"');
+  return WEEKDAYS.filter((d) => words.includes(d));
+}
+var endsText = (r) => r.until ? r.until : r.count ? `${r.count} times` : "never";
+function parseEnds(text2) {
+  const t = text2.trim().toLowerCase();
+  if (!t || t === "never") return {};
+  if (/^\d{4}-\d{2}-\d{2}$/.test(t) && isValid(parseISO3(t)) && format2(parseISO3(t), "yyyy-MM-dd") === t) return { until: t };
+  const m = /^(\d+)(\s*times?)?$/.exec(t);
+  if (m && +m[1] >= 1 && +m[1] <= 999) return { count: +m[1] };
+  throw new Error('Ends: use "never", a date (YYYY-MM-DD) or "10 times"');
+}
+
+// ../../packages/core/src/mock/MockProvider.ts
+var MAX_INSTANCES = 60;
+function expand(first, r, series) {
+  const start = parseISO4(first.start);
+  const length = parseISO4(first.end).getTime() - start.getTime();
+  const every = r.interval ?? 1;
+  const days = r.byDay?.length ? r.byDay : [weekdayOf(first.start)];
+  const until = r.until ? parseISO4(r.until) : void 0;
+  const hits = (d) => {
+    const n = differenceInCalendarDays(d, start);
+    if (r.freq === "daily") return n % every === 0;
+    if (r.freq === "weekly")
+      return days.includes(weekdayOf(format3(d, "yyyy-MM-dd"))) && differenceInCalendarDays(startOfWeek(d, { weekStartsOn: 1 }), startOfWeek(start, { weekStartsOn: 1 })) / 7 % every === 0;
+    const months = differenceInCalendarMonths(d, start);
+    if (d.getDate() !== start.getDate()) return false;
+    return r.freq === "monthly" ? months % every === 0 : months % (12 * every) === 0;
+  };
+  const out = [];
+  for (let n = 0; n < 3 * 366 && out.length < (r.count ?? MAX_INSTANCES) && out.length < MAX_INSTANCES; n++) {
+    const d = addDays(start, n);
+    if (until && differenceInCalendarDays(d, until) > 0) break;
+    if (!hits(d)) continue;
+    const s = first.allDay ? format3(d, "yyyy-MM-dd") : d.toISOString();
+    const e = first.allDay ? format3(addDays(parseISO4(first.end), n), "yyyy-MM-dd") : new Date(d.getTime() + length).toISOString();
+    out.push({ ...first, id: `${series}@${s}`, start: s, end: e, recurringEventId: series, recurrence: void 0 });
+  }
+  return out;
+}
 var MockProvider = class {
   constructor(accountId, email, calendars) {
     this.accountId = accountId;
@@ -844,11 +1028,13 @@ var MockProvider = class {
   email;
   calendars;
   events = [];
+  /** Series id -> its rule. */
+  rules = /* @__PURE__ */ new Map();
   async listCalendars() {
     return structuredClone(this.calendars);
   }
   async listEvents(calendarId, range) {
-    const t = (iso2) => parseISO3(iso2).getTime();
+    const t = (iso2) => parseISO4(iso2).getTime();
     return structuredClone(
       this.events.filter((e) => e.calendarId === calendarId && t(e.end) > t(range.start) && t(e.start) < t(range.end))
     );
@@ -867,12 +1053,45 @@ var MockProvider = class {
       organizer: { email: this.email },
       attendees: (input.attendees ?? []).map((email) => ({ email, status: "needsAction" }))
     };
+    if (input.recurrence) return this.startSeries(ev, input.recurrence, ev.id);
     this.events.push(ev);
     return structuredClone(ev);
   }
-  async updateEvent(event) {
+  /** Add the series `first` starts under `r` (or `first` alone for null); returns its first event. */
+  startSeries(first, r, series) {
+    const evs = r ? expand(first, r, series) : [{ ...first, recurringEventId: void 0, recurrence: void 0 }];
+    if (r) this.rules.set(series, r);
+    this.events.push(...evs);
+    return structuredClone(evs[0]);
+  }
+  async getRecurrence(event) {
+    return event.recurringEventId && this.rules.get(event.recurringEventId) || null;
+  }
+  async updateEvent(event, scope = "one") {
     const i = this.events.findIndex((e) => e.id === event.id);
     if (i < 0) throw new Error("not found");
+    const old = this.events[i];
+    const series = old.recurringEventId;
+    if (event.recurrence !== void 0 && (!series || scope !== "one")) {
+      const own = (e) => e.id === old.id || !!series && e.recurringEventId === series && (scope === "all" || e.start >= old.start);
+      const firstOld = series && scope === "all" ? this.events.filter(own).sort((a, b) => a.start.localeCompare(b.start))[0] : old;
+      this.events = this.events.filter((e) => !own(e));
+      const shift = Date.parse(event.start) - Date.parse(old.start);
+      const anchor = event.recurrence && firstOld !== old && !event.allDay ? { start: new Date(Date.parse(firstOld.start) + shift).toISOString(), end: new Date(Date.parse(firstOld.start) + shift + Date.parse(event.end) - Date.parse(event.start)).toISOString() } : {};
+      const id2 = scope === "all" && series ? series : randomUUID3();
+      return this.startSeries({ ...event, ...anchor, accountId: this.accountId }, event.recurrence, id2);
+    }
+    if (series && scope !== "one") {
+      const shift = Date.parse(event.start) - Date.parse(old.start);
+      const length = Date.parse(event.end) - Date.parse(event.start);
+      const at3 = (ms) => new Date(ms).toISOString();
+      const { title: title2, location, description, attendees } = event;
+      this.events = this.events.map((e) => {
+        if (e.id === event.id || e.recurringEventId !== series || scope === "following" && e.start < old.start) return e;
+        const moved = old.allDay || event.allDay ? {} : { start: at3(Date.parse(e.start) + shift), end: at3(Date.parse(e.start) + shift + length) };
+        return { ...e, title: title2, location, description, attendees, ...moved };
+      });
+    }
     this.events[i] = { ...event, accountId: this.accountId };
     return structuredClone(this.events[i]);
   }
@@ -942,8 +1161,9 @@ function createMockApi(onChanged) {
   for (let d = -2; d <= 4; d++) {
     seed(personal, "p-main", { title: "Morning run", start: iso(d, 7), end: iso(d, 7, 45), recurringEventId: "run-series" });
   }
+  personal.rules.set("run-series", { freq: "daily", count: 7 });
   seed(personal, "p-main", { title: "Dinner with friends", start: iso(2, 20), end: iso(2, 22), location: "Kyiv" });
-  const day = (offset) => format2(addDays(/* @__PURE__ */ new Date(), offset), "yyyy-MM-dd");
+  const day = (offset) => format4(addDays2(/* @__PURE__ */ new Date(), offset), "yyyy-MM-dd");
   seed(personal, "p-holidays", { title: "Holiday", start: day(0), end: day(1), allDay: true });
   const prov = (id2) => {
     const p = providers.get(id2);
@@ -999,8 +1219,8 @@ function createMockApi(onChanged) {
         onChanged(input.accountId);
         return ev;
       },
-      update: async (ev) => {
-        const r = await own(ev.accountId, ev.calendarId).updateEvent(ev);
+      update: async (ev, scope) => {
+        const r = await own(ev.accountId, ev.calendarId).updateEvent(ev, scope);
         onChanged(ev.accountId);
         return r;
       },
@@ -1008,6 +1228,7 @@ function createMockApi(onChanged) {
         await own(ev.accountId, ev.calendarId).deleteEvent(ev, scope);
         onChanged(ev.accountId);
       },
+      recurrence: async (ev) => own(ev.accountId, ev.calendarId).getRecurrence(ev),
       respond: async (ev, status) => {
         const r = await own(ev.accountId, ev.calendarId).respond(ev, status);
         onChanged(ev.accountId);
@@ -1034,7 +1255,7 @@ import {
 
 // ../../packages/core/src/providers/caldav/ics.ts
 import ICAL from "ical.js";
-var MAX_INSTANCES = 1e5;
+var MAX_INSTANCES2 = 1e5;
 var PARTSTAT_IN = {
   ACCEPTED: "accepted",
   DECLINED: "declined",
@@ -1132,7 +1353,7 @@ function parseEvents(ics, href, etag, ctx, range) {
     -Infinity,
     ...vevents.filter((v) => v !== master).map((v) => v.getFirstPropertyValue("recurrence-id").toJSDate().getTime())
   );
-  for (let i = 0, next = it.next(); next && i < MAX_INSTANCES; i++, next = it.next()) {
+  for (let i = 0, next = it.next(); next && i < MAX_INSTANCES2; i++, next = it.next()) {
     const ms = next.toJSDate().getTime();
     if (ms >= rangeEnd && ms > lastOverride) break;
     const d = event.getOccurrenceDetails(next);
@@ -1155,9 +1376,40 @@ function buildIcs(uid, input, email) {
   setText(v, "location", input.location);
   setText(v, "description", input.description);
   setAttendees(v, input.attendees ?? [], email);
+  if (input.recurrence) setRule(v, input.recurrence, input.allDay);
   root.addSubcomponent(v);
   return root.toString();
 }
+function setRule(v, r, allDay) {
+  v.removeAllProperties("rrule");
+  v.addPropertyWithValue("rrule", ICAL.Recur.fromString(toRRule(r, allDay)));
+}
+function recurrenceOf(raw) {
+  const master = findMaster(parse(raw.ics));
+  const rule = master?.getFirstPropertyValue("rrule");
+  return master && rule ? fromRRule(rule.toString(), toIso(dtstart(master))) : null;
+}
+function applyRule(root, master, event) {
+  if (event.recurrence === void 0) return;
+  const overrides = root.getAllSubcomponents("vevent").filter((v) => v !== master);
+  if (event.recurrence === null) {
+    for (const n of ["rrule", "rdate", "exdate"]) master.removeAllProperties(n);
+    for (const o of overrides) root.removeSubcomponent(o);
+    master.addProperty(replaceTime(master, "dtstart", fromIso(event.start, event.allDay)));
+    master.addProperty(replaceTime(master, "dtend", fromIso(event.end, event.allDay)));
+    return;
+  }
+  setRule(master, event.recurrence, event.allDay);
+  const ms = (t) => t.toJSDate().getTime();
+  const rid = (o) => o.getFirstPropertyValue("recurrence-id");
+  const exdates = master.getAllProperties("exdate").flatMap((p) => p.getValues()).filter((t) => t instanceof ICAL.Time);
+  const last = Math.max(-Infinity, ...overrides.map((o) => ms(rid(o))), ...exdates.map(ms));
+  const slots2 = /* @__PURE__ */ new Set();
+  const it = master.getFirstPropertyValue("rrule").iterator(dtstart(master));
+  for (let t = it.next(), n = 0; t && ms(t) <= last && n < MAX_INSTANCES2; t = it.next(), n++) slots2.add(ms(t));
+  for (const o of overrides) if (!slots2.has(ms(rid(o)))) root.removeSubcomponent(o);
+  mapDates(master, "exdate", (t) => slots2.has(ms(t)) ? t : null);
+}
 function setAttendees(v, emails, email) {
   const wanted = [...new Set(emails.map(cleanEmail).filter(Boolean))];
   const existing = new Map(v.getAllProperties("attendee").map((p) => [cleanEmail(p.getFirstValue()), p]));
@@ -1217,9 +1469,14 @@ function applyUpdate(event, email) {
   const raw = event.raw;
   const root = parse(raw.ics);
   const v = targetVevent(root, raw);
-  setTime(v, "dtstart", fromIso(event.start, event.allDay));
+  writeEdit(v, event, email, fromIso(event.start, event.allDay), fromIso(event.end, event.allDay));
+  if (event.recurrence && !raw.recurrenceId && !v.hasProperty("rrule")) setRule(v, event.recurrence, event.allDay);
+  return root.toString();
+}
+function writeEdit(v, event, email, start, end) {
+  v.addProperty(replaceTime(v, "dtstart", start));
   v.removeAllProperties("duration");
-  setTime(v, "dtend", fromIso(event.end, event.allDay));
+  v.addProperty(replaceTime(v, "dtend", end));
   setText(v, "summary", event.title);
   setText(v, "location", event.location);
   setText(v, "description", event.description);
@@ -1228,10 +1485,156 @@ function applyUpdate(event, email) {
     event.attendees.map((a) => a.email),
     email
   );
+  bump(v);
+}
+function bump(v) {
   v.updatePropertyWithValue("sequence", Number(v.getFirstPropertyValue("sequence") ?? 0) + 1);
   touch(v);
+}
+function timeProp(name, t) {
+  const p = new ICAL.Property(name);
+  p.setValue(t);
+  const tzid = t.zone?.tzid;
+  if (!t.isDate && tzid && tzid !== "UTC" && tzid !== "floating") p.setParameter("tzid", tzid);
+  return p;
+}
+function replaceTime(v, name, t) {
+  v.removeAllProperties(name);
+  return timeProp(name, t);
+}
+var dtstart = (v) => v.getFirstPropertyValue("dtstart");
+var dateOf = (t) => ICAL.Time.fromData({ year: t.year, month: t.month, day: t.day, isDate: true });
+var daysBetween = (a, b) => Math.round(dateOf(b).subtractDate(dateOf(a)).toSeconds() / 86400);
+function addDays3(t, days) {
+  const x = t.clone();
+  x.adjust(days, 0, 0, 0);
+  return x;
+}
+function spanFrom(start, event) {
+  if (event.allDay) return [start, addDays3(start, daysBetween(fromIso(event.start, true), fromIso(event.end, true)))];
+  const end = start.clone();
+  end.adjust(0, 0, 0, (Date.parse(event.end) - Date.parse(event.start)) / 1e3);
+  return [start, end];
+}
+function slotShift(master, before, event) {
+  const anchor = dtstart(master);
+  const zone = anchor.isDate ? void 0 : anchor.zone;
+  const local = (t) => zone && !t.isDate ? t.convertToZone(zone) : t.clone();
+  const after = fromIso(event.start, event.allDay);
+  if (event.allDay) {
+    const days2 = daysBetween(local(before), after);
+    return (t) => addDays3(dateOf(local(t)), days2);
+  }
+  if (!anchor.isDate) {
+    const seconds = (zone ? after.convertToZone(zone) : after).subtractDate(local(before)).toSeconds();
+    return (t) => {
+      const x = local(t);
+      x.adjust(0, 0, 0, seconds);
+      return x;
+    };
+  }
+  const days = daysBetween(before, after);
+  return (t) => {
+    const d = addDays3(dateOf(t), days);
+    return ICAL.Time.fromData({ year: d.year, month: d.month, day: d.day, hour: after.hour, minute: after.minute, second: after.second }, ICAL.Timezone.utcTimezone);
+  };
+}
+function mapDates(v, name, map) {
+  const props = v.getAllProperties(name);
+  if (!props.length) return;
+  const out = [];
+  for (const p of props) {
+    for (const value of p.getValues()) {
+      if (!(value instanceof ICAL.Time)) {
+        const keep = new ICAL.Property(name);
+        keep.setValue(value);
+        out.push(keep);
+        continue;
+      }
+      const t = map(value);
+      if (t) out.push(timeProp(name, t));
+    }
+  }
+  v.removeAllProperties(name);
+  for (const p of out) v.addProperty(p);
+}
+var attendeeKey = (v) => v.getAllProperties("attendee").map((p) => cleanEmail(p.getFirstValue())).sort().join(",");
+function rewriteSeries(root, master, edited, event, email, shift, anchor) {
+  const shared = ["summary", "location", "description"].map((n) => [n, master.getFirstPropertyValue(n)]);
+  const people = attendeeKey(master);
+  const retyped = dtstart(master).isDate !== event.allDay;
+  const [start, end] = spanFrom(shift(anchor), event);
+  writeEdit(master, event, email, start, end);
+  mapDates(master, "exdate", shift);
+  mapDates(master, "rdate", shift);
+  for (const o of root.getAllSubcomponents("vevent")) {
+    const rid = o.getFirstPropertyValue("recurrence-id");
+    if (!rid) continue;
+    o.addProperty(replaceTime(o, "recurrence-id", shift(rid)));
+    if (o === edited) {
+      writeEdit(o, event, email, fromIso(event.start, event.allDay), fromIso(event.end, event.allDay));
+      continue;
+    }
+    const [s, e] = retyped ? spanFrom(shift(dtstart(o)), event) : [shift(dtstart(o)), shift(new ICAL.Event(o).endDate)];
+    o.addProperty(replaceTime(o, "dtstart", s));
+    o.removeAllProperties("duration");
+    o.addProperty(replaceTime(o, "dtend", e));
+    for (const [name, old] of shared) {
+      if (String(o.getFirstPropertyValue(name) ?? "") === String(old ?? "")) setText(o, name, event[name === "summary" ? "title" : name]);
+    }
+    if (attendeeKey(o) === people) setAttendees(o, event.attendees.map((a) => a.email), email);
+    bump(o);
+  }
+}
+var instanceStart = (master, override, rid) => override ? dtstart(override) : ridTime(master, rid).time;
+function applyUpdateSeries(event, email) {
+  const raw = event.raw;
+  const root = parse(raw.ics);
+  const master = findMaster(root);
+  if (!raw.recurrenceId || !master) return applyUpdate(event, email);
+  const edited = findOverride(root, raw.recurrenceId);
+  const shift = slotShift(master, instanceStart(master, edited, raw.recurrenceId), event);
+  rewriteSeries(root, master, edited, event, email, shift, dtstart(master));
+  applyRule(root, master, event);
   return root.toString();
 }
+function applySplitFollowing(event, email, uid) {
+  const raw = event.raw;
+  if (!raw.recurrenceId) throw new Error("Not a recurring instance");
+  const rest = applyDeleteFollowing(raw);
+  if (!rest) return null;
+  const root = parse(raw.ics);
+  const master = masterOf(root);
+  const slot = ridTime(master, raw.recurrenceId).time;
+  const cut = slot.toJSDate().getTime();
+  const edited = findOverride(root, raw.recurrenceId);
+  const shift = slotShift(master, instanceStart(master, edited, raw.recurrenceId), event);
+  for (const v of root.getAllSubcomponents("vevent")) {
+    const t = v.getFirstPropertyValue("recurrence-id");
+    if (t && t.toJSDate().getTime() < cut) root.removeSubcomponent(v);
+  }
+  const later = (t) => t.toJSDate().getTime() >= cut ? t : null;
+  mapDates(master, "exdate", later);
+  mapDates(master, "rdate", later);
+  const first = dtstart(master);
+  for (const p of event.recurrence === void 0 ? master.getAllProperties("rrule") : []) {
+    const r = p.getFirstValue().clone();
+    if (!r.count) continue;
+    const it = r.iterator(first);
+    let passed = 0;
+    for (let t = it.next(); t && t.toJSDate().getTime() < cut && passed < MAX_INSTANCES2; t = it.next()) passed++;
+    r.count = Math.max(1, r.count - passed);
+    p.setValue(r);
+  }
+  for (const v of root.getAllSubcomponents("vevent")) {
+    v.updatePropertyWithValue("uid", uid);
+    v.updatePropertyWithValue("sequence", -1);
+    v.updatePropertyWithValue("created", ICAL.Time.now());
+  }
+  rewriteSeries(root, master, edited, event, email, shift, slot);
+  applyRule(root, master, event);
+  return { rest, next: root.toString() };
+}
 function applyDeleteInstance(raw) {
   if (!raw.recurrenceId) throw new Error("Not a recurring instance");
   const root = parse(raw.ics);
@@ -1378,7 +1781,8 @@ var createCaldavProvider = (ctx) => {
     if (!obj?.data) throw new Error("Saved event could not be read back from the server");
     const range = { start: new Date(new Date(around.start).getTime() - DAY).toISOString(), end: new Date(new Date(around.end).getTime() + DAY).toISOString() };
     const events = parseEvents(obj.data, id2 === void 0 ? obj.url : href, obj.etag, mapCtx(calendarId), range);
-    const ev = id2 === void 0 ? events[0] : events.find((e) => e.id === id2);
+    const at3 = Date.parse(around.start);
+    const ev = id2 === void 0 ? events.find((e) => Date.parse(e.start) === at3) ?? events[0] : events.find((e) => e.id === id2);
     if (!ev) throw new Error("Saved event not found on the server");
     return ev;
   }
@@ -1406,9 +1810,24 @@ var createCaldavProvider = (ctx) => {
       const href = new URL(filename, calendarId.endsWith("/") ? calendarId : `${calendarId}/`).href;
       return reload(calendarId, href, void 0, input);
     },
-    async updateEvent(event) {
-      await put(event, applyUpdate(event, ctx.email), "Update event");
-      return reload(event.calendarId, event.raw.href, event.id, event);
+    async updateEvent(event, scope = "one") {
+      const raw = event.raw;
+      if (!raw.recurrenceId || scope === "one") {
+        await put(event, applyUpdate(event, ctx.email), "Update event");
+        return reload(event.calendarId, raw.href, event.recurrence ? void 0 : event.id, event);
+      }
+      const uid = randomUUID4();
+      const split = scope === "following" ? applySplitFollowing(event, ctx.email, uid) : null;
+      if (!split) {
+        await put(event, applyUpdateSeries(event, ctx.email), "Update event");
+        return reload(event.calendarId, raw.href, void 0, event);
+      }
+      await put(event, split.rest, "Update event");
+      const { headers } = await getConn();
+      const filename = `${uid}.ics`;
+      check(await createCalendarObject({ calendar: { url: event.calendarId }, filename, iCalString: split.next, headers, fetch: timedFetch }), "Update event");
+      const href = new URL(filename, event.calendarId.endsWith("/") ? event.calendarId : `${event.calendarId}/`).href;
+      return reload(event.calendarId, href, void 0, event);
     },
     async deleteEvent(event, scope = "one") {
       const raw = event.raw;
@@ -1417,6 +1836,9 @@ var createCaldavProvider = (ctx) => {
       const { headers } = await getConn();
       check(await deleteCalendarObject({ calendarObject: { url: raw.href, etag: event.etag }, headers, fetch: timedFetch }), "Delete event");
     },
+    async getRecurrence(event) {
+      return recurrenceOf(event.raw);
+    },
     async respond(event, status) {
       await put(event, applyRespond(event.raw, ctx.email, status), "Respond");
       return reload(event.calendarId, event.raw.href, event.id, event);
@@ -1440,7 +1862,7 @@ import { createHash as createHash2, randomBytes } from "crypto";
 import { createServer } from "http";
 var AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
 var TOKEN_URL = "https://oauth2.googleapis.com/token";
-var SCOPES = "openid email https://www.googleapis.com/auth/calendar";
+var SCOPES = "openid email https://www.googleapis.com/auth/calendar.calendarlist.readonly https://www.googleapis.com/auth/calendar.events";
 var TIMEOUT_MS = 5 * 60 * 1e3;
 var clientConfig = {};
 function setClientConfig(cfg) {
@@ -1607,7 +2029,29 @@ function truncateRecurrence(recurrence, cutoff) {
     return `RRULE:${[...parts, `UNTIL=${until}`].join(";")}`;
   });
 }
+var DAY2 = 864e5;
+var plusDays = (date, days) => new Date(Date.parse(date.slice(0, 10)) + days * DAY2).toISOString().slice(0, 10);
+var daysBetween2 = (a, b) => Math.round((Date.parse(b.slice(0, 10)) - Date.parse(a.slice(0, 10))) / DAY2);
+var localDate = (d) => [d.getFullYear(), d.getMonth() + 1, d.getDate()].map((n) => String(n).padStart(2, "0")).join("-");
+function shiftAnchor(anchor, before, start, allDay, timeZone) {
+  if (allDay) return { date: plusDays(anchor.date ?? anchor.dateTime, daysBetween2(before.date ?? before.dateTime, start)) };
+  if (anchor.dateTime && before.dateTime) {
+    return { dateTime: new Date(Date.parse(anchor.dateTime) + Date.parse(start) - Date.parse(before.dateTime)).toISOString(), timeZone };
+  }
+  const at3 = new Date(start);
+  const day = /* @__PURE__ */ new Date(`${plusDays(anchor.date, daysBetween2(before.date, localDate(at3)))}T00:00:00`);
+  day.setHours(at3.getHours(), at3.getMinutes(), at3.getSeconds());
+  return { dateTime: day.toISOString(), timeZone };
+}
+function endFrom(from, event, timeZone) {
+  if (event.allDay) return { date: plusDays(from.date, daysBetween2(event.start, event.end)) };
+  return { dateTime: new Date(Date.parse(from.dateTime) + Date.parse(event.end) - Date.parse(event.start)).toISOString(), timeZone };
+}
 var toGTime = (iso2, allDay) => allDay ? { date: iso2.slice(0, 10), dateTime: null, timeZone: null } : { dateTime: iso2, date: null, timeZone: null };
+var zoned = (iso2, allDay, timeZone) => allDay ? { date: iso2.slice(0, 10) } : { dateTime: iso2, timeZone };
+var localZone = () => Intl.DateTimeFormat().resolvedOptions().timeZone;
+var rruleLines = (r, allDay) => [`RRULE:${toRRule(r, allDay)}`];
+var nulled = (t) => ({ date: null, dateTime: null, timeZone: null, ...t });
 function createGoogleProviderImpl(ctx) {
   if (ctx.credentials.kind !== "google") throw new Error("Google provider needs Google credentials");
   let creds = ctx.credentials;
@@ -1645,6 +2089,35 @@ function createGoogleProviderImpl(ctx) {
     return !e.organizer || e.organizer.email.toLowerCase() === ctx.email.toLowerCase();
   };
   const map = (g, calendarId) => mapEvent(g, ctx.accountId, calendarId);
+  const fields = (event, prevAttendees, organizer) => {
+    const body = { summary: event.title, location: event.location ?? null, description: event.description ?? null };
+    if (organizer) {
+      const prev = new Map((prevAttendees ?? []).map((a) => [a.email.toLowerCase(), a]));
+      body.attendees = event.attendees.map((a) => prev.get(a.email.toLowerCase()) ?? { email: a.email, displayName: a.name });
+    }
+    return body;
+  };
+  async function remainingRecurrence(calendarId, series, recurrence, slot) {
+    const rules = recurrence.filter((l) => l.startsWith("RRULE:"));
+    if (!rules.some((l) => /;COUNT=|:COUNT=/i.test(l))) return rules;
+    const cut = Date.parse(slot.dateTime ?? slot.date);
+    let passed = 0;
+    let pageToken;
+    do {
+      const page = await api("GET", `${eventPath(calendarId, series)}/instances`, {
+        showDeleted: "true",
+        timeMax: new Date(cut).toISOString(),
+        maxResults: "2500",
+        ...pageToken ? { pageToken } : {}
+      });
+      for (const g of page.items ?? []) {
+        const t = g.originalStartTime ?? g.start;
+        if (Date.parse(t.dateTime ?? t.date) < cut) passed++;
+      }
+      pageToken = page.nextPageToken;
+    } while (pageToken);
+    return rules.map((l) => l.replace(/COUNT=(\d+)/i, (_, n) => `COUNT=${Math.max(1, Number(n) - passed)}`));
+  }
   return {
     async listCalendars() {
       const out = [];
@@ -1685,36 +2158,67 @@ function createGoogleProviderImpl(ctx) {
     },
     async createEvent(calendarId, input) {
       const attendees = (input.attendees ?? []).map((email) => ({ email }));
+      const rule = input.recurrence;
       const g = await api(
         "POST",
         eventPath(calendarId),
         { sendUpdates: attendees.length ? "all" : "none" },
         {
           summary: input.title,
-          start: toGTime(input.start, input.allDay),
-          end: toGTime(input.end, input.allDay),
+          start: rule ? zoned(input.start, input.allDay, localZone()) : toGTime(input.start, input.allDay),
+          end: rule ? zoned(input.end, input.allDay, localZone()) : toGTime(input.end, input.allDay),
           location: input.location,
           description: input.description,
-          attendees
+          attendees,
+          ...rule ? { recurrence: rruleLines(rule, input.allDay) } : {}
         }
       );
       return map(g, calendarId);
     },
-    async updateEvent(event) {
+    async updateEvent(event, scope = "one") {
       const organizer = isOrganizer(event);
-      const body = {
-        summary: event.title,
-        start: toGTime(event.start, event.allDay),
-        end: toGTime(event.end, event.allDay),
-        location: event.location ?? null,
-        description: event.description ?? null
-      };
-      if (organizer) {
-        const prev = new Map((rawOf(event)?.attendees ?? []).map((a) => [a.email.toLowerCase(), a]));
-        body.attendees = event.attendees.map((a) => prev.get(a.email.toLowerCase()) ?? { email: a.email, displayName: a.name });
+      const q = { sendUpdates: organizer ? "all" : "none" };
+      const series = event.recurringEventId;
+      const before = rawOf(event)?.start;
+      if (!series || scope === "one" || !before) {
+        const rule2 = !series ? event.recurrence : void 0;
+        const time = (iso2) => rule2 ? nulled(zoned(iso2, event.allDay, localZone())) : toGTime(iso2, event.allDay);
+        const body = {
+          ...fields(event, rawOf(event)?.attendees, organizer),
+          start: time(event.start),
+          end: time(event.end),
+          ...rule2 ? { recurrence: rruleLines(rule2, event.allDay) } : {}
+        };
+        return map(await api("PATCH", eventPath(event.calendarId, event.id), q, body), event.calendarId);
       }
-      const g = await api("PATCH", eventPath(event.calendarId, event.id), { sendUpdates: organizer ? "all" : "none" }, body);
-      return map(g, event.calendarId);
+      const master = await api("GET", eventPath(event.calendarId, series));
+      const timeZone = master.start.timeZone ?? localZone();
+      const rule = event.recurrence;
+      const slot = rawOf(event)?.originalStartTime ?? before;
+      const first = master.start.dateTime ?? master.start.date;
+      const at3 = slot.dateTime ?? slot.date;
+      if (scope === "all" || Date.parse(at3) <= Date.parse(first)) {
+        const start2 = rule === null ? zoned(event.start, event.allDay, timeZone) : shiftAnchor(master.start, before, event.start, event.allDay, timeZone);
+        const body = {
+          ...fields(event, master.attendees, organizer),
+          start: nulled(start2),
+          end: nulled(endFrom(start2, event, timeZone)),
+          // A new RRULE replaces the old ones; EXDATE/RDATE lines stay.
+          ...rule === void 0 ? {} : { recurrence: rule ? [...rruleLines(rule, event.allDay), ...(master.recurrence ?? []).filter((l) => !l.startsWith("RRULE:"))] : [] }
+        };
+        await api("PATCH", eventPath(event.calendarId, series), q, body);
+        return event;
+      }
+      const recurrence = rule === void 0 ? await remainingRecurrence(event.calendarId, series, master.recurrence ?? [], slot) : rule ? rruleLines(rule, event.allDay) : void 0;
+      await api("PATCH", eventPath(event.calendarId, series), q, { recurrence: truncateRecurrence(master.recurrence ?? [], slot) });
+      const start = shiftAnchor(slot, before, event.start, event.allDay, timeZone);
+      const created = await api("POST", eventPath(event.calendarId), q, {
+        ...fields(event, master.attendees, organizer),
+        start,
+        end: endFrom(start, event, timeZone),
+        ...recurrence ? { recurrence } : {}
+      });
+      return { ...map(created, event.calendarId), start: event.start, end: event.end, recurringEventId: recurrence ? created.id : void 0 };
     },
     async deleteEvent(event, scope = "one") {
       const q = { sendUpdates: isOrganizer(event) ? "all" : "none" };
@@ -1732,6 +2236,12 @@ function createGoogleProviderImpl(ctx) {
       }
       await api("DELETE", eventPath(event.calendarId, series), q);
     },
+    async getRecurrence(event) {
+      if (!event.recurringEventId) return null;
+      const master = await api("GET", eventPath(event.calendarId, event.recurringEventId));
+      const line = master.recurrence?.find((l) => l.startsWith("RRULE:"));
+      return line ? fromRRule(line, master.start.dateTime ?? master.start.date) : null;
+    },
     async respond(event, status) {
       const attendees = rawOf(event)?.attendees ?? event.attendees.map((a) => ({ email: a.email, displayName: a.name, responseStatus: a.status, self: a.self, organizer: a.organizer }));
       if (!attendees.some((a) => a.self)) throw new Error("This account is not an attendee of the event");
@@ -2070,32 +2580,32 @@ async function runDaemon() {
 // src/ui/hooks.ts
 import { createContext, useCallback, useContext, useEffect, useState } from "react";
 import { useStdout } from "ink";
-import { addDays as addDays3, addWeeks as addWeeks2, startOfDay as startOfDay2 } from "date-fns";
+import { addDays as addDays5, addWeeks as addWeeks2, startOfDay as startOfDay2 } from "date-fns";
 
 // ../../packages/core/src/logic/layout.ts
 import {
-  addDays as addDays2,
+  addDays as addDays4,
   addMonths as addMonths2,
   addWeeks,
-  format as format3,
+  format as format5,
   isSameDay as isSameDay2,
-  parseISO as parseISO4,
+  parseISO as parseISO5,
   startOfDay,
   startOfMonth,
-  startOfWeek
+  startOfWeek as startOfWeek2
 } from "date-fns";
 var WEEK_STARTS_ON = 1;
 function eventBounds(e) {
-  const start = parseISO4(e.start);
-  let end = parseISO4(e.end);
-  if (end <= start) end = e.allDay ? addDays2(start, 1) : new Date(start.getTime() + 6e4);
+  const start = parseISO5(e.start);
+  let end = parseISO5(e.end);
+  if (end <= start) end = e.allDay ? addDays4(start, 1) : new Date(start.getTime() + 6e4);
   return { start, end };
 }
 var isPast = (e, now) => eventBounds(e).end.getTime() <= +now;
 function overlapsDay(e, day) {
   const d0 = startOfDay(day);
   const { start, end } = eventBounds(e);
-  return start < addDays2(d0, 1) && end > d0;
+  return start < addDays4(d0, 1) && end > d0;
 }
 function eventsOnDay(events, day) {
   return events.filter((e) => overlapsDay(e, day)).sort((a, b) => {
@@ -2142,31 +2652,31 @@ function layoutDay(events, day, minDur = 0) {
   return packColumns(items, minDur);
 }
 function monthGrid(date) {
-  const first = startOfWeek(startOfMonth(date), { weekStartsOn: WEEK_STARTS_ON });
-  return Array.from({ length: 42 }, (_, i) => addDays2(first, i));
+  const first = startOfWeek2(startOfMonth(date), { weekStartsOn: WEEK_STARTS_ON });
+  return Array.from({ length: 42 }, (_, i) => addDays4(first, i));
 }
 function viewDays(view, date) {
   if (view === "month") return monthGrid(date);
   if (view === "day") return [startOfDay(date)];
-  if (view === "3day") return [0, 1, 2].map((i) => addDays2(startOfDay(date), i));
-  const first = startOfWeek(date, { weekStartsOn: WEEK_STARTS_ON });
-  return Array.from({ length: 7 }, (_, i) => addDays2(first, i));
+  if (view === "3day") return [0, 1, 2].map((i) => addDays4(startOfDay(date), i));
+  const first = startOfWeek2(date, { weekStartsOn: WEEK_STARTS_ON });
+  return Array.from({ length: 7 }, (_, i) => addDays4(first, i));
 }
 function viewRange(view, date) {
   const days = viewDays(view, date);
-  return { start: days[0].toISOString(), end: addDays2(days[days.length - 1], 1).toISOString() };
+  return { start: days[0].toISOString(), end: addDays4(days[days.length - 1], 1).toISOString() };
 }
 function shiftDate(view, date, dir) {
-  if (view === "day") return addDays2(date, dir);
-  if (view === "3day") return addDays2(date, 3 * dir);
+  if (view === "day") return addDays4(date, dir);
+  if (view === "3day") return addDays4(date, 3 * dir);
   if (view === "week") return addWeeks(date, dir);
   return addMonths2(date, dir);
 }
 function rangeLabel(a, b) {
   const head = a.getFullYear() !== b.getFullYear() ? "d MMM yyyy" : a.getMonth() !== b.getMonth() ? "d MMM" : "d";
-  return `${format3(a, head)} \u2013 ${format3(b, "d MMM yyyy")}`;
+  return `${format5(a, head)} \u2013 ${format5(b, "d MMM yyyy")}`;
 }
-var ymd = (d) => format3(d, "yyyy-MM-dd");
+var ymd = (d) => format5(d, "yyyy-MM-dd");
 
 // ../../packages/core/src/logic/visible.ts
 var key2 = (accountId, calendarId) => `${accountId}/${calendarId}`;
@@ -2186,7 +2696,7 @@ var eventKey = (e) => `${e.accountId}/${e.calendarId}/${e.id}`;
 function useLive(load, deps) {
   const api = useApi();
   const [state, setState] = useState({});
-  const [bump, setBump] = useState(0);
+  const [bump2, setBump] = useState(0);
   useEffect(() => {
     let seq = 0;
     let alive2 = true;
@@ -2203,7 +2713,7 @@ function useLive(load, deps) {
       alive2 = false;
       off();
     };
-  }, [api, bump, ...deps]);
+  }, [api, bump2, ...deps]);
   return { ...state, reload: useCallback(() => setBump((b) => b + 1), []) };
 }
 function useDirectory() {
@@ -2224,13 +2734,13 @@ var AGENDA_DAYS = 14;
 function navRange({ view, date }) {
   if (view === "agenda" || view === "2day") {
     const start = startOfDay2(date);
-    return { start: start.toISOString(), end: addDays3(start, view === "agenda" ? AGENDA_DAYS : 2).toISOString() };
+    return { start: start.toISOString(), end: addDays5(start, view === "agenda" ? AGENDA_DAYS : 2).toISOString() };
   }
   return viewRange(view, date);
 }
 var shiftNav = ({ view, date }, dir) => ({
   view,
-  date: view === "agenda" ? addWeeks2(date, dir) : view === "2day" ? addDays3(date, 2 * dir) : shiftDate(view, date, dir)
+  date: view === "agenda" ? addWeeks2(date, dir) : view === "2day" ? addDays5(date, 2 * dir) : shiftDate(view, date, dir)
 });
 function useNav(initial = { view: "agenda", date: /* @__PURE__ */ new Date() }) {
   const [nav, setNav] = useState(initial);
@@ -2265,12 +2775,12 @@ function useTermSize() {
 // src/ui/App.tsx
 import { useEffect as useEffect6, useMemo as useMemo6, useRef as useRef7, useState as useState8 } from "react";
 import { Box as Box11, Text as Text11, useApp, useStdin as useStdin2 } from "ink";
-import { addDays as addDays9, differenceInMinutes as differenceInMinutes3, format as format11, isSameMonth as isSameMonth2, max, set, startOfDay as startOfDay7 } from "date-fns";
+import { addDays as addDays11, differenceInMinutes as differenceInMinutes3, format as format13, isSameMonth as isSameMonth2, max, set, startOfDay as startOfDay7 } from "date-fns";
 
 // ../../packages/core/src/logic/editor.ts
-import { addDays as addDays4, addHours, format as format4, parseISO as parseISO5, startOfHour } from "date-fns";
+import { addDays as addDays6, addHours, format as format6, parseISO as parseISO6, startOfHour } from "date-fns";
 var LOCAL = "yyyy-MM-dd'T'HH:mm";
-var toLocalInput = (iso2) => format4(iso2.length === 10 ? parseISO5(iso2) : new Date(iso2), LOCAL);
+var toLocalInput = (iso2) => format6(iso2.length === 10 ? parseISO6(iso2) : new Date(iso2), LOCAL);
 var fromLocalInput = (local) => new Date(local).toISOString();
 var writableCalendars = (calendars, accountId) => calendars.filter((c) => c.accountId === accountId && !c.readOnly);
 var writableAccounts = (accounts, calendars) => accounts.filter((a) => writableCalendars(calendars, a.id).length > 0);
@@ -2280,8 +2790,8 @@ var splitEmails = (text2) => text2.split(/[\s,;]+/).map((s) => s.trim()).filter(
 var isEmail = (s) => EMAIL.test(s);
 function emptyForm(accounts, calendars, prefill = {}, now = /* @__PURE__ */ new Date()) {
   const accountId = soleId(writableAccounts(accounts, calendars));
-  const start = prefill.start ? toLocalInput(prefill.start) : format4(startOfHour(addHours(now, 1)), LOCAL);
-  let end = prefill.end ? toLocalInput(prefill.end) : format4(addHours(new Date(start), 1), LOCAL);
+  const start = prefill.start ? toLocalInput(prefill.start) : format6(startOfHour(addHours(now, 1)), LOCAL);
+  let end = prefill.end ? toLocalInput(prefill.end) : format6(addHours(new Date(start), 1), LOCAL);
   if (prefill.allDay && prefill.end) end = inclusiveEnd(start, end);
   return {
     accountId,
@@ -2292,11 +2802,13 @@ function emptyForm(accounts, calendars, prefill = {}, now = /* @__PURE__ */ new
     allDay: !!prefill.allDay,
     location: "",
     description: "",
-    attendees: []
+    attendees: [],
+    repeat: null,
+    repeatWas: null
   };
 }
 var inclusiveEnd = (startLocal, endLocal) => {
-  const d = format4(addDays4(new Date(endLocal), -1), LOCAL);
+  const d = format6(addDays6(new Date(endLocal), -1), LOCAL);
   return d.slice(0, 10) < startLocal.slice(0, 10) ? startLocal : d;
 };
 function formFromEvent(e) {
@@ -2311,23 +2823,28 @@ function formFromEvent(e) {
     allDay: e.allDay,
     location: e.location ?? "",
     description: e.description ?? "",
-    attendees: e.attendees.filter((a) => !a.self && !a.organizer).map((a) => a.email)
+    attendees: e.attendees.filter((a) => !a.self && !a.organizer).map((a) => a.email),
+    repeat: null,
+    // A series' rule isn't cached: the editor loads it (events.recurrence) and sets both fields.
+    repeatWas: e.recurringEventId ? void 0 : null
   };
 }
+var withLoadedRepeat = (f, rule) => ({ ...f, repeat: rule, repeatWas: rule });
+var repeatChanged = (f) => f.repeatWas !== void 0 && !sameRecurrence(f.repeat, f.repeatWas, f.start);
 function setAllDay(f, allDay) {
   if (allDay || f.end > f.start) return { ...f, allDay };
-  return { ...f, allDay, end: format4(addHours(new Date(f.start), 1), LOCAL) };
+  return { ...f, allDay, end: format6(addHours(new Date(f.start), 1), LOCAL) };
 }
 function moveStart(f, start) {
   const end = new Date(new Date(f.end).getTime() + new Date(start).getTime() - new Date(f.start).getTime());
-  return { ...f, start, end: format4(end, LOCAL) };
+  return { ...f, start, end: format6(end, LOCAL) };
 }
 function times(f) {
   if (f.allDay) {
     const start2 = f.start.slice(0, 10);
     const endIncl = f.end.slice(0, 10);
     if (endIncl < start2) throw new Error("End date is before start date");
-    return { allDay: true, start: start2, end: format4(addDays4(parseISO5(endIncl), 1), "yyyy-MM-dd") };
+    return { allDay: true, start: start2, end: format6(addDays6(parseISO6(endIncl), 1), "yyyy-MM-dd") };
   }
   const start = fromLocalInput(f.start);
   const end = fromLocalInput(f.end);
@@ -2350,7 +2867,8 @@ function formToInput(f) {
     ...times(f),
     location: f.location.trim() || void 0,
     description: f.description.trim() || void 0,
-    ...attendees.length ? { attendees } : {}
+    ...attendees.length ? { attendees } : {},
+    ...f.repeat ? { recurrence: f.repeat } : {}
   };
 }
 function applyForm(e, f) {
@@ -2364,7 +2882,9 @@ function applyForm(e, f) {
     ...times(f),
     location: f.location.trim() || void 0,
     description: f.description.trim() || void 0,
-    attendees: [...keep, ...invited]
+    attendees: [...keep, ...invited],
+    // Only a changed rule is sent; absent keeps the series' rule.
+    ...repeatChanged(f) ? { recurrence: f.repeat } : {}
   };
 }
 var errorText = (e) => String(e instanceof Error ? e.message : e).replace(/^Error invoking remote method '[^']+': (\w*Error: )?/, "");
@@ -2483,10 +3003,10 @@ function Button({ k, label, onPress, color: color2 = C.accent }) {
 // src/ui/views/Agenda.tsx
 import { useMemo, useReducer, useRef as useRef2 } from "react";
 import { Box as Box3, Text as Text3 } from "ink";
-import { addDays as addDays6, differenceInCalendarDays, differenceInMinutes as differenceInMinutes2, format as format7, isSameDay as isSameDay4, startOfDay as startOfDay3 } from "date-fns";
+import { addDays as addDays8, differenceInCalendarDays as differenceInCalendarDays2, differenceInMinutes as differenceInMinutes2, format as format9, isSameDay as isSameDay4, startOfDay as startOfDay3 } from "date-fns";
 
 // ../../packages/core/src/logic/details.ts
-import { addDays as addDays5, format as format5, isSameDay as isSameDay3, parseISO as parseISO6 } from "date-fns";
+import { addDays as addDays7, format as format7, isSameDay as isSameDay3, parseISO as parseISO7 } from "date-fns";
 var same = (a, b) => !!a && !!b && a.trim().toLowerCase() === b.trim().toLowerCase();
 function ownerLine(calendar, label, email) {
   return { calendar: same(calendar, label) || same(calendar, email) ? void 0 : calendar, label, email: same(email, label) ? void 0 : email };
@@ -2496,17 +3016,17 @@ function canEdit(e, account, calendar) {
   if (e.attendees.length === 0) return true;
   return same(e.organizer?.email, account.email) || e.attendees.some((a) => a.self && a.organizer);
 }
-var at2 = (iso2, allDay) => (allDay ? parseISO6(iso2) : new Date(iso2)).getTime();
+var at2 = (iso2, allDay) => (allDay ? parseISO7(iso2) : new Date(iso2)).getTime();
 var pendingInvites = (events, now = /* @__PURE__ */ new Date()) => events.filter((e) => e.myStatus === "needsAction" && at2(e.end, e.allDay) > now.getTime()).sort((a, b) => at2(a.start, a.allDay) - at2(b.start, b.allDay));
 function formatWhen(e) {
   if (e.allDay) {
-    const s2 = parseISO6(e.start);
-    const last = addDays5(parseISO6(e.end), -1);
-    return last > s2 ? `${format5(s2, "EEE, d MMM")} \u2013 ${format5(last, "EEE, d MMM")} \xB7 all day` : `${format5(s2, "EEE, d MMM")} \xB7 all day`;
+    const s2 = parseISO7(e.start);
+    const last = addDays7(parseISO7(e.end), -1);
+    return last > s2 ? `${format7(s2, "EEE, d MMM")} \u2013 ${format7(last, "EEE, d MMM")} \xB7 all day` : `${format7(s2, "EEE, d MMM")} \xB7 all day`;
   }
   const s = new Date(e.start);
   const t = new Date(e.end);
-  return isSameDay3(s, t) ? `${format5(s, "EEE, d MMM")} \xB7 ${format5(s, "HH:mm")} \u2013 ${format5(t, "HH:mm")}` : `${format5(s, "EEE, d MMM HH:mm")} \u2013 ${format5(t, "EEE, d MMM HH:mm")}`;
+  return isSameDay3(s, t) ? `${format7(s, "EEE, d MMM")} \xB7 ${format7(s, "HH:mm")} \u2013 ${format7(t, "HH:mm")}` : `${format7(s, "EEE, d MMM HH:mm")} \u2013 ${format7(t, "EEE, d MMM HH:mm")}`;
 }
 var STATUS_ICON = {
   accepted: "\u2713",
@@ -2527,7 +3047,7 @@ function place(location = "") {
 }
 
 // ../../packages/core/src/logic/status.ts
-import { differenceInMinutes, format as format6 } from "date-fns";
+import { differenceInMinutes, format as format8 } from "date-fns";
 function pickNowNext(events, now) {
   const t = now.getTime();
   const timed = events.filter((e) => !e.allDay && e.myStatus !== "declined").sort((a, b) => Date.parse(a.start) - Date.parse(b.start));
@@ -2539,7 +3059,7 @@ function pickNowNext(events, now) {
 function startsLabel(start, now) {
   const s = new Date(start);
   const m = differenceInMinutes(s, now, { roundingMethod: "ceil" });
-  return m <= 60 ? `in ${m}m` : `at ${format6(s, "HH:mm")}`;
+  return m <= 60 ? `in ${m}m` : `at ${format8(s, "HH:mm")}`;
 }
 
 // src/ui/screens/EventDetails.tsx
@@ -2753,7 +3273,7 @@ var span = (m) => {
 };
 function busyMinutes(list, day) {
   const from = +startOfDay3(day);
-  const to = +addDays6(day, 1);
+  const to = +addDays8(day, 1);
   const iv = list.filter((e) => !e.allDay && e.myStatus !== "declined").map((e) => [Math.max(+eventBounds(e).start, from), Math.min(+eventBounds(e).end, to)]).sort((a, b) => a[0] - b[0]);
   let total = 0;
   let end = -Infinity;
@@ -2768,7 +3288,7 @@ var overlaps = (e, list) => !e.allDay && e.myStatus !== "declined" && list.some(
   (o) => o !== e && !o.allDay && o.myStatus !== "declined" && eventBounds(o).start < eventBounds(e).end && eventBounds(e).start < eventBounds(o).end
 );
 function relativeDay(day, now) {
-  const d = differenceInCalendarDays(day, now);
+  const d = differenceInCalendarDays2(day, now);
   return d === 0 ? "today" : d === 1 ? "tomorrow" : d === -1 ? "yesterday" : d > 0 ? `in ${d} days` : `${-d} days ago`;
 }
 function fitParts(parts, w) {
@@ -2797,7 +3317,7 @@ function Agenda({ events, date, now, selectedKey, width, height, onSelect, onOpe
   const rows = useMemo(() => {
     const out = [];
     for (let i = 0; i < AGENDA_DAYS; i++) {
-      const day = addDays6(startOfDay3(date), i);
+      const day = addDays8(startOfDay3(date), i);
       const list = eventsOnDay(events, day);
       if (!list.length) {
         const last = out.at(-1);
@@ -2838,7 +3358,7 @@ function Agenda({ events, date, now, selectedKey, width, height, onSelect, onOpe
     const key3 = "free" in r ? `free${ymd(r.free[0])}` : "e" in r ? `${ymd(r.day)}/${eventKey(r.e)}` : "nowLine" in r ? `${ymd(r.day)}/now` : "divider" in r ? `${ymd(r.day)}/d${i}` : ymd(r.day);
     if ("free" in r) {
       const [a, b] = r.free;
-      const label = isSameDay4(a, b) ? format7(a, "EEE d MMM") : `${format7(a, "EEE d MMM")} \u2013 ${format7(b, "EEE d MMM")}`;
+      const label = isSameDay4(a, b) ? format9(a, "EEE d MMM") : `${format9(a, "EEE d MMM")} \u2013 ${format9(b, "EEE d MMM")}`;
       lines.push(
         /* @__PURE__ */ jsx3(Box3, { width, height: 1, overflow: "hidden", children: /* @__PURE__ */ jsx3(Text3, { color: C.muted, wrap: "truncate", children: ` ${label}  free` }) }, key3)
       );
@@ -2852,7 +3372,7 @@ function Agenda({ events, date, now, selectedKey, width, height, onSelect, onOpe
     }
     if ("nowLine" in r) {
       lines.push(
-        /* @__PURE__ */ jsx3(Box3, { width, height: 1, overflow: "hidden", children: /* @__PURE__ */ jsx3(Text3, { color: C.now, bold: true, wrap: "truncate", children: `  ${format7(now, "HH:mm")} ${"\u2500".repeat(width)}` }) }, key3)
+        /* @__PURE__ */ jsx3(Box3, { width, height: 1, overflow: "hidden", children: /* @__PURE__ */ jsx3(Text3, { color: C.now, bold: true, wrap: "truncate", children: `  ${format9(now, "HH:mm")} ${"\u2500".repeat(width)}` }) }, key3)
       );
       return;
     }
@@ -2860,7 +3380,7 @@ function Agenda({ events, date, now, selectedKey, width, height, onSelect, onOpe
       const today = isSameDay4(r.day, now);
       const list = eventsOnDay(events, r.day);
       const busy = busyMinutes(list, r.day);
-      const left = ` ${format7(r.day, "EEE d MMM")}  `;
+      const left = ` ${format9(r.day, "EEE d MMM")}  `;
       const rel = relativeDay(r.day, now);
       const right = ` ${list.length} ${list.length === 1 ? "event" : "events"}${busy ? ` \xB7 ${span(busy)} busy` : ""} `;
       const rule = "\u2500".repeat(Math.max(width - left.length - rel.length - right.length - 1, 1));
@@ -2878,7 +3398,7 @@ function Agenda({ events, date, now, selectedKey, width, height, onSelect, onOpe
     const { start, end } = eventBounds(e);
     const running = !e.allDay && start <= now && now < end;
     const past = isPast(e, now) || e.myStatus === "declined";
-    const clockOf = (d, edge) => isSameDay4(d, r.day) ? format7(d, "HH:mm") : +d === +addDays6(r.day, 1) ? "24:00" : edge;
+    const clockOf = (d, edge) => isSameDay4(d, r.day) ? format9(d, "HH:mm") : +d === +addDays8(r.day, 1) ? "24:00" : edge;
     const badges = [];
     if (running) badges.push({ text: `  \u25CF now \xB7 ends in ${span(Math.max(differenceInMinutes2(end, now, { roundingMethod: "ceil" }), 1))}`, color: C.green, bold: true });
     else if (e === upNext) badges.push({ text: `  ${startsLabel(e.start, now)}`, color: C.yellow });
@@ -2916,16 +3436,16 @@ function Agenda({ events, date, now, selectedKey, width, height, onSelect, onOpe
 
 // src/ui/views/Day.tsx
 import { useMemo as useMemo3 } from "react";
-import { addDays as addDays7, startOfDay as startOfDay5 } from "date-fns";
+import { addDays as addDays9, startOfDay as startOfDay5 } from "date-fns";
 
 // src/ui/views/TimeGrid.tsx
 import { useMemo as useMemo2 } from "react";
 import { Box as Box5, Text as Text5 } from "ink";
-import { format as format9, isSameDay as isSameDay6 } from "date-fns";
+import { format as format11, isSameDay as isSameDay6 } from "date-fns";
 
 // src/ui/views/Month.tsx
 import { Box as Box4, Text as Text4 } from "ink";
-import { format as format8, isSameDay as isSameDay5, isSameMonth, startOfDay as startOfDay4 } from "date-fns";
+import { format as format10, isSameDay as isSameDay5, isSameMonth, startOfDay as startOfDay4 } from "date-fns";
 import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
 function fit(items, rows, selected) {
   if (items.length <= rows) return { shown: items, more: 0 };
@@ -2936,7 +3456,7 @@ function fit(items, rows, selected) {
 }
 function EventLine({ e, day, now, selected, time, onSelect, onOpen }) {
   const { start, end } = eventBounds(e);
-  const prefix = !time || e.allDay ? "" : start < startOfDay4(day) ? "\u2026     " : `${format8(start, "HH:mm")} `;
+  const prefix = !time || e.allDay ? "" : start < startOfDay4(day) ? "\u2026     " : `${format10(start, "HH:mm")} `;
   const live = !e.allDay && start <= now && now < end;
   return /* @__PURE__ */ jsx4(Clickable, { height: 1, onClick: clickEvent(e, selected, { onSelect, onOpen }), children: /* @__PURE__ */ jsxs4(
     Text4,
@@ -2960,7 +3480,7 @@ function Month({ events, date, now, cursor, selectedKey, width, height, onSelect
   const cellHeight = Math.max(Math.floor((height - 1) / 6), 1);
   const weeks = [0, 1, 2, 3, 4, 5].map((w) => days.slice(w * 7, w * 7 + 7));
   return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx4(Box4, { children: weeks[0].map((d) => /* @__PURE__ */ jsx4(Box4, { width: colWidth, children: /* @__PURE__ */ jsx4(Text4, { color: C.accent, bold: true, children: format8(d, "EEE") }) }, d.getDay())) }),
+    /* @__PURE__ */ jsx4(Box4, { children: weeks[0].map((d) => /* @__PURE__ */ jsx4(Box4, { width: colWidth, children: /* @__PURE__ */ jsx4(Text4, { color: C.accent, bold: true, children: format10(d, "EEE") }) }, d.getDay())) }),
     weeks.map((week) => /* @__PURE__ */ jsx4(Box4, { height: cellHeight, children: week.map((day) => {
       const items = eventsOnDay(events, day);
       const { shown, more } = fit(items, cellHeight - 1, items.findIndex((e) => eventKey(e) === selectedKey));
@@ -2974,7 +3494,7 @@ function Month({ events, date, now, cursor, selectedKey, width, height, onSelect
             inverse: here,
             color: today ? C.now : here ? C.accent : isSameMonth(day, date) ? void 0 : C.muted,
             children: [
-              here ? ` ${format8(day, "d")} ` : format8(day, "d"),
+              here ? ` ${format10(day, "d")} ` : format10(day, "d"),
               cellHeight === 1 && items.length > 0 && /* @__PURE__ */ jsxs4(Text4, { color: C.muted, children: [
                 " \xB7",
                 items.length
@@ -3064,10 +3584,10 @@ function TimeGrid({ days, events, now, cursor, selectedKey, width, height, onSel
       const selected = k === selectedKey;
       const first = p.start / 60;
       const { start, end } = eventBounds(e);
-      const from = isSameDay6(start, day) ? format9(start, "HH:mm") : "\u2026";
+      const from = isSameDay6(start, day) ? format11(start, "HH:mm") : "\u2026";
       const title2 = `${rsvpMark(e)}${e.title || "(no title)"}`;
       const where = place(e.location);
-      const lines = colW < COMPACT_BELOW ? [p.end - p.start > 60 || start.getMinutes() === 0 ? title2 : `:${format9(start, "mm")} ${title2}`, `${from}\u2013${isSameDay6(end, day) ? format9(end, "HH:mm") : "\u2026"}`, where] : [`${from} ${title2}`, [where, duration(e)].filter(Boolean).join(" \xB7 ")];
+      const lines = colW < COMPACT_BELOW ? [p.end - p.start > 60 || start.getMinutes() === 0 ? title2 : `:${format11(start, "mm")} ${title2}`, `${from}\u2013${isSameDay6(end, day) ? format11(end, "HH:mm") : "\u2026"}`, where] : [`${from} ${title2}`, [where, duration(e)].filter(Boolean).join(" \xB7 ")];
       const text2 = lines[h - first] ?? "";
       const inner = p.col < p.cols - 1 && w > 1 ? w - 1 : w;
       const past = isPast(e, now) || e.myStatus === "declined";
@@ -3095,7 +3615,7 @@ function TimeGrid({ days, events, now, cursor, selectedKey, width, height, onSel
       const isToday = isSameDay6(c.day, now);
       const here = !!cursor && isSameDay6(c.day, cursor) && days.length > 1;
       return /* @__PURE__ */ jsx5(Clickable, { height: 1, width: colW, onClick: onPickDay && (() => onPickDay(c.day)), children: /* @__PURE__ */ jsxs5(Text5, { wrap: "truncate", children: [
-        /* @__PURE__ */ jsx5(Text5, { bold: true, inverse: here, color: isToday ? C.now : C.accent, children: ` ${format9(c.day, "EEE d")} ` }),
+        /* @__PURE__ */ jsx5(Text5, { bold: true, inverse: here, color: isToday ? C.now : C.accent, children: ` ${format11(c.day, "EEE d")} ` }),
         c.count > 0 && /* @__PURE__ */ jsxs5(Text5, { color: C.muted, children: [
           "\xB7",
           c.count
@@ -3125,7 +3645,7 @@ function TimeGrid({ days, events, now, cursor, selectedKey, width, height, onSel
     /* @__PURE__ */ jsx5(Clickable, { flexDirection: "column", width, onWheel: (dir) => scrollBy(dir), children: Array.from({ length: Math.min(gridH, 24) }, (_, i) => {
       const h = top + i;
       const current = today && h === now.getHours();
-      const gutter = /* @__PURE__ */ jsx5(Box5, { width: GUTTER, flexShrink: 0, children: /* @__PURE__ */ jsx5(Text5, { color: current ? C.now : C.muted, bold: current, children: current ? `${format9(now, "HH:mm")}\u2500` : `${String(h).padStart(2, "0")}:00` }) });
+      const gutter = /* @__PURE__ */ jsx5(Box5, { width: GUTTER, flexShrink: 0, children: /* @__PURE__ */ jsx5(Text5, { color: current ? C.now : C.muted, bold: current, children: current ? `${format11(now, "HH:mm")}\u2500` : `${String(h).padStart(2, "0")}:00` }) });
       return row(
         `h${h}`,
         gutter,
@@ -3140,7 +3660,7 @@ function TimeGrid({ days, events, now, cursor, selectedKey, width, height, onSel
 import { jsx as jsx6 } from "react/jsx-runtime";
 function useDays(date, n) {
   const t = startOfDay5(date).getTime();
-  return useMemo3(() => Array.from({ length: n }, (_, i) => addDays7(t, i)), [t, n]);
+  return useMemo3(() => Array.from({ length: n }, (_, i) => addDays9(t, i)), [t, n]);
 }
 var Day = (p) => /* @__PURE__ */ jsx6(TimeGrid, { ...p, days: useDays(p.date, 1) });
 var TwoDay = (p) => /* @__PURE__ */ jsx6(TimeGrid, { ...p, days: useDays(p.date, 2) });
@@ -3157,7 +3677,7 @@ function Week(p) {
 // src/ui/screens/EventEditor.tsx
 import { useEffect as useEffect3, useRef as useRef3, useState as useState3 } from "react";
 import { Box as Box6, Text as Text6 } from "ink";
-import { format as format10, isValid, parse as parse2 } from "date-fns";
+import { format as format12, isValid as isValid2, parse as parse2 } from "date-fns";
 import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
 var LABELS = {
   title: "Title",
@@ -3170,20 +3690,29 @@ var LABELS = {
   endTime: "End time",
   location: "Location",
   description: "Notes",
-  attendees: "Invitees"
+  attendees: "Invitees",
+  repeat: "Repeat",
+  repeatEvery: "Every",
+  repeatDays: "On days",
+  repeatEnds: "Stops"
 };
+var SCOPE_KEYS2 = { "1": "one", "2": "following", "3": "all" };
 var HINTS = {
   startDate: "YYYY-MM-DD",
   startTime: "HH:mm",
   endDate: "YYYY-MM-DD",
   endTime: "HH:mm",
   attendees: "a@x.com, b@y.com",
-  title: "New Event"
+  title: "New Event",
+  repeatEvery: "2 weeks",
+  repeatDays: "mo th",
+  repeatEnds: "never \xB7 2026-12-31 \xB7 10 times"
 };
+var PICKERS = /* @__PURE__ */ new Set(["account", "calendar", "allDay", "repeat"]);
 function toLocal(date, time) {
   if (!/^\d{4}-\d{2}-\d{2}$/.test(date) || !/^\d{2}:\d{2}$/.test(time)) return;
   const d = parse2(`${date}T${time}`, "yyyy-MM-dd'T'HH:mm", /* @__PURE__ */ new Date());
-  return isValid(d) && format10(d, "yyyy-MM-dd'T'HH:mm") === `${date}T${time}` ? `${date}T${time}` : void 0;
+  return isValid2(d) && format12(d, "yyyy-MM-dd'T'HH:mm") === `${date}T${time}` ? `${date}T${time}` : void 0;
 }
 var timeTexts = (f) => ({
   startDate: f.start.slice(0, 10),
@@ -3191,25 +3720,48 @@ var timeTexts = (f) => ({
   endDate: f.end.slice(0, 10),
   endTime: f.end.slice(11)
 });
+var repeatTexts = (r, start) => ({
+  repeatEvery: r ? everyText(r) : "",
+  repeatDays: daysText(r?.byDay?.length ? r.byDay : [weekdayOf(start)]),
+  repeatEnds: r ? endsText(r) : "never"
+});
 var textsFrom = (f) => ({
   title: f.title,
   location: f.location,
   description: f.description,
   attendees: f.attendees.join(", "),
-  ...timeTexts(f)
+  ...timeTexts(f),
+  ...repeatTexts(f.repeat, f.start)
 });
-var fieldsFor = (form, editing) => [
-  "title",
-  ...editing ? [] : ["account", "calendar"],
-  "allDay",
-  "startDate",
-  ...form.allDay ? [] : ["startTime"],
-  "endDate",
-  ...form.allDay ? [] : ["endTime"],
-  "location",
-  "description",
-  "attendees"
-];
+var isCustom = (s) => !!s.form.repeat && !s.form.repeat.rule && (s.custom || presetOf(s.form.repeat, s.form.start) === "custom");
+var fieldsFor = (s, editing) => {
+  const { form } = s;
+  const custom = isCustom(s);
+  return [
+    "title",
+    ...editing ? [] : ["account", "calendar"],
+    "allDay",
+    "startDate",
+    ...form.allDay ? [] : ["startTime"],
+    "endDate",
+    ...form.allDay ? [] : ["endTime"],
+    "repeat",
+    ...custom ? ["repeatEvery"] : [],
+    ...custom && form.repeat?.freq === "weekly" ? ["repeatDays"] : [],
+    ...form.repeat && !form.repeat.rule ? ["repeatEnds"] : [],
+    "location",
+    "description",
+    "attendees"
+  ];
+};
+function readRepeat(s) {
+  const r = s.form.repeat;
+  if (!r || r.rule) return r;
+  const { until: _u, count: _c, ...base } = r;
+  const rule = isCustom(s) ? { ...parseEvery(s.texts.repeatEvery) } : base;
+  if (isCustom(s) && rule.freq === "weekly") rule.byDay = parseDays(s.texts.repeatDays);
+  return { ...rule, ...parseEnds(s.texts.repeatEnds) };
+}
 function EventEditor({ event, initialStart, onClose }) {
   const api = useApi();
   const { accounts, calendars, loaded } = useDirectory();
@@ -3223,18 +3775,41 @@ function EventEditor({ event, initialStart, onClose }) {
   const [error, setError] = useState3("");
   const [saving, setSaving] = useState3(false);
   const busy = useRef3(false);
+  const [askScope, setAskScopeState] = useState3(false);
+  const asking = useRef3(false);
+  const setAskScope = (on) => {
+    asking.current = on;
+    setAskScopeState(on);
+  };
+  const [repeatFailed, setRepeatFailed] = useState3(false);
   const alive2 = useRef3(true);
   useEffect3(() => () => void (alive2.current = false), []);
   useEffect3(() => {
     if (latest.current || !loaded) return;
     const form2 = event ? formFromEvent(event) : emptyForm(accounts, calendars, {}, initialStart);
-    latest.current = { form: form2, texts: textsFrom(form2), focus: 0 };
+    latest.current = { form: form2, texts: textsFrom(form2), focus: 0, custom: false };
     setState(latest.current);
+    if (event?.recurringEventId) {
+      api.events.recurrence(event).then(
+        (rule) => {
+          if (!alive2.current || !latest.current) return;
+          const f = withLoadedRepeat(latest.current.form, rule);
+          update({ form: f, texts: { ...latest.current.texts, ...repeatTexts(rule, f.start) } });
+        },
+        () => alive2.current && setRepeatFailed(true)
+      );
+    }
   }, [loaded]);
   const choices = writableAccounts(accounts, calendars);
-  const save = async () => {
+  const save = async (scope) => {
     if (!latest.current || busy.current) return;
     const { form: form2, texts: texts2 } = latest.current;
+    let repeat;
+    try {
+      repeat = readRepeat(latest.current);
+    } catch (e) {
+      return setError(errorText(e));
+    }
     setError("");
     const start = toLocal(texts2.startDate, form2.allDay ? form2.start.slice(11) : texts2.startTime);
     const end = toLocal(texts2.endDate, form2.allDay ? form2.end.slice(11) : texts2.endTime);
@@ -3247,14 +3822,18 @@ function EventEditor({ event, initialStart, onClose }) {
       description: texts2.description,
       attendees: splitEmails(texts2.attendees),
       start,
-      end
+      end,
+      repeat
     };
     let request;
     try {
-      request = event ? api.events.update(applyForm(event, f)) : api.events.create(formToInput(f));
+      const edited = event && applyForm(event, f);
+      if (edited && event.recurringEventId && !scope) return setAskScope(repeatChanged(f) ? "rule" : "any");
+      request = edited ? api.events.update(edited, scope) : api.events.create(formToInput(f));
     } catch (e) {
       return setError(errorText(e));
     }
+    setAskScope(false);
     busy.current = true;
     setSaving(true);
     try {
@@ -3273,7 +3852,8 @@ function EventEditor({ event, initialStart, onClose }) {
     const i = items.findIndex((x) => x.id === id2);
     return items[i < 0 ? dir > 0 ? 0 : items.length - 1 : (i + dir + items.length) % items.length].id;
   };
-  const pick = ({ form: form2, texts: texts2 }, field, dir) => {
+  const pick = (st, field, dir) => {
+    const { form: form2, texts: texts2 } = st;
     if (field === "account") {
       const accountId = cycle2(choices, form2.accountId, dir);
       update({ form: { ...form2, accountId, calendarId: soleId(writableCalendars(calendars, accountId)) } });
@@ -3282,6 +3862,19 @@ function EventEditor({ event, initialStart, onClose }) {
     } else if (field === "allDay") {
       const f = setAllDay(form2, !form2.allDay);
       update({ form: f, texts: { ...texts2, ...timeTexts(f) } });
+    } else if (field === "repeat") {
+      if (form2.repeatWas === void 0) return;
+      const ids = [...presets(form2.start).map((p) => p.id), "custom"];
+      const at3 = ids.indexOf(isCustom(st) ? "custom" : presetOf(form2.repeat, form2.start));
+      const next = ids[(at3 + dir + ids.length) % ids.length];
+      let prev = form2.repeat;
+      try {
+        prev = readRepeat(st);
+      } catch {
+      }
+      const preset = presets(form2.start).find((p) => p.id === next)?.recurrence;
+      const repeat = next === "custom" ? prev && !prev.rule ? prev : withEnd({ freq: "weekly" }, prev) : preset ? withEnd(preset, prev) : null;
+      update({ form: { ...form2, repeat }, custom: next === "custom", texts: { ...texts2, ...repeatTexts(repeat, form2.start) } });
     }
   };
   const edit = ({ form: form2, texts: texts2 }, field, value2) => {
@@ -3301,17 +3894,22 @@ function EventEditor({ event, initialStart, onClose }) {
   const clickField = (f) => {
     const s = latest.current;
     if (!s || busy.current) return;
-    const i = fieldsFor(s.form, !!event).indexOf(f);
+    const i = fieldsFor(s, !!event).indexOf(f);
     if (i < 0) return;
-    if (i === s.focus && (f === "account" || f === "calendar" || f === "allDay")) return pick(s, f, 1);
+    if (i === s.focus && PICKERS.has(f)) return pick(s, f, 1);
     update({ focus: i });
   };
   useKeys((input, key3) => {
+    if (key3.escape && asking.current && !busy.current) return setAskScope(false);
     if (key3.escape) return onClose();
     const s = latest.current;
     if (!s || busy.current) return;
+    if (asking.current) {
+      if (!Object.hasOwn(SCOPE_KEYS2, input) || asking.current === "rule" && SCOPE_KEYS2[input] === "one") return;
+      return void save(SCOPE_KEYS2[input]);
+    }
     if (key3.ctrl && input === "s") return void save();
-    const fields2 = fieldsFor(s.form, !!event);
+    const fields2 = fieldsFor(s, !!event);
     const i = Math.min(s.focus, fields2.length - 1);
     const field = fields2[i];
     const move = (dir) => update({ focus: (i + dir + fields2.length) % fields2.length });
@@ -3319,19 +3917,20 @@ function EventEditor({ event, initialStart, onClose }) {
     if (key3.downArrow) return move(1);
     if (key3.upArrow) return move(-1);
     if (key3.return) return i === fields2.length - 1 ? void save() : move(1);
-    if (field === "account" || field === "calendar" || field === "allDay") {
+    if (PICKERS.has(field)) {
       if (key3.leftArrow) pick(s, field, -1);
       else if (key3.rightArrow || input === " ") pick(s, field, 1);
       return;
     }
-    if (key3.backspace || key3.delete) return edit(s, field, s.texts[field].slice(0, -1));
+    const text2 = field;
+    if (key3.backspace || key3.delete) return edit(s, text2, s.texts[text2].slice(0, -1));
     if (key3.ctrl || key3.meta || !input) return;
     const printable = input.replace(/[\u0000-\u001f\u007f]/g, "");
-    if (printable) edit(s, field, s.texts[field] + printable);
+    if (printable) edit(s, text2, s.texts[text2] + printable);
   });
   if (!state) return /* @__PURE__ */ jsx8(Text6, { color: C.muted, children: "Loading\u2026" });
   const { form, texts } = state;
-  const fields = fieldsFor(form, !!event);
+  const fields = fieldsFor(state, !!event);
   const current = fields[Math.min(state.focus, fields.length - 1)];
   const account = accounts.find((a) => a.id === form.accountId);
   const calendar = calendars.find((c) => c.accountId === form.accountId && c.id === form.calendarId);
@@ -3346,6 +3945,11 @@ function EventEditor({ event, initialStart, onClose }) {
         return calendar ? { text: calendar.name } : { text: "\u2039 choose calendar \u203A", dim: true };
       case "allDay":
         return { text: form.allDay ? "[x]" : "[ ]" };
+      case "repeat":
+        if (form.repeatWas === void 0) return { text: repeatFailed ? "couldn\u2019t load; stays as it is" : "loading\u2026", dim: true };
+        if (form.repeat?.rule) return { text: describe(form.repeat, form.start) };
+        if (isCustom(state)) return { text: "Custom" };
+        return { text: presets(form.start).find((p) => p.id === presetOf(form.repeat, form.start)).label };
       default:
         return texts[f] ? { text: texts[f] } : { text: HINTS[f] ?? "", dim: true };
     }
@@ -3356,7 +3960,7 @@ function EventEditor({ event, initialStart, onClose }) {
     rows.map((f) => {
       const on = f === current;
       const v = value(f);
-      const picker = !event && (f === "account" || f === "calendar");
+      const picker = !event && (f === "account" || f === "calendar") || f === "repeat";
       return /* @__PURE__ */ jsxs6(Clickable, { onClick: () => clickField(f), children: [
         /* @__PURE__ */ jsxs6(Text6, { color: on ? C.cyan : void 0, children: [
           on ? "\u203A " : "  ",
@@ -3368,7 +3972,13 @@ function EventEditor({ event, initialStart, onClose }) {
     }),
     /* @__PURE__ */ jsx8(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text6, { color: C.muted, children: account ? `Organizer: ${account.email}` : "Choose which account this event belongs to." }) }),
     error && /* @__PURE__ */ jsx8(Text6, { color: C.red, children: error }),
-    saving ? /* @__PURE__ */ jsx8(Text6, { color: C.yellow, children: "Saving\u2026" }) : /* @__PURE__ */ jsxs6(Box6, { flexWrap: "wrap", children: [
+    saving ? /* @__PURE__ */ jsx8(Text6, { color: C.yellow, children: "Saving\u2026" }) : askScope ? /* @__PURE__ */ jsxs6(Box6, { flexWrap: "wrap", children: [
+      /* @__PURE__ */ jsx8(Text6, { color: C.yellow, children: askScope === "rule" ? "Change the repeat rule for: " : "Save recurring event: " }),
+      askScope !== "rule" && /* @__PURE__ */ jsx8(Button, { k: "1", label: "this event", color: C.green, onPress: () => void save("one") }),
+      /* @__PURE__ */ jsx8(Button, { k: "2", label: "this and following", color: C.green, onPress: () => void save("following") }),
+      /* @__PURE__ */ jsx8(Button, { k: "3", label: "all events", color: C.green, onPress: () => void save("all") }),
+      /* @__PURE__ */ jsx8(Button, { k: "esc", label: "back", onPress: () => setAskScope(false) })
+    ] }) : /* @__PURE__ */ jsxs6(Box6, { flexWrap: "wrap", children: [
       /* @__PURE__ */ jsx8(Box6, { marginRight: 2, children: /* @__PURE__ */ jsx8(Text6, { color: C.muted, children: "tab/\u2191\u2193 move \xB7 \u2190/\u2192/space pick" }) }),
       /* @__PURE__ */ jsx8(Button, { k: "ctrl+s", label: "save", color: C.green, onPress: () => void save() }),
       /* @__PURE__ */ jsx8(Button, { k: "esc", label: "cancel", onPress: onClose })
@@ -3391,12 +4001,12 @@ import { Box as Box8, Text as Text8 } from "ink";
 // src/ui/screens/Invites.tsx
 import { useMemo as useMemo5, useRef as useRef4, useState as useState4 } from "react";
 import { Box as Box7, Text as Text7 } from "ink";
-import { addDays as addDays8, startOfDay as startOfDay6 } from "date-fns";
+import { addDays as addDays10, startOfDay as startOfDay6 } from "date-fns";
 import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
 var INVITE_DAYS = 60;
 function useUpcoming(now) {
   const day = startOfDay6(now).getTime();
-  const range = useMemo5(() => ({ start: new Date(day).toISOString(), end: addDays8(day, INVITE_DAYS).toISOString() }), [day]);
+  const range = useMemo5(() => ({ start: new Date(day).toISOString(), end: addDays10(day, INVITE_DAYS).toISOString() }), [day]);
   return useEvents(range);
 }
 var REPLY = { y: "accepted", n: "declined", m: "tentative" };
@@ -3574,12 +4184,12 @@ var NAMES = {
 };
 function useKeyState(init) {
   const ref = useRef5(init);
-  const [, bump] = useState6(0);
+  const [, bump2] = useState6(0);
   return [
     () => ref.current,
     (next) => {
       ref.current = next;
-      bump((n) => n + 1);
+      bump2((n) => n + 1);
     }
   ];
 }
@@ -3996,9 +4606,9 @@ function FirstSyncCheck({ width, height, children }) {
   ] }) });
 }
 function title({ view, date }) {
-  if (view === "month") return format11(date, "MMMM yyyy");
-  if (view === "day") return format11(date, "EEE d MMM yyyy");
-  const days = view === "agenda" ? [date, addDays9(date, AGENDA_DAYS - 1)] : view === "2day" ? [date, addDays9(date, 1)] : viewDays(view, date);
+  if (view === "month") return format13(date, "MMMM yyyy");
+  if (view === "day") return format13(date, "EEE d MMM yyyy");
+  const days = view === "agenda" ? [date, addDays11(date, AGENDA_DAYS - 1)] : view === "2day" ? [date, addDays11(date, 1)] : viewDays(view, date);
   return rangeLabel(days[0], days[days.length - 1]);
 }
 var chronological = (a, b) => eventBounds(a).start.getTime() - eventBounds(b).start.getTime() || Number(b.allDay) - Number(a.allDay);
@@ -4076,8 +4686,8 @@ function Shell({ initialNav, updateCheck, notice }) {
     const { cursor: from, view, date, key: key3 } = live.current;
     const sel = ordered2.find((e) => eventKey(e) === key3);
     const minute = sel ? sel.allDay ? void 0 : Math.max(differenceInMinutes3(eventBounds(sel).start, from), 0) : live.current.minute;
-    const day = addDays9(from, n);
-    const nextDate = onPageOf({ view, date }, day) ? date : view === "2day" && n > 0 ? addDays9(day, -1) : day;
+    const day = addDays11(from, n);
+    const nextDate = onPageOf({ view, date }, day) ? date : view === "2day" && n > 0 ? addDays11(day, -1) : day;
     Object.assign(live.current, { cursor: day, date: nextDate, minute });
     setCursor(day);
     if (+nextDate !== +date) setDate(nextDate);