@acms-subir/core 0.3.58 → 0.3.59

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @acms-subir/core
 
+## 0.3.59
+
+### Patch Changes
+
+- fa476b6: The Google Calendar sync now maps Google's "this and following" to "from this date on" (C4), both ways.
+
+  - A split in Google changes the site event from that date on (`changeFromDate` as `GOOGLE_SYNC`). It stays one event, with the same page, hosts and RSVPs, and sign-ups move to the nearest new date with the "new time" email. The new Google series becomes that later part's pair. Its later time, rule or place edits change the part again, and its single dates are cancelled and moved like any date.
+  - A change from a date on, made on the site, gives the later part its own Google series. The first series gets an UNTIL before that day, as in the site's own feeds. Undo removes the later series again.
+  - Deleting the later series in Google, or ending a series sooner, cancels those dates on the site from the first one on (`cancelFromDate`). They're struck through, their rooms are freed, and they can be restored. Restoring them on either side brings them back on the other.
+  - At the first match, a split Google already has is recorded as it is (Q18). Matching now pairs a Google series that was split with its site twin.
+  - Before this, splits were only listed for staff, and both Google series stayed linked to the one site event. Those pairs carry on: the next change on either side applies the new way.
+
+  No migration. Nothing to do after updating.
+
 ## 0.3.58
 
 ### Patch Changes

package/docs/calendar.md

@@ -440,8 +440,11 @@ calendars in step, both ways, within a few minutes. The full guide is
 - **Booked appointments** from Google booking pages come in as "Booked" with the
   internal tag `#google-booking` (`GOOGLE_BOOKING_TAG`), holding the link's room. Treat
   them as bookings: the tag never shows publicly.
-- **"This and following"** in Google is listed for staff, and the site series stays whole
-  until "from this date on" exists.
+- **"This and following"** maps to "from this date on", both ways:
+  - A Google split changes the event from that date on (`changeFromDate` as `GOOGLE_SYNC`).
+  - A change from a date on gives the later part its own Google series.
+  - Deleting the later series in Google, or ending a series sooner, cancels those dates
+    (`cancelFromDate`), so they stay restorable.
 - Site code can read an event's Google copies with `googleCopies(repo, eventId)`, and
   Recent changes with `googleSyncHistory(repo)`.
 

package/docs/google-calendar.md

@@ -185,12 +185,28 @@ A series is one event with a rule on both sides. Single dates:
   taken room only warns. A date moved on the site moves that Google instance.
 - **Per-date titles or descriptions** from Google aren't applied, because the
   site keeps one title for every date. They're listed under Recent changes.
-- **"This and following"** in Google splits the series in two. Until the site
-  has "from this date on", the new Google series is linked to the same site
-  event as a later part. The split is listed for staff, and the site series
-  stays whole: its time and rule don't change from either side. Likewise, a
-  series Google ends sooner keeps its later dates on the site, listed for
-  staff to end or cancel.
+- **"This and following"** maps to "from this date on", both ways.
+  - **In Google:** a split makes a second Google series. The site changes the
+    same event from that date on (`changeFromDate`, as `GOOGLE_SYNC`), so its
+    page, hosts and RSVPs stay. Sign-ups move to the nearest new date (with the
+    "new time" email). The date is the one Google split at: its id ends in
+    `_R` and that date's original start.
+  - **Pairs:** the new Google series becomes the later part's pair. Its later
+    time, rule or place edits change that part again. Its single dates are
+    cancelled and moved like any date. Its own title or description isn't kept,
+    because the site keeps one for the whole series.
+  - **On the site:** a change from a date on gives the later part its own
+    Google series (its hidden link names the part), and the first series gets
+    an UNTIL before that day, as in the site's feeds. **Undo** removes the
+    later series again.
+  - **Deleting:** deleting the later series in Google, or ending a series
+    sooner, cancels those dates on the site from the first one on
+    (`cancelFromDate`): struck through, rooms freed, restorable (Q6).
+    Restoring them, in Google or on the site, brings them back on the other
+    side. Dates cancelled from a date on, on the site, are removed from
+    Google, like a cancelled date's instance.
+  - **First match:** a split Google already has is recorded as it is. Neither
+    side changes until one of them does (Q18).
 
 ## Clashes
 
