@acms-subir/core 0.3.58 → 0.3.60

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @acms-subir/core
 
+## 0.3.60
+
+### Patch Changes
+
+- 9e2d741: A follow-up for forms on sites in more than one language, and for staff reading time answers.
+
+  - **Times read the way your site writes them.** A time answer, stored as 24-hour `18:30`, now shows the way your site's locale writes times (Settings → Timezone & language): "6:30 PM" for en-US, "6:30 p.m." for es-MX, "18:30" for es-ES. You'll see this in Forms → Responses, the editor app's responses and the staff alert emails. For event registrations, it's in the hosts' "New RSVP" email and the registration's details in Bookings. CSV exports keep the stored `HH:mm`, just as they keep dates as `YYYY-MM-DD`, because spreadsheets sort and format that reliably. Nothing stored changes, and searching Responses still matches the stored text ("18:30").
+  - **Error messages in the visitor's language.** On `/es/forms/<id>`, and in Form blocks on Spanish pages, a missing or invalid answer now gets a Spanish message that names the question by the Spanish label the visitor saw ("Responde “Hora”."). The form's other refusals are in Spanish too: a form that changed, a post that's too large, too many submissions, "reload the form". Event pages word their RSVP form's errors the same way. Apps get these messages in the `locale` they send to `POST /api/v1/forms/{id}/responses` (also the 404 and 410 from `GET /api/v1/forms/{id}`), and for RSVP answers sent to `POST /api/v1/bookings` with a `locale`. Error codes and statuses don't change, so apps that check them keep working. Messages come in English, Spanish, French, German and Portuguese; other languages get English, and pages in the main language read as before.
+  - **Forms stored with their keys in another order take responses again.** Sometimes a form definition is written straight into the database or imported, with its JSON keys in a different order from the one the site uses. Every response to such a form failed with "This form changed. Reload and try again." Responses are now checked against the form by what it asks, not by how its JSON is written, so they go through. A form that's unpublished, archived or really changed between loading and sending still refuses the response.
+
+  There's no migration, and nothing to change after updating.
+
+## 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.60",
   "publishConfig": {
     "access": "public"
   },

package/src/lib/booking/service.ts

@@ -1,4 +1,4 @@
-import { collectResponse, displayAnswers } from '../forms/service';
+import { collectResponse, displayAnswers, staffAnswers } from '../forms/service';
 // Booking workflows shared by the public booking pages, the admin, the REST
 // API and agent tools, so every path validates, notifies and fires webhooks
 // the same way. Auto-confirm links confirm on the spot (and show on the
@@ -158,7 +158,8 @@ export async function bookingMail(repo: ContentRepository, b: Booking, kind: Boo
     position: await waitlistPosition(repo, b), hours: WAITLIST_HOLD / 3_600_000,
     until: b.holdUntil === null ? '' : untilText(b.holdUntil, d.tz, settings),
   } : undefined;
-  return bookingEmail(kind, { booking:b,resource:d.resource,link:d.link,title:d.title,location:d.location,when:d.when,
+  // staff read an RSVP's time answers as the site writes them ("6:30 PM"); Booking.answers keeps them as stored
+  return bookingEmail(kind, { booking:staff ? { ...b, answers: staffAnswers(b, siteLocale(settings)) } : b,resource:d.resource,link:d.link,title:d.title,location:d.location,when:d.when,
     manageUrl:mine ? origin + mine : staff ? adminBookingUrl(origin, b, kind) : origin + bookingManagePath({ manageToken: b.manageToken, locale: language.locale }),
     mineLink: !!mine,
     siteTitle:settings.siteTitle,host:new URL(origin).host,organizer:parseFrom(from)?.email,message:snapshot?.message,

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. */