@acms-subir/core 0.3.57 → 0.3.59

package/src/lib/calendar/google/inbound.ts

@@ -18,20 +18,25 @@
 // - deleted: cancelled on the site (struck through, room freed, restorable,
 //   Q6), or, when the event has another linked copy, just this link's room
 //   and calendar taken off it
-// - "this and following": the new Google series is linked to the same site
-//   event as a later part (kind segment) and listed for staff; C4 ("from this
-//   date on") will apply those later
+// - "this and following": C4's changeFromDate from the date Google split at,
+//   as GOOGLE_SYNC (RSVPs and dates follow; quiet in full reads); the new
+//   Google series is that later part's pair (kind segment). Its later edits
+//   change the part again, its single dates go through C1 like any date, and
+//   deleting it, or a series Google ends sooner, cancels those dates
+//   (cancelFromDate: struck through, restorable, Q6)
 import { EventLocation, RoomHold, type CalEvent } from '../../schema';
 import { eventSideEffects } from '../../content-service';
-import { expandEvents } from '../events';
+import { eventTimeZone, expandEvents, findOccurrence, locationLine, seriesParts, type SeriesPart } from '../events';
 import { rruleMap } from '../rrule';
+import { cancelFromDate, changeFromDate, restoreFromDate } from '../segments';
 import { cancelOccurrence, restoreOccurrence, uniqueSlug } from '../schedule';
 import { GOOGLE_SYNC, moveOccurrence, moveOccurrenceBack } from '../moves';
 import { clashNote, entry, type SyncContext } from './context';
 import { GoogleError } from './client';
 import {
   BOOKING_TAG, NONE, asSiteEvent, changed, dateHash, describe, fieldHash, fieldHashes, fieldWord, googleFields, hiddenLink, inWindow, instanceKey,
-  instanceState, isBooking, keyStart, linkCarries, notAnEvent, paragraphsHtml, sameValue, siteFields, siteUpdate, splitFrom, windowStart, type DateState, type Fields,
+  instanceState, isBooking, keyStart, linkCarries, notAnEvent, paragraphsHtml, sameButEnd, sameValue, siteFields, siteUpdate, splitFrom, splitKey, windowStart, withEndOf,
+  type DateState, type Fields,
 } from './map';
 import type { GcalItem, GcalLink, GoogleEvent, Hashes, NewLogEntry } from './types';
 