@@ -284,9 +300,6 @@ insert, update and delete of `events`) and `gcal_log`.
 
 - **Google push notifications** (`events.watch`) for near-instant updates.
   Reading every 2 minutes is the mechanism.
-- **"This and following"** as a real change on the site, once "from this date
-  on" exists. Until then, splits are listed and both Google series stay linked
-  to the one site event.
 
 ## Troubleshooting
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acms-subir/core",
-  "version": "0.3.58",
+  "version": "0.3.59",
   "publishConfig": {
     "access": "public"
   },

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) {

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

@@ -8,14 +8,22 @@
 // title. Only the fields the sync owns are patched; guests are never added
 // and Google never emails anyone (sendUpdates=none).
 //
+// A series changed "from this date on" (CalEvent.segments) is one Google
+// series per part, as Google does for "this and following": the first part's
+// rule stops where the next takes over, and each later part is its own
+// series (a segment pair, its hidden link naming its `from`). A cancelled
+// part has no Google copy (its dates are removed in Google, like a cancelled
+// date's instance), and a part the site took back is removed from Google.
+//
 // A change that already matches what the pair agreed is never sent, which is
 // what stops loops: the site's write of a change that came from Google leaves
 // nothing to send back to that link (only to the event's other links).
 import { hasTag, type CalEvent } from '../../schema';
+import { seriesParts, type SeriesPart } from '../events';
 import type { SyncContext } from './context';
 import { entry } from './context';
 import { GoogleError } from './client';
-import { applyGoogleChange } from './inbound';
+import { applyGoogleChange, applySegmentChange } from './inbound';
 import {
   BOOKING_TAG, NONE, changed, dateHash, fieldHashes, fieldWord, googleBody, googleFields, googleIdFor, googlePatch, inWindow, instanceBody,
   instanceState, keyStart, linkCarries, originalStart, siteFields, windowStart, type DateState, type Fields,
@@ -96,8 +104,43 @@ async function pushToLink(ctx: SyncContext, link: GcalLink, e: CalEvent | null,
   // deleted from this Google calendar while the event stays in its other copies: it stays out
   if (main.leftOut) return;
   // deleted in Google (and so cancelled here, Q6): made again only once the site brings it back
-  if (main.gone) { if (!e.cancelled) await createCopy(ctx, link, e, main); return; }
-  await updateCopy(ctx, link, e, main, mine.some((i) => i.kind === 'segment'));
+  if (main.gone) { if (!e.cancelled) await createCopy(ctx, link, e, main); }
+  else await updateCopy(ctx, link, e, main);
+  if (e.rrule || mine.some((i) => i.kind === 'segment')) {
+    // as they are now (taking Google's changes may have written the event)
+    const fresh = await ctx.repo.getEvent(e.id);
+    if (fresh) await pushParts(ctx, link, fresh, (await ctx.repo.gcal.itemsForEvent(e.id)).filter((i) => i.linkId === link.id));
+  }
+}
+
+/** The later parts of a series changed from a date on: one Google series each. */
+async function pushParts(ctx: SyncContext, link: GcalLink, e: CalEvent, mine: GcalItem[]) {
+  const parts = e.rrule ? seriesParts(e).slice(1) : [];
+  const segments = mine.filter((i) => i.kind === 'segment');
+  for (const p of parts) {
+    const item = segments.find((i) => i.segmentFrom === p.from);
+    if (p.cancelled) {
+      // its dates are cancelled: removed in Google (kept as the pair, so restoring the part makes it again)
+      if (item && !item.gone) {
+        await ctx.client.deleteEvent(link.googleId, item.googleId);
+        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: 'out', action: 'removed', summary: `Dates from ${p.from.replace('T', ' ')} on cancelled on the site: removed from ${link.googleName}.` })], ctx.now);
+      }
+      continue;
+    }
+    if (!item) await createCopy(ctx, link, e, undefined, p);
+    else if (item.gone) await createCopy(ctx, link, e, item, p);
+    else await updateCopy(ctx, link, e, item, p);
+  }
+  for (const item of segments) {
+    if (parts.some((p) => p.from === item.segmentFrom)) continue;
+    // a split Google had at the first match, never on the site: Google keeps it as it is
+    if (!Object.keys(item.site).length) continue;
+    // the site took that change back ("Undo"): its Google series goes
+    if (!item.gone) await ctx.client.deleteEvent(link.googleId, item.googleId);
+    await ctx.repo.gcal.deleteItem(link.id, item.googleId);
+    await ctx.repo.gcal.log([entry(link, item, e.title, { direction: 'out', action: 'removed', summary: `The change from ${item.segmentFrom.replace('T', ' ')} on was undone on the site: its series was removed from ${link.googleName}.` })], ctx.now);
+  }
 }
 
 /** Google won't let the account change this event there: listed once, and the site's change counts as seen (no retries). */
@@ -115,7 +158,7 @@ async function unpair(ctx: SyncContext, link: GcalLink, item: GcalItem, e: CalEv
 }
 
 async function removeCopy(ctx: SyncContext, link: GcalLink, item: GcalItem, all: GcalItem[], e: CalEvent | null) {
-  // the event's later parts from a Google split go with it
+  // the event's later parts (their own Google series) go with it
   for (const i of all) {
     if (!i.gone) await ctx.client.deleteEvent(link.googleId, i.googleId);
     await ctx.repo.gcal.deleteItem(link.id, i.googleId);
@@ -151,18 +194,19 @@ function written(patch: Record<string, unknown>, rules: GcalLink['rules']): stri
 }
 const masterHashes = (h: Hashes) => Object.fromEntries(Object.entries(h).filter(([k]) => !k.startsWith('date:')));
 
-/** A new Google copy (or a new one after Google deleted the old: `previous`), with the series' changed dates. */
-export async function createCopy(ctx: SyncContext, link: GcalLink, e: CalEvent, previous?: GcalItem) {
-  const f = siteFields(e, link, ctx.map);
-  const body = googleBody(e, f, link, ctx.map, { desc: true });
-  const id = googleIdFor(e.id, previous ? Math.floor(ctx.now / 1000) : 0);
+/** A new Google copy (or a new one after Google deleted the old: `previous`), with the series' changed dates; `part`: a later part's own series. */
+export async function createCopy(ctx: SyncContext, link: GcalLink, e: CalEvent, previous?: GcalItem, part?: SeriesPart) {
+  const f = siteFields(e, link, ctx.map, part);
+  const segment = part?.from ?? '';
+  const body = googleBody(e, f, link, ctx.map, { desc: true, segment });
+  const id = googleIdFor(e.id, previous ? Math.floor(ctx.now / 1000) : 0, segment);
   let g: GoogleEvent;
   try { g = await ctx.client.insertEvent(link.googleId, id ? { id, ...body } : body); }
   catch (err) {
     if (!(err instanceof GoogleError && err.code === 'conflict' && id)) throw err;
     // that id is taken: our own copy from a run that stopped before saving the pair, or one Google deleted (ids stay taken)
     const found = await ctx.client.getEvent(link.googleId, id).catch(() => null);
-    g = found && found.status !== 'cancelled' && found.extendedProperties?.private?.acmsEventId === e.id
+    g = found && found.status !== 'cancelled' && found.extendedProperties?.private?.acmsEventId === e.id && (found.extendedProperties.private.acmsSegment ?? '') === segment
       ? await ctx.client.patchEvent(link.googleId, id, body)
       : await ctx.client.insertEvent(link.googleId, body);
   }
@@ -177,12 +221,13 @@ export async function createCopy(ctx: SyncContext, link: GcalLink, e: CalEvent,
     else google[`date:${key}`] = dateHash(after);
   }
   const item: GcalItem = {
-    linkId: link.id, googleId: g.id, eventId: e.id, icalUid: g.iCalUID ?? '', kind: e.rrule ? 'series' : 'single', segmentFrom: '', etag: g.etag ?? '', htmlLink: g.htmlLink ?? '',
+    linkId: link.id, googleId: g.id, eventId: e.id, icalUid: g.iCalUID ?? '', kind: segment ? 'segment' : e.rrule ? 'series' : 'single', segmentFrom: segment, etag: g.etag ?? '', htmlLink: g.htmlLink ?? '',
     site: fieldHashes(f), google, descGoogle: false, booking: false, gone: false, leftOut: false, conflict: null, syncedAt: ctx.now, createdAt: previous?.createdAt ?? ctx.now,
   };
   if (previous) await ctx.repo.gcal.replaceItem(previous.googleId, item); else await ctx.repo.gcal.putItem(item);
   await ctx.repo.gcal.log([entry(link, item, e.title, { direction: 'out', action: 'created',
-    summary: previous ? `Back on the site: made again in ${link.googleName}.` : `Copied to ${link.googleName}${e.cancelled ? ' as cancelled' : ''}.` }), ...notes], ctx.now);
+    summary: segment ? `From ${segment.replace('T', ' ')} on, a series of its own in ${link.googleName} (“this and following”).`
+      : previous ? `Back on the site: made again in ${link.googleName}.` : `Copied to ${link.googleName}${e.cancelled ? ' as cancelled' : ''}.` }), ...notes], ctx.now);
 }
 
 /** Sets one date of the Google series; returns its state there afterwards (null: Google has no such date). */