@@ -139,7 +144,11 @@ async function handleEvent(ctx: SyncContext, link: GcalLink, g: GoogleEvent, opt
   const item = await ctx.repo.gcal.getItem(link.id, g.id);
   if (g.status === 'cancelled') { if (item && !item.gone) await googleDeleted(ctx, link, item, opts); return; }
   if (item) {
-    if (item.kind === 'segment') return;
+    if (item.kind === 'segment') {
+      if (item.gone) await segmentBack(ctx, link, item, opts);
+      await applySegmentChange(ctx, link, { ...item, gone: false }, g, opts);
+      return;
+    }
     if (item.gone) await backInGoogle(ctx, link, item, opts);
     await applyGoogleChange(ctx, link, { ...item, gone: false }, g, opts);
     return;
@@ -148,9 +157,18 @@ async function handleEvent(ctx: SyncContext, link: GcalLink, g: GoogleEvent, opt
   const base = splitFrom(g.id);
   if (base) {
     const from = await ctx.repo.gcal.getItem(link.id, base);
-    if (from && from.kind !== 'segment') return void await recordSplit(ctx, link, from, g);
+    if (from && from.kind !== 'segment') return void await applySplit(ctx, link, from, g, opts);
   }
   const hidden = g.extendedProperties?.private;
+  if (hidden?.acmsEventId && hidden.acmsSite === ctx.origin && hidden.acmsSegment) {
+    // a later part's own series, copied there by the site: paired again (a resync, a new link)
+    const e = await ctx.repo.getEvent(hidden.acmsEventId);
+    const part = e ? seriesParts(e).find((p) => p.from === hidden.acmsSegment) : undefined;
+    const paired = e && (await ctx.repo.gcal.itemsForEvent(e.id)).some((i) => i.linkId === link.id && i.kind === 'segment' && i.segmentFrom === hidden.acmsSegment);
+    if (e && part && !paired && linkCarries(e, link)) return void await pairSegment(ctx, link, e, part, g);
+    // the site doesn't have that part any more: left as it is rather than made a second event
+    if (e) return;
+  }
   if (hidden?.acmsEventId && hidden.acmsSite === ctx.origin) {
     const e = await ctx.repo.getEvent(hidden.acmsEventId);
     const paired = e && (await ctx.repo.gcal.itemsForEvent(e.id)).some((i) => i.linkId === link.id && i.kind !== 'segment');
@@ -184,6 +202,17 @@ export async function pairExisting(ctx: SyncContext, link: GcalLink, e: CalEvent
   await ctx.repo.gcal.log([entry(link, item, e.title, { direction: 'info', action: 'paired', summary: `Paired with “${g.summary ?? ''}” in ${link.googleName} by ${why}. Both keep their titles until one is edited.` })], ctx.now);
 }
 
+/** A later part's Google series paired as it is (a resync, a new link): both sides' fields become the agreed starting point. */
+async function pairSegment(ctx: SyncContext, link: GcalLink, e: CalEvent, part: SeriesPart, g: GoogleEvent) {
+  const gf = googleFields(g, link, ctx.settings);
+  const item: GcalItem = {
+    linkId: link.id, googleId: g.id, eventId: e.id, icalUid: g.iCalUID ?? '', kind: 'segment', segmentFrom: part.from, etag: g.etag ?? '', htmlLink: g.htmlLink ?? '',
+    site: fieldHashes(siteFields(e, link, ctx.map, part)), google: gf ? fieldHashes(gf) : {}, descGoogle: false, booking: false, gone: false, leftOut: false, conflict: null, syncedAt: ctx.now, createdAt: ctx.now,
+  };
+  await ctx.repo.gcal.putItem(item);
+  await ctx.repo.gcal.log([entry(link, item, e.title, { direction: 'info', action: 'paired', summary: `Paired its dates from ${part.from.replace('T', ' ')} on with their series in ${link.googleName}, by its hidden link.` })], ctx.now);
+}
+
 /** A new Google event: published on the site at once (Q5), in the link's calendar, holding its rooms. */
 async function createSiteEvent(ctx: SyncContext, link: GcalLink, g: GoogleEvent, opts: InboundOptions) {
   const gf = googleFields(g, link, ctx.settings);
@@ -233,17 +262,50 @@ async function backInGoogle(ctx: SyncContext, link: GcalLink, item: GcalItem, op
   await ctx.repo.gcal.log([entry(link, item, e?.title ?? '', { direction: 'in', action: 'restored', summary: `Back in ${link.googleName}: no longer cancelled.` })], ctx.now);
 }
 
-/** True when Google's rule is the site's with an earlier end (an end added or moved sooner): Google dropped dates the site still has. */
-function endsSooner(siteRule: string, googleRule: string): boolean {
-  if (!siteRule || !googleRule) return false;
-  const a = rruleMap(siteRule), b = rruleMap(googleRule);
-  if (!b.UNTIL && !b.COUNT) return false;
-  const rest = (m: Record<string, string>) => JSON.stringify(Object.entries(m).filter(([k]) => k !== 'UNTIL' && k !== 'COUNT').sort());
-  if (rest(a) !== rest(b)) return false;
-  if (!a.UNTIL && !a.COUNT) return true;
-  if (a.COUNT && b.COUNT) return Number(b.COUNT) < Number(a.COUNT);
-  if (a.UNTIL && b.UNTIL) return b.UNTIL.slice(0, 8) < a.UNTIL.slice(0, 8);
-  return true;
+const DAY = 86_400_000;
+/** The site event's first date (any part, moves aside) starting after `ms`, as its key. */
+function firstDateAfter(ctx: SyncContext, e: CalEvent, ms: number): string | null {
+  return expandEvents([{ ...e, movedDates: {} }], ctx.settings, { displayTz: ctx.settings.timezone || 'UTC', now: ms, windowStartMs: ms + 1, windowEndMs: ms + 800 * DAY })
+    .find((o) => o.start > ms)?.key ?? null;
+}
+/** When Google's series has its last date (UTC ms), or null when it goes on. */
+function googleEnd(ctx: SyncContext, gf: Fields): number | null {
+  const parts = rruleMap(gf.repeat.rrule);
+  if (!gf.repeat.rrule || (!parts.UNTIL && !parts.COUNT)) return null;
+  const shape = asSiteEvent(gf, ctx.settings);
+  const dates = expandEvents([shape], ctx.settings, { displayTz: ctx.settings.timezone || 'UTC', now: shape.startAt, windowStartMs: shape.startAt, windowEndMs: shape.startAt + 20 * 366 * DAY });
+  return dates.length ? dates[dates.length - 1].start : shape.startAt;
+}
+/** A place for C4 from Google's: null when it's the event's own. */
+const placeInput = (place: string, e: CalEvent) =>
+  place === locationLine(e.location) ? null : { name: place.slice(0, 300), address: '', placeId: '', lat: null, lng: null, mapImage: '', mapImageDark: '' };
+
+/**
+ * A change to the end of the first part's rule in Google (its other parts
+ * alike). Google ending it where the site's next part takes over is the same
+ * cut ("this and following"): nothing to do. Ending it sooner dropped dates
+ * the site still has: they're cancelled from the first one on
+ * (cancelFromDate, Q6), and Google going on again past a cancelled part
+ * restores it. Returns what it did, or null when it's an ordinary rule change.
+ */
+async function seriesEnd(ctx: SyncContext, link: GcalLink, e: CalEvent, gf: Fields, opts: InboundOptions): Promise<{ words: string } | null> {
+  if (!e.rrule || !sameButEnd(e.rrule, gf.repeat.rrule)) return null;
+  const parts = seriesParts(e);
+  const next = parts[1];
+  const end = googleEnd(ctx, gf);
+  const firstGone = end === null ? null : firstDateAfter(ctx, { ...e, segments: [] }, end);
+  const cut = next ? next.from.slice(0, 10) : null;
+  // Google's dates run to the site's next part: the same series
+  if (cut && firstGone && firstGone.slice(0, 10) >= cut) return { words: '' };
+  if (cut && end === null && next.cancelled) {
+    if (link.direction === 'out') return { words: '' };
+    await restoreFromDate(ctx.repo, GOOGLE_SYNC, e.id, next.from, ctx.hooks, { quiet: opts.quiet, now: ctx.now });
+    return { words: `Google’s series goes on again: the dates from ${next.from.replace('T', ' ')} on are back.` };
+  }
+  if (!firstGone) return null;
+  if (link.direction === 'out') return { words: '' };
+  await cancelFromDate(ctx.repo, GOOGLE_SYNC, e.id, firstGone, ctx.hooks, { quiet: opts.quiet, now: ctx.now });
+  return { words: `Google ended this series sooner: the dates from ${firstGone.replace('T', ' ')} on are cancelled here (restorable).` };
 }
 
 /** The value of one field from Google, for "Use Google's version" later. */
@@ -272,8 +334,8 @@ export async function applyGoogleChange(ctx: SyncContext, link: GcalLink, item:
     return;
   }
   const sf = siteFields(e, link, ctx.map), sh = fieldHashes(sf);
-  const split = (await ctx.repo.gcal.itemsForEvent(e.id)).some((i) => i.linkId === link.id && i.kind === 'segment');
   const google: Hashes = { ...item.google }, site: Hashes = { ...item.site };
+  let reparted = false;
   const notes: NewLogEntry[] = [];
   const apply: string[] = [];
   let conflict = item.conflict, sendBack = false;
@@ -290,13 +352,19 @@ export async function applyGoogleChange(ctx: SyncContext, link: GcalLink, item:
       sendBack = true;
       continue;
     }
-    if (split && (n === 'when' || n === 'repeat')) {
-      notes.push(entry(link, item, e.title, { direction: 'info', action: 'split', summary: `${fieldWord(n)} changed when Google split this series (“this and following”). The site keeps one event as it was for now: change the later dates on the site by hand if needed.` }));
-      continue;
-    }
-    if (n === 'repeat' && endsSooner(sf.repeat.rrule, gf.repeat.rrule)) {
-      notes.push(entry(link, item, e.title, { direction: 'info', action: 'ended', summary: `Google ended this series sooner (${describe(n, gf)}). The site keeps its later dates: end the series or cancel those dates on the site if that’s right.` }));
-      continue;
+    if (n === 'repeat' && !item.booking) {
+      try {
+        const done = await seriesEnd(ctx, link, e, gf, opts);
+        if (done) {
+          reparted = true;
+          if (done.words) notes.push(entry(link, item, e.title, { direction: 'in', action: 'ended', summary: done.words }));
+          continue;
+        }
+      } catch (err) {
+        rethrowGoogle(err);
+        notes.push(entry(link, item, e.title, { direction: 'info', action: 'ended', summary: `Google changed when this series ends (${describe(n, gf)}), but the site couldn’t follow: ${errorText(err)}` }));
+        continue;
+      }
     }
     // a Google → site link mirrors Google; otherwise a field both sides changed keeps the site's value (Q4)
     const siteChanged = (sh[n] ?? '') !== (item.site[n] ?? '');
@@ -311,7 +379,9 @@ export async function applyGoogleChange(ctx: SyncContext, link: GcalLink, item:
     apply.push(n);
   }
   if (apply.length) {
-    const update = siteUpdate(e, gf, apply, { rules: link.rules, descGoogle: item.descGoogle, settings: ctx.settings });
+    // a series changed from a date on keeps its parts: the first part's own rule changes, its end stays where the next takes over
+    const parted = seriesParts(e).length > 1 ? { ...gf, repeat: { ...gf.repeat, rrule: withEndOf(gf.repeat.rrule, e.rrule) } } : gf;
+    const update = siteUpdate(e, parted, apply, { rules: link.rules, descGoogle: item.descGoogle, settings: ctx.settings });
     if (update) {
       const after = await writeSite(ctx, e, update, opts.quiet);
       if (update.tags) await ctx.repo.ensureTags(update.tags);
@@ -329,6 +399,13 @@ export async function applyGoogleChange(ctx: SyncContext, link: GcalLink, item:
       if (conflict && apply.includes(conflict.field)) conflict = null;
     } else for (const n of apply) setHash(site, n, sh[n] ?? '');
   }
+  if (reparted) {
+    // the parts moved (a cut, cancelled or restored dates): the first part's rule and dates as the site has them now
+    const now = fieldHashes(siteFields((await ctx.repo.getEvent(e.id)) ?? e, link, ctx.map));
+    setHash(site, 'repeat', now.repeat);
+    for (const k of Object.keys(site)) if (k.startsWith('date:')) delete site[k];
+    for (const [k, v] of Object.entries(now)) if (k.startsWith('date:')) site[k] = v;
+  }
   await ctx.repo.gcal.patchItem(link.id, item.googleId, { site, google, conflict, etag: g.etag ?? item.etag, htmlLink: g.htmlLink ?? item.htmlLink, kind: gf.repeat.rrule ? 'series' : 'single', syncedAt: ctx.now });
   await ctx.repo.gcal.log(notes, ctx.now);
   if (sendBack) await ctx.repo.gcal.enqueue([e.id], ctx.now);
@@ -337,12 +414,16 @@ export async function applyGoogleChange(ctx: SyncContext, link: GcalLink, item:
 /** Single dates of a series that changed in Google: cancelled, moved, or back to normal. */
 async function handleDates(ctx: SyncContext, link: GcalLink, masterId: string, list: GoogleEvent[], master: GoogleEvent | undefined, opts: InboundOptions) {
   const item = await ctx.repo.gcal.getItem(link.id, masterId);
-  // dates of a later part (Google moved them to the split series), of a booking, or of a series no longer paired
-  if (!item || item.kind === 'segment' || item.booking || item.gone) return;
+  // dates of a booking, or of a series no longer paired
+  if (!item || item.booking || item.gone) return;
   let e = await ctx.repo.getEvent(item.eventId);
   if (!e) return;
+  // a later part's dates (its own Google series): only while the site has that part
+  const partOfItem = (ev: CalEvent) => (item.kind === 'segment' ? seriesParts(ev).find((p) => p.from === item.segmentFrom) : undefined);
+  let part = partOfItem(e);
+  if (item.kind === 'segment' && (!part || part.cancelled)) return;
   const m = master ?? await ctx.client.getEvent(link.googleId, masterId).catch((err) => { if (err instanceof GoogleError && (err.code === 'notfound' || err.code === 'gone')) return null; throw err; });
-  let sf = siteFields(e, link, ctx.map);
+  let sf = siteFields(e, link, ctx.map, part);
   // Google's dates read in the site event's zone, where its date keys are
   const gf = m && m.status !== 'cancelled' ? googleFields(m, link, ctx.settings, sf.when.tz) : null;
   if (!gf || !gf.repeat.rrule) return;
@@ -375,7 +456,8 @@ async function handleDates(ctx: SyncContext, link: GcalLink, masterId: string, l
     try {
       const words = await applyDate(ctx, e, key, state, mine, sf, opts);
       e = (await ctx.repo.getEvent(e.id))!;
-      sf = siteFields(e, link, ctx.map);
+      part = partOfItem(e);
+      sf = siteFields(e, link, ctx.map, part);
       setHash(site, n, dateHash(sf.dates[key] ?? 'none'));
       notes.push(entry(link, item, e.title, { direction: 'in', action: 'date', summary: `${key.replace('T', ' ')}: ${words}` }));
     } catch (err) {
@@ -406,8 +488,17 @@ async function applyDate(ctx: SyncContext, e: CalEvent, key: string, state: Date
 async function googleDeleted(ctx: SyncContext, link: GcalLink, item: GcalItem, opts: InboundOptions) {
   const e = await ctx.repo.getEvent(item.eventId);
   if (item.kind === 'segment') {
-    await ctx.repo.gcal.deleteItem(link.id, item.googleId);
-    await ctx.repo.gcal.log([entry(link, item, e?.title ?? '', { direction: 'info', action: 'split', summary: `Google deleted the later part of this series${item.segmentFrom ? ` (from ${item.segmentFrom.replace('T', ' ')})` : ''}. The site keeps those dates: cancel them on the site if that’s right.` })], ctx.now);
+    const part = e ? seriesParts(e).find((p) => p.from === item.segmentFrom) : undefined;
+    // a split Google had at the first match, never on the site: nothing to cancel
+    if (!e || !part) { await ctx.repo.gcal.deleteItem(link.id, item.googleId); return; }
+    let words = `Google deleted the dates from ${item.segmentFrom.replace('T', ' ')} on: they’re cancelled here (restorable).`;
+    if (!part.cancelled && link.direction !== 'out') {
+      try { await cancelFromDate(ctx.repo, GOOGLE_SYNC, e.id, item.segmentFrom, ctx.hooks, { quiet: opts.quiet, now: ctx.now }); }
+      catch (err) { rethrowGoogle(err); words = `Google deleted the dates from ${item.segmentFrom.replace('T', ' ')} on, but the site couldn’t cancel them: ${errorText(err)}`; }
+    }
+    // kept as the pair: restoring the dates on the site (or in Google) makes the series again
+    await ctx.repo.gcal.patchItem(link.id, item.googleId, { gone: true, leftOut: false, syncedAt: ctx.now });
+    await ctx.repo.gcal.log([entry(link, item, e.title, { direction: 'in', action: 'cancelled', summary: words })], ctx.now);
     return;
   }
   if (!e) { await ctx.repo.gcal.deleteItem(link.id, item.googleId); return; }
@@ -437,23 +528,132 @@ async function googleDeleted(ctx: SyncContext, link: GcalLink, item: GcalItem, o
   await ctx.repo.gcal.log([entry(link, item, e.title, { direction: 'in', action: 'cancelled', summary: `Deleted in ${link.googleName}: cancelled on the site. Restore it there to bring it back in Google.` })], ctx.now);
 }
 
-/** Google split a series ("this and following"): the new series is linked to the same site event as a later part, listed for staff (C4 will apply these). */
-async function recordSplit(ctx: SyncContext, link: GcalLink, base: GcalItem, g: GoogleEvent) {
+/**
+ * Google split a series ("this and following"): the site changes it from
+ * that date on (C4's changeFromDate, as GOOGLE_SYNC), and the new Google
+ * series becomes that later part's pair. The date is the one the split's id
+ * names, else the first date from the new part's first day. At the first
+ * match it's only recorded (both sides as they are, Q18).
+ */
+async function applySplit(ctx: SyncContext, link: GcalLink, base: GcalItem, g: GoogleEvent, opts: InboundOptions) {
   const e = await ctx.repo.getEvent(base.eventId);
   const gf = googleFields(g, link, ctx.settings);
-  // the first date of the site's series from the new part's first day on
+  const tz = e ? eventTimeZone(e, ctx.settings) : '';
+  const inZone = e ? googleFields(g, link, ctx.settings, e.allDay ? undefined : tz) : null;
   let from = '';
-  if (e && gf) {
-    const day = asSiteEvent({ ...gf, when: { ...gf.when, start: gf.when.start.slice(0, 10), end: gf.when.start.slice(0, 10), allDay: true } }, ctx.settings).startAt;
-    from = expandEvents([{ ...e, movedDates: {} }], ctx.settings, { displayTz: ctx.settings.timezone || 'UTC', now: day, windowStartMs: day, windowEndMs: day + 400 * 86_400_000 })
-      .find((o) => o.start >= day)?.key ?? '';
+  if (e && inZone) {
+    const key = splitKey(g.id, { allDay: e.allDay, tz });
+    from = key && findOccurrence({ ...e, movedDates: {} }, key, ctx.settings) ? key : '';
+    if (!from) {
+      const day = asSiteEvent({ ...inZone, when: { ...inZone.when, start: inZone.when.start.slice(0, 10), end: inZone.when.start.slice(0, 10), allDay: true } }, ctx.settings).startAt;
+      from = firstDateAfter(ctx, e, day - 1) ?? '';
+    }
   }
-  await ctx.repo.gcal.putItem({
-    linkId: link.id, googleId: g.id, eventId: base.eventId, icalUid: g.iCalUID ?? '', kind: 'segment', segmentFrom: from, etag: g.etag ?? '', htmlLink: g.htmlLink ?? '',
-    site: {}, google: gf ? fieldHashes(gf) : {}, descGoogle: false, booking: false, gone: false, leftOut: false, conflict: null, syncedAt: ctx.now, createdAt: ctx.now,
+  const record = (site: GcalItem['site'], segmentFrom = from) => ctx.repo.gcal.putItem({
+    linkId: link.id, googleId: g.id, eventId: base.eventId, icalUid: g.iCalUID ?? '', kind: 'segment', segmentFrom, etag: g.etag ?? '', htmlLink: g.htmlLink ?? '',
+    site, google: gf ? fieldHashes(gf) : {}, descGoogle: false, booking: false, gone: false, leftOut: false, conflict: null, syncedAt: ctx.now, createdAt: ctx.now,
   });
-  await ctx.repo.gcal.log([entry(link, base, e?.title ?? g.summary ?? '', { direction: 'info', action: 'split',
-    summary: `Google changed this series from ${from ? from.replace('T', ' ') : 'a later date'} on (“this and following”)${gf ? `: ${describe('when', gf)}, ${describe('repeat', gf)}` : ''}. The site keeps one event as it was for now; change the later dates on the site by hand if needed.` })], ctx.now);
+  const date = from ? from.replace('T', ' ') : 'a later date';
+  const what = gf ? `: ${describe('when', gf)}, ${describe('repeat', gf)}` : '';
+  if (!e || !inZone || !from || opts.adopt?.has(base.googleId) || link.direction === 'out') {
+    await record({});
+    await ctx.repo.gcal.log([entry(link, base, e?.title ?? g.summary ?? '', { direction: 'info', action: 'split',
+      summary: `Google has this series changed from ${date} on (“this and following”)${what}. Both stay as they are until one of them changes.` })], ctx.now);
+    return;
+  }
+  try {
+    const r = await changeFromDate(ctx.repo, GOOGLE_SYNC, e.id, from, { start: inZone.when.start, end: inZone.when.end, rrule: inZone.repeat.rrule, location: placeInput(inZone.place, e) }, ctx.hooks, { quiet: opts.quiet, now: ctx.now });
+    const after = r.event;
+    const part = seriesParts(after).filter((p) => p.from && p.from <= from).pop();
+    await record(part ? fieldHashes(siteFields(after, link, ctx.map, part)) : {}, part?.from ?? from);
+    // the first part's rule now stops there: agreed for the base series too (Google's own cut is the same change)
+    const base2 = await ctx.repo.gcal.getItem(link.id, base.googleId);
+    if (base2) {
+      const now = fieldHashes(siteFields(after, link, ctx.map));
+      const site = { ...base2.site, repeat: now.repeat };
+      for (const k of Object.keys(site)) if (k.startsWith('date:')) delete site[k];
+      for (const [k, v] of Object.entries(now)) if (k.startsWith('date:')) site[k] = v;
+      await ctx.repo.gcal.patchItem(link.id, base.googleId, { site });
+    }
+    const rsvps = r.rsvps.moved || r.rsvps.cancelled ? ` Sign-ups: ${r.rsvps.moved} moved, ${r.rsvps.cancelled} cancelled.` : '';
+    const dropped = r.dropped.length ? ` Dates with no match: ${r.dropped.map((k) => k.replace('T', ' ')).join(', ')}.` : '';
+    await ctx.repo.gcal.log([entry(link, base, after.title, { direction: 'in', action: 'split',
+      summary: `Google changed this series from ${date} on (“this and following”)${what}. ${r.changed ? 'The site changed it from that date on too.' : 'The site already had it so.'}${rsvps}${dropped}` })], ctx.now);
+    const clash = r.clashes.length ? await clashNote(ctx, link, base, after) : null;
+    if (clash) await ctx.repo.gcal.log([clash], ctx.now);
+  } catch (err) {
+    rethrowGoogle(err);
+    await record({});
+    await ctx.repo.gcal.log([entry(link, base, e.title, { direction: 'info', action: 'split',
+      summary: `Google changed this series from ${date} on (“this and following”)${what}, but the site couldn’t follow: ${errorText(err)}` })], ctx.now);
+  }
+}
+
+/**
+ * A later part's own Google series changed: its time, rule or place change
+ * that part on the site (changeFromDate at the same date, replacing it); a
+ * part's own title or description isn't kept (one for the whole series). The
+ * site wins where both changed (Q4).
+ */
+export async function applySegmentChange(ctx: SyncContext, link: GcalLink, item: GcalItem, g: GoogleEvent, opts: InboundOptions = { quiet: false }) {
+  const e = await ctx.repo.getEvent(item.eventId);
+  const gf = googleFields(g, link, ctx.settings);
+  if (!e || !gf) return;
+  const gh = fieldHashes(gf);
+  const chg = changed(masterHashes(gh), masterHashes(item.google));
+  if (!chg.length) {
+    if (g.etag && g.etag !== item.etag) await ctx.repo.gcal.patchItem(link.id, item.googleId, { etag: g.etag, htmlLink: g.htmlLink ?? item.htmlLink });
+    return;
+  }
+  const inZone = googleFields(g, link, ctx.settings, e.allDay ? undefined : eventTimeZone(e, ctx.settings))!;
+  const part = seriesParts(e).find((p) => p.from === item.segmentFrom);
+  const sf = part ? siteFields(e, link, ctx.map, part) : null, sh = sf ? fieldHashes(sf) : {};
+  const google: Hashes = { ...item.google }, site: Hashes = { ...item.site };
+  for (const n of chg) setHash(google, n, gh[n] ?? '');
+  const notes: NewLogEntry[] = [];
+  const date = item.segmentFrom.replace('T', ' ');
+  const own = chg.filter((n) => n === 'title' || n === 'desc' || n.startsWith('rule:'));
+  if (own.length) notes.push(entry(link, item, e.title, { direction: 'info', action: 'split', summary: `The dates from ${date} on have their own ${own.includes('desc') ? 'description' : 'title'} in Google. The site keeps one for the whole series, so that edit stays in Google only.` }));
+  let apply = chg.filter((n) => n === 'when' || n === 'repeat' || n === 'place');
+  let sendBack = false;
+  if (link.direction === 'out') apply = [];
+  else if (part && sf && link.direction !== 'in' && Object.keys(item.site).length) {
+    const both = apply.filter((n) => (sh[n] ?? '') !== (item.site[n] ?? '') && !sameValue(n, sf, inZone, link.rules));
+    if (both.length) {
+      notes.push(entry(link, item, e.title, { direction: 'clash', action: 'split', summary: `From ${date} on, ${both.map((n) => fieldWord(n).toLowerCase()).join(' and ')} changed on both sides: kept the site’s.` }));
+      apply = apply.filter((n) => !both.includes(n));
+      sendBack = true;
+    }
+  }
+  if (apply.length) {
+    try {
+      const r = await changeFromDate(ctx.repo, GOOGLE_SYNC, e.id, item.segmentFrom, { start: inZone.when.start, end: inZone.when.end, rrule: inZone.repeat.rrule, location: placeInput(inZone.place, e) }, ctx.hooks, { quiet: opts.quiet, now: ctx.now });
+      const next = seriesParts(r.event).find((p) => p.from === item.segmentFrom);
+      const sh2 = next ? fieldHashes(siteFields(r.event, link, ctx.map, next)) : {};
+      for (const n of apply) setHash(site, n, sh2[n] ?? '');
+      for (const k of Object.keys(site)) if (k.startsWith('date:')) delete site[k];
+      for (const [k, v] of Object.entries(sh2)) if (k.startsWith('date:')) site[k] = v;
+      if (r.changed) notes.unshift(entry(link, item, r.event.title, { direction: 'in', action: 'updated', summary: `From ${date} on: ${describe('when', inZone)}, ${describe('repeat', inZone)}${inZone.place ? `, at ${inZone.place}` : ''}.` }));
+    } catch (err) {
+      rethrowGoogle(err);
+      notes.push(entry(link, item, e.title, { direction: 'info', action: 'split', summary: `The dates from ${date} on changed in Google, but the site couldn’t follow: ${errorText(err)}` }));
+    }
+  }
+  await ctx.repo.gcal.patchItem(link.id, item.googleId, { site, google, etag: g.etag ?? item.etag, htmlLink: g.htmlLink ?? item.htmlLink, syncedAt: ctx.now });
+  await ctx.repo.gcal.log(notes, ctx.now);
+  if (sendBack) await ctx.repo.gcal.enqueue([e.id], ctx.now);
+}
+
+/** A later part's series Google brought back (its trash): the dates are restored on the site. */
+async function segmentBack(ctx: SyncContext, link: GcalLink, item: GcalItem, opts: InboundOptions) {
+  const e = await ctx.repo.getEvent(item.eventId);
+  const part = e ? seriesParts(e).find((p) => p.from === item.segmentFrom) : undefined;
+  if (e && part?.cancelled && link.direction !== 'out') {
+    try { await restoreFromDate(ctx.repo, GOOGLE_SYNC, e.id, item.segmentFrom, ctx.hooks, { quiet: opts.quiet, now: ctx.now }); }
+    catch (err) { rethrowGoogle(err); }
+  }
+  await ctx.repo.gcal.patchItem(link.id, item.googleId, { gone: false, leftOut: false });
+  await ctx.repo.gcal.log([entry(link, item, e?.title ?? '', { direction: 'in', action: 'restored', summary: `The dates from ${item.segmentFrom.replace('T', ' ')} on are back in ${link.googleName}, and on the site.` })], ctx.now);
 }
 
 /** After a full read: pairs Google didn't list (deleted long ago, or a list that skipped them) are checked one by one. */

package/src/lib/calendar/google/map.ts

@@ -17,7 +17,8 @@
 import { createHash } from 'node:crypto';
 import type { CalEvent, Settings } from '../../schema';
 import { EventLocation, hasTag } from '../../schema';
-import { addWallDays, eventInstants, eventTimeZone, expandEvents, findOccurrence, formatWall, isValidTimeZone, locationLine, normalizeEventTimes, parseWall } from '../events';
+import { addWallDays, cutsAt, eventInstants, eventTimeZone, expandEvents, findOccurrence, formatWall, isValidTimeZone, locationLine, normalizeEventTimes, parseWall, seriesParts, type SeriesPart } from '../events';
+import { ruleUntil } from '../ics-write';
 import { tzParts, zonedToUtc } from '../ics';
 import { cleanRrule, describeRepeat, rruleMap } from '../rrule';
 import type { GcalLink, GoogleEvent, GoogleTime, Hashes, PrefixRule } from './types';
@@ -261,18 +262,30 @@ export function repeatFromGoogle(lines: string[] | undefined, tz: string, allDay
 
 // ---- each side's fields ----
 
-/** The site event's synced fields. A series' changed dates count from the link's start date on. */
-export function siteFields(e: CalEvent, link: Pick<GcalLink, 'rules' | 'startDate'>, ctx: MapContext): SiteFields {
+/**
+ * The site event's synced fields: of its series' first part, or of `part`, a
+ * later one from "from this date on" (CalEvent.segments), which Google keeps
+ * as a series of its own. A part's rule stops where the next one takes over,
+ * as in the site's feeds. A series' changed dates count from the link's start
+ * date on, each with the part it belongs to.
+ */
+export function siteFields(e: CalEvent, link: Pick<GcalLink, 'rules' | 'startDate'>, ctx: MapContext, part?: SeriesPart): SiteFields {
   const tz = eventTimeZone(e, ctx.settings);
-  const when: When = e.allDay ? { allDay: true, start: e.start, end: e.end || e.start, tz: '' } : { allDay: false, start: e.start, end: e.end || e.start, tz };
-  const repeat: Repeat = e.rrule ? { rrule: cleanRrule(e.rrule), exdates: [...new Set(e.exdates)].sort() } : { rrule: '', exdates: [] };
-  const place = locationLine(e.location);
+  const parts = seriesParts(e);
+  const p = part ?? parts[0];
+  const when: When = e.allDay ? { allDay: true, start: p.start, end: p.end || p.start, tz: '' } : { allDay: false, start: p.start, end: p.end || p.start, tz };
+  // the part's own skipped dates: from where it takes over until the next part does
+  const mine = (key: string) => (!p.from || key.slice(0, 10) >= p.from.slice(0, 10)) && !cutsAt(p.until, key);
+  const rule = p.until ? ruleUntil(e, p, ctx.settings.timezone) ?? cleanRrule(p.rrule) : cleanRrule(p.rrule);
+  const repeat: Repeat = e.rrule ? { rrule: rule, exdates: [...new Set(e.exdates)].filter(mine).sort() } : { rrule: '', exdates: [] };
+  const place = locationLine(p.location ?? e.location);
   const dates: Record<string, DateState> = {};
   if (e.rrule) {
     const series = { ...e, movedDates: {} };
-    for (const key of e.cancelledDates) if (key >= link.startDate && findOccurrence(series, key, ctx.settings)) dates[key] = 'cancelled';
+    const inPart = (key: string) => { const o = findOccurrence(series, key, ctx.settings); return !!o && (o.segment ?? '') === p.from; };
+    for (const key of e.cancelledDates) if (key >= link.startDate && inPart(key)) dates[key] = 'cancelled';
     for (const [key, m] of Object.entries(e.movedDates)) {
-      if (key < link.startDate || dates[key] || !findOccurrence(series, key, ctx.settings)) continue;
+      if (key < link.startDate || dates[key] || !inPart(key)) continue;
       dates[key] = { start: m.start, end: m.end, place: m.location ? locationLine(m.location) : place };
     }
   }
@@ -430,6 +443,31 @@ export function isBooking(g: GoogleEvent, link: Pick<GcalLink, 'bookingTitles'>)
 /** A later part made by Google's "this and following" ("<series id>_R<when>"): the series it was split from. */
 export const splitFrom = (googleId: string) => /^(.+)_R\d{8}(?:T\d{6}Z?)?$/.exec(googleId)?.[1] ?? null;
 
+/**
+ * Where a Google split takes over, from its id: "_R" and the original start
+ * of the date it was split at (UTC, as people see Google write it), as the
+ * site's occurrence key in the series' zone; null when the id has no time.
+ */
+export function splitKey(googleId: string, when: Pick<When, 'allDay' | 'tz'>): string | null {
+  const m = /_R(\d{4})(\d{2})(\d{2})(?:T(\d{2})(\d{2})(\d{2})Z?)?$/.exec(googleId);
+  if (!m) return null;
+  if (when.allDay) return `${m[1]}-${m[2]}-${m[3]}`;
+  if (!m[4]) return null;
+  return wallOfMs(Date.UTC(+m[1], +m[2] - 1, +m[3], +m[4], +m[5], +m[6]), when.tz || 'UTC');
+}
+
+/** Two rules alike but for their end (UNTIL or COUNT). */
+export function sameButEnd(a: string, b: string): boolean {
+  const rest = (r: string) => JSON.stringify(Object.entries(rruleMap(r)).filter(([k]) => k !== 'UNTIL' && k !== 'COUNT').sort());
+  return !!a && !!b && rest(a) === rest(b);
+}
+/** A rule without its end, or with another rule's end. */
+export function withEndOf(rule: string, endFrom: string): string {
+  const keep = Object.entries(rruleMap(rule)).filter(([k]) => k !== 'UNTIL' && k !== 'COUNT');
+  const end = Object.entries(rruleMap(endFrom)).filter(([k]) => k === 'UNTIL' || k === 'COUNT');
+  return cleanRrule([...keep, ...end].map(([k, v]) => `${k}=${v}`).join(';'));
+}
+
 // ---- what Google gets ----
 
 /**
@@ -438,23 +476,25 @@ export const splitFrom = (googleId: string) => /^(.+)_R\d{8}(?:T\d{6}Z?)?$/.exec
  * again instead of making a second one. A copy made again after Google
  * deleted the first gets a new id (deleted ids stay taken).
  */
-export function googleIdFor(eventId: string, again = 0): string | undefined {
+export function googleIdFor(eventId: string, again = 0, segment = ''): string | undefined {
   const hex = eventId.toLowerCase().replace(/-/g, '');
   if (!/^[0-9a-f]{32}$/.test(hex)) return undefined;
-  return `acms${hex}${again ? `r${again.toString(32)}` : ''}`;
+  // a later part's copy ("from this date on"): its `from` key, digits only
+  return `acms${hex}${segment ? `s${segment.replace(/\D/g, '')}` : ''}${again ? `r${again.toString(32)}` : ''}`;
 }
 
-export const hiddenLink = (eventId: string, origin: string) => ({ private: { acmsEventId: eventId, acmsSite: origin } });
+/** The hidden link on every Google copy (a later part's also names its `from`), so a re-link or a full resync finds the pairs again. */
+export const hiddenLink = (eventId: string, origin: string, segment = '') => ({ private: { acmsEventId: eventId, acmsSite: origin, ...(segment ? { acmsSegment: segment } : {}) } });
 
-/** A whole new Google event for the site event (description left out while it's Google's). */
-export function googleBody(e: CalEvent, f: SiteFields, link: Pick<GcalLink, 'rules'>, ctx: MapContext, opts: { desc: boolean }): Record<string, unknown> {
+/** A whole new Google event for the site event, or for one later part of its series (description left out while it's Google's). */
+export function googleBody(e: CalEvent, f: SiteFields, link: Pick<GcalLink, 'rules'>, ctx: MapContext, opts: { desc: boolean; segment?: string }): Record<string, unknown> {
   return {
     summary: googleTitle(e, link.rules, ctx.words),
     ...(opts.desc ? { description: googleDescription(f.desc, f.link, ctx.words) } : {}),
     location: f.place,
     ...googleTimes(f.when),
     ...(f.repeat.rrule ? { recurrence: googleRecurrence(f.repeat, f.when) } : {}),
-    extendedProperties: hiddenLink(e.id, ctx.origin),
+    extendedProperties: hiddenLink(e.id, ctx.origin, opts.segment),
   };
 }
 

package/src/lib/calendar/google/match.ts

@@ -16,7 +16,7 @@ import { hasTag } from '../../schema';
 import type { SyncContext } from './context';
 import { processEvents, listChanges, pairExisting } from './inbound';
 import { queueLinkCalendar } from './links';
-import { BOOKING_TAG, asSiteEvent, comparableTitle, googleFields, inWindow, isBooking, linkCarries, notAnEvent, windowStart } from './map';
+import { BOOKING_TAG, asSiteEvent, comparableTitle, googleFields, inWindow, isBooking, linkCarries, notAnEvent, sameButEnd, windowStart } from './map';
 import type { GcalLink, MatchPair, MatchState } from './types';
 
 const REASON_WORDS: Record<MatchPair['reason'], string> = {
@@ -41,7 +41,8 @@ export async function buildMatch(ctx: SyncContext, link: GcalLink): Promise<Matc
     ['hidden-id', 'linked', (e, x) => x.g.extendedProperties?.private?.acmsEventId === e.id && x.g.extendedProperties?.private?.acmsSite === ctx.origin],
     ['uid', 'linked', (e, x) => !!e.sourceUid && e.sourceUid === x.g.iCalUID],
     ['title-time', 'linked', (e, x) => e.startAt === x.shape.startAt && !!e.rrule === !!x.f.repeat.rrule && comparableTitle(e.title, link.rules) === comparableTitle(x.f.title, link.rules)],
-    ['time-repeat', 'suggested', (e, x) => e.startAt === x.shape.startAt && e.allDay === x.f.when.allDay && e.rrule === x.f.repeat.rrule],
+    // a series either side changed from a date on ends sooner: the same series all the same
+    ['time-repeat', 'suggested', (e, x) => e.startAt === x.shape.startAt && e.allDay === x.f.when.allDay && (e.rrule === x.f.repeat.rrule || sameButEnd(e.rrule, x.f.repeat.rrule))],
   ];
   for (const [reason, state, same] of passes) {
     for (const x of google) {