@@ -207,9 +252,11 @@ async function writeDate(ctx: SyncContext, link: GcalLink, masterId: string, key
   }
 }
 
-/** Sends the site's changes since the pair last agreed (Google's own changes are taken first, field by field). */
-async function updateCopy(ctx: SyncContext, link: GcalLink, e: CalEvent, item: GcalItem, split: boolean) {
-  let f = siteFields(e, link, ctx.map);
+/** Sends the site's changes since the pair last agreed (Google's own changes are taken first, field by field); `part`: a later part's series. */
+async function updateCopy(ctx: SyncContext, link: GcalLink, e: CalEvent, item: GcalItem, part?: SeriesPart) {
+  const partFrom = part?.from;
+  const partNow = (ev: CalEvent) => (partFrom === undefined ? undefined : seriesParts(ev).find((p) => p.from === partFrom));
+  let f = siteFields(e, link, ctx.map, part);
   if (!pendingSite(fieldHashes(f), item, link, {}).ch.length) return;
   let g: GoogleEvent | null = await ctx.client.getEvent(link.googleId, item.googleId).catch((err) => {
     if (err instanceof GoogleError && (err.code === 'notfound' || err.code === 'gone')) return null;
@@ -223,10 +270,12 @@ async function updateCopy(ctx: SyncContext, link: GcalLink, e: CalEvent, item: G
   let gf = googleFields(g, link, ctx.settings);
   // Google changed fields too: take those first (the site wins where both changed, Q4), then send what's left
   if (link.direction === 'both' && gf && changed(masterHashes(fieldHashes(gf)), masterHashes(item.google)).length) {
-    await applyGoogleChange(ctx, link, item, g);
+    await (part ? applySegmentChange(ctx, link, item, g) : applyGoogleChange(ctx, link, item, g));
     const [again, fresh] = await Promise.all([ctx.repo.gcal.getItem(link.id, item.googleId), ctx.repo.getEvent(e.id)]);
     if (!again || !fresh || again.gone) return;
-    item = again; e = fresh; f = siteFields(e, link, ctx.map);
+    item = again; e = fresh;
+    if (part) { part = partNow(e); if (!part || part.cancelled) return; }
+    f = siteFields(e, link, ctx.map, part);
   }
   const cur = fieldHashes(f);
   const pending = pendingSite(cur, item, link, gf ? fieldHashes(gf) : {});
@@ -239,10 +288,7 @@ async function updateCopy(ctx: SyncContext, link: GcalLink, e: CalEvent, item: G
     descGoogle = false;
     notes.push(entry(link, item, e.title, { direction: 'info', action: 'description', summary: 'Description edited on the site: from now on Google gets the site’s text (Q8).' }));
   }
-  // a series Google split ("this and following") keeps its time and rule until the site has "from this date on"
-  const held: string[] = split ? ch.filter((n) => n === 'when' || n === 'repeat') : [];
-  if (held.length) notes.push(entry(link, item, e.title, { direction: 'info', action: 'split', summary: `${held.map(fieldWord).join(' and ')} changed on the site, but Google split this series (“this and following”), so ${held.length > 1 ? 'they weren’t' : 'it wasn’t'} sent. Change the later part in Google, or both by hand.` }));
-  const fields = ch.filter((n) => !n.startsWith('date:') && !held.includes(n) && !((n === 'desc' || n === 'link') && descGoogle));
+  const fields = ch.filter((n) => !n.startsWith('date:') && !((n === 'desc' || n === 'link') && descGoogle));
   const patch = fields.length ? googlePatch(e, f, link, ctx.map, fields, { desc: !descGoogle, googleSummary: g.summary ?? '' }) : {};
   if (Object.keys(patch).length) g = await ctx.client.patchEvent(link.googleId, item.googleId, patch);
   gf = googleFields(g, link, ctx.settings) ?? gf;
@@ -252,7 +298,7 @@ async function updateCopy(ctx: SyncContext, link: GcalLink, e: CalEvent, item: G
 
   // single dates, once the series itself is right (read in the site event's zone, where its keys are)
   const inSiteZone = googleFields(g, link, ctx.settings, f.when.tz);
-  if (!split && inSiteZone) for (const n of ch.filter((x) => x.startsWith('date:'))) {
+  if (inSiteZone) for (const n of ch.filter((x) => x.startsWith('date:'))) {
     const key = n.slice(5);
     if (keyStart(key, f.when, ctx.settings) <= ctx.now) continue;
     const want = f.dates[key] ?? 'none';
@@ -265,8 +311,8 @@ async function updateCopy(ctx: SyncContext, link: GcalLink, e: CalEvent, item: G
   for (const n of ch) { if (cur[n] === undefined) delete site[n]; else site[n] = cur[n]; }
   // the clash note stays until the site edits that field again (sending the site's winning value isn't an edit)
   const conflict = !item.conflict || !ch.includes(item.conflict.field) ? item.conflict : item.conflict.sent ? null : { ...item.conflict, sent: true };
-  await ctx.repo.gcal.patchItem(link.id, item.googleId, { site, google, descGoogle, conflict, etag: g.etag ?? item.etag, htmlLink: g.htmlLink ?? item.htmlLink, kind: e.rrule ? 'series' : 'single', syncedAt: ctx.now });
-  const sent = [...new Set(ch.filter((n) => !held.includes(n)).map((n) => n.startsWith('date:') ? 'dates' : n.startsWith('rule:') ? 'title' : n === 'status' ? (e.cancelled ? 'cancelled' : 'restored') : n === 'link' ? 'desc' : n))];
-  if (sent.length) notes.unshift(entry(link, item, e.title, { direction: 'out', action: 'updated', summary: `${sent.map((n) => n === 'dates' ? 'Single dates' : n === 'cancelled' ? 'Cancelled' : n === 'restored' ? 'No longer cancelled' : fieldWord(n)).join(', ')} → ${link.googleName}` }));
+  await ctx.repo.gcal.patchItem(link.id, item.googleId, { site, google, descGoogle, conflict, etag: g.etag ?? item.etag, htmlLink: g.htmlLink ?? item.htmlLink, kind: part ? 'segment' : e.rrule ? 'series' : 'single', syncedAt: ctx.now });
+  const sent = [...new Set(ch.map((n) => n.startsWith('date:') ? 'dates' : n.startsWith('rule:') ? 'title' : n === 'status' ? (e.cancelled ? 'cancelled' : 'restored') : n === 'link' ? 'desc' : n))];
+  if (sent.length) notes.unshift(entry(link, item, e.title, { direction: 'out', action: 'updated', summary: `${sent.map((n) => n === 'dates' ? 'Single dates' : n === 'cancelled' ? 'Cancelled' : n === 'restored' ? 'No longer cancelled' : fieldWord(n)).join(', ')}${part ? ` (from ${part.from.replace('T', ' ')} on)` : ''} → ${link.googleName}` }));
   await ctx.repo.gcal.log(notes, ctx.now);
 }

package/src/lib/calendar/ics-write.ts

@@ -93,8 +93,9 @@ export function eventToVevent(e: CalEvent, siteTz: string, opts: FeedOptions): s
 // A part's rule for the feed: stopped just before the next part's `from`
 // (RFC 5545 UNTIL is inclusive: the instant before it for timed events, the
 // day before for all-day ones). COUNT becomes that UNTIL when the rule would
-// still have dates there; null when the part has none left before it.
-function ruleUntil(e: CalEvent, p: SeriesPart, siteTz: string): string | null {
+// still have dates there; null when the part has none left before it. The
+// Google Calendar sync gives each part's Google series the same rule.
+export function ruleUntil(e: CalEvent, p: SeriesPart, siteTz: string): string | null {
   const clean = cleanRrule(p.rrule);
   if (!p.until || !clean) return clean;
   const cut = parseWall(p.until);