@acms-subir/core 0.3.58 → 0.3.60

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

package/src/lib/editor/site-data.ts

@@ -3,6 +3,7 @@ import type { Link } from '../schema';
 import { LinksAvatarShape, LinksAvatarFit, LinksAvatarScale, LinkKind } from '../schema';
 import { ApiError } from '../api';
 import { displayAnswers } from '../forms/service';
+import { siteLocale } from '../dates';
 import type { EditorContext } from './http';
 import { isAdmin, requireAdmin } from './roles';
 import { principalCan, requirePrincipal } from '../permissions/access';
@@ -35,13 +36,16 @@ export async function formResponsesFor(c: EditorContext, id: string, q: z.infer<
   await requirePrincipal(c.repo, c.who, 'forms.responses');
   const form = await c.repo.forms.get(id);
   if (!form || form.kind !== 'form') throw new ApiError(404, 'Form not found.');
-  const rows = await c.repo.forms.searchSubmissions(id, { q: q.q, since: q.since ? Date.parse(q.since) : undefined, limit: q.limit + 1, offset: (q.page - 1) * q.limit });
+  const [rows, settings] = await Promise.all([
+    c.repo.forms.searchSubmissions(id, { q: q.q, since: q.since ? Date.parse(q.since) : undefined, limit: q.limit + 1, offset: (q.page - 1) * q.limit }),
+    c.repo.getSettings(),
+  ]);
   return {
     form: { id: form.id, name: form.name },
     items: rows.slice(0, q.limit).map((s) => ({
       id: s.id, createdAt: iso(s.createdAt)!,
-      // labelled answers from the questions as they were when submitted
-      answers: Object.entries(displayAnswers(s.response)).map(([label, value]) => ({ label, value })),
+      // labelled answers from the questions as they were when submitted, times as the site writes them
+      answers: Object.entries(displayAnswers(s.response, siteLocale(settings))).map(([label, value]) => ({ label, value })),
     })),
     pagination: { page: q.page, limit: q.limit, nextPage: rows.length > q.limit ? q.page + 1 : null },
   };

package/src/lib/forms/alert-mail.ts

@@ -2,8 +2,9 @@
 // and its push: in the site's main language, like other staff emails. With
 // the answers, every question in order with its label; without them (forms
 // that ask for sensitive things), only that a response arrived and when, so
-// the email holds nothing about the person. Plain HTML like the staff
-// booking emails, plus a text part. Other languages fall back to English.
+// the email holds nothing about the person. Times read as the site writes
+// them ("6:30 PM" in en-US). Plain HTML like the staff booking emails, plus a
+// text part. Other languages fall back to English.
 import type { ContentRepository } from '../repo/types';
 import type { Settings } from '../schema';
 import type { Mail } from '../email/types';
@@ -12,6 +13,7 @@ import { siteLang, siteLocale } from '../dates';
 import { I18N } from '../i18n';
 import { fill } from '../live/words';
 import { answerFields, type FormField, type FormResponse } from './schema';
+import { timeText } from './service';
 
 /** alerts one form sends in a day (the site's); the last one says so */
 export const ALERTS_PER_DAY = 50;
@@ -64,9 +66,10 @@ function whenText(at: number, locale: string, tz: string, year: boolean) {
 // names can't break the subject line
 const oneLine = (s: string) => s.replace(/\s+/g, ' ').trim();
 
-function shown(f: FormField, value: string | undefined, w: AlertWords) {
+function shown(f: FormField, value: string | undefined, w: AlertWords, locale: string) {
   if (f.type === 'checkbox' || f.type === 'consent') return value === 'yes' ? w.yes : w.no;
   if (f.type === 'checkboxes') return value ? value.split('\n').join(', ') : '—';
+  if (f.type === 'time' && value) return timeText(value, locale);
   return value || '—';
 }
 /** the answer to the first email question, when it's a usable address (else '') */
@@ -94,7 +97,7 @@ export async function formAlertMail(repo: ContentRepository, to: string, p: Aler
   const name = oneLine(form.name);
   const heading = fill(w.subject, { form: name });
   const intro = fill(w.received, { when: whenText(s.createdAt, locale, settings.timezone, true) });
-  const rows: [string, string][] = answers ? answerFields(s.response.definition).map((f) => [f.label, shown(f, s.response.answers[f.id], w)]) : [];
+  const rows: [string, string][] = answers ? answerFields(s.response.definition).map((f) => [f.label, shown(f, s.response.answers[f.id], w, locale)]) : [];
   // replies reach the person only when the email shows their answers
   const replyTo = answers ? replyAddress(s.response) : '';
   const notes = [...(replyTo ? [fill(w.reply, { email: replyTo })] : []), ...(p.last ? [fill(w.last, { max: String(ALERTS_PER_DAY) })] : [])];

package/src/lib/forms/http.ts

@@ -1,29 +1,31 @@
-import { ApiError } from '../api';
 import { sha256Hex } from '../api-keys';
 import type { ContentRepository } from '../repo/types';
 import type { FormDefinition } from './schema';
 import { AnswerError, answersFrom } from './validate';
+import { refuse } from './service';
+// Refusals say why (service.ts refuse): the public form and event pages word
+// them in the visitor's language (formError); admin pages show the English.
 export function checkOrigin(request: Request) {
   const origin = request.headers.get('origin');
-  if ((origin && origin !== new URL(request.url).origin) || request.headers.get('sec-fetch-site') === 'cross-site') throw new ApiError(403, 'Please submit from this site.');
+  if ((origin && origin !== new URL(request.url).origin) || request.headers.get('sec-fetch-site') === 'cross-site') throw refuse(403, 'otherSite');
 }
 export async function readForm(request: Request): Promise<FormData> {
   checkOrigin(request);
   // Read the stream with an actual bound (Content-Length is not trustworthy).
   const reader = request.body?.getReader(); let length = 0; const chunks: Uint8Array[] = [];
-  if (reader) for (;;) { const { value, done } = await reader.read(); if (done) break; length += value.length; if (length > 100_000) { await reader.cancel(); throw new ApiError(413, 'This form is too large.'); } chunks.push(value); }
+  if (reader) for (;;) { const { value, done } = await reader.read(); if (done) break; length += value.length; if (length > 100_000) { await reader.cancel(); throw refuse(413, 'tooLarge'); } chunks.push(value); }
   const bytes = new Uint8Array(length); let at = 0; for (const c of chunks) { bytes.set(c, at); at += c.length; }
   try { return await new Response(bytes, { headers: { 'Content-Type': request.headers.get('content-type') || 'application/x-www-form-urlencoded' } }).formData(); }
-  catch { throw new ApiError(400, 'Could not read this form.'); }
+  catch { throw refuse(400, 'unreadable'); }
 }
 export function readAnswers(data: FormData, definition: FormDefinition) {
   try { return answersFrom(name => data.getAll(name), definition); }
-  catch (e) { if (e instanceof AnswerError) throw new ApiError(400, e.message); throw e; }
+  catch (e) { if (e instanceof AnswerError) throw refuse(400, e.reason, e.field); throw e; }
 }
 export async function submissionGuard(repo: ContentRepository, data: FormData, address: string, scope: string) {
-  if (data.get('website')) throw new ApiError(400, 'Could not submit this form.');
-  if (!await repo.email.rateLimit(`forms:${await sha256Hex(scope + ':' + address)}`, 20, 60_000)) throw new ApiError(429, 'Too many submissions. Please try again in a minute.');
+  if (data.get('website')) throw refuse(400, 'spam');
+  if (!await repo.email.rateLimit(`forms:${await sha256Hex(scope + ':' + address)}`, 20, 60_000)) throw refuse(429, 'tooFast');
   const key = String(data.get('requestId') ?? '');
-  if (!/^[a-f\d]{8}-[a-f\d]{4}-4[a-f\d]{3}-[89ab][a-f\d]{3}-[a-f\d]{12}$/i.test(key)) throw new ApiError(400, 'Reload the form and try again.');
+  if (!/^[a-f\d]{8}-[a-f\d]{4}-4[a-f\d]{3}-[89ab][a-f\d]{3}-[a-f\d]{12}$/i.test(key)) throw refuse(400, 'reload');
   return key;
 }

package/src/lib/forms/schema.ts

@@ -36,8 +36,8 @@ export const FormField = z.object({
   // Checkbox answers are stored newline-joined, so a choice is one line.
   options: z.array(z.string().trim().min(1).max(200).regex(/^[^\r\n]*$/, 'Each choice must be one line.')).max(50).default([]),
   // Newer props are optional (not defaulted) on purpose: parsing must not add
-  // keys to stored definitions, because form versions and the submission
-  // guard compare the exact JSON. Read them through the helpers below.
+  // keys to stored definitions, because form versions hash the exact JSON.
+  // Read them through the helpers below.
   placeholder: z.string().max(120).optional(),
   width: z.enum(['full', 'half']).optional(),
   allowOther: z.boolean().optional(),
@@ -86,6 +86,21 @@ export const SavedForm = z.object({
 export type SavedForm = z.infer<typeof SavedForm>;
 export const FormSubmission = z.object({ id: z.string(), formId: z.string(), response: FormResponse, createdAt: z.number() });
 export type FormSubmission = z.infer<typeof FormSubmission>;
+// JSON with every object's keys in one order (and undefined left out, as
+// JSON.stringify does), so the same data reads the same however it was written
+const sorted = (v: unknown): string => Array.isArray(v) ? `[${v.map((x) => (x === undefined ? 'null' : sorted(x))).join(',')}]`
+  : v && typeof v === 'object' ? `{${Object.keys(v).sort().filter((k) => (v as Record<string, unknown>)[k] !== undefined).map((k) => `${JSON.stringify(k)}:${sorted((v as Record<string, unknown>)[k])}`).join(',')}}`
+  : JSON.stringify(v) ?? 'null';
+const meaning = (schema: z.ZodTypeAny, v: unknown) => { const r = schema.safeParse(v); return sorted(r.success ? r.data : v); };
+/**
+ * Whether two definitions are the same form, by meaning rather than as
+ * written: both parsed (defaults filled in), keys in one order. One stored
+ * straight in the database or imported may order its keys differently from
+ * how the site writes it.
+ */
+export const sameDefinition = (a: unknown, b: unknown) => meaning(FormDefinition, a) === meaning(FormDefinition, b);
+/** The same for two responses (its definition, version and answers). */
+export const sameResponse = (a: unknown, b: unknown) => meaning(FormResponse, a) === meaning(FormResponse, b);
 const field = (id: string, label: string, type: FormField['type'], required = false, options: string[] = []): FormField => ({ id, label, type, required, help: '', options });
 export function starter(key: string): FormDefinition {
   const contact = key === 'contact', interest = key === 'interest';

package/src/lib/forms/service.ts

@@ -1,8 +1,34 @@
 import { ApiError } from '../api';
 import { sha256Hex } from '../api-keys';
-import { FormDefinition, answerFields, type FormResponse } from './schema';
+import type { Booking } from '../schema';
+import { isExtraLocale } from '../translations';
+import { FormDefinition, answerFields, type FormField, type FormResponse } from './schema';
 import { AnswerError, checkAnswer } from './validate';
-import { withoutWords } from './localize';
+import { localizeForm, withoutWords } from './localize';
+import { formErrorText, type FormErrorReason } from './words';
+
+/**
+ * A refusal the person sending a form reads (the web form, an event's RSVP
+ * questions, the app API): why, and the question when it's about one. The
+ * message is the English one; the page or app words it in the person's
+ * language with formError. Not `code`: the app API sends an ApiError's code
+ * as the error code, and these keep theirs (invalid_request, conflict…).
+ */
+export type FormRefusal = ApiError & { refusal: { reason: FormErrorReason; field?: Pick<FormField, 'id' | 'label'> } };
+export const refuse = (status: number, reason: FormErrorReason, field?: Pick<FormField, 'id' | 'label'>, retryAfter?: number): FormRefusal =>
+  Object.assign(new ApiError(status, formErrorText(reason, field?.label), retryAfter), { refusal: { reason, field: field && { id: field.id, label: field.label } } });
+const isRefusal = (e: unknown): e is FormRefusal => e instanceof ApiError && 'refusal' in e;
+/**
+ * A form's refusal in `lang` (the page's language, or the app's ?locale=),
+ * naming the question as `definition` reads in it: the label the person saw.
+ * Same status; anything else comes back as it is.
+ */
+export function formError<E>(e: E, lang: string | null | undefined, definition?: FormDefinition): E | FormRefusal {
+  if (!isRefusal(e)) return e;
+  const { refusal } = e, id = refusal.field?.id;
+  const shown = id && definition ? localizeForm(definition, isExtraLocale(lang) ? lang : '').fields.find((f) => f.id === id) : undefined;
+  return Object.assign(new ApiError(e.status, formErrorText(refusal.reason, shown?.label ?? refusal.field?.label, lang), e.retryAfter), { refusal });
+}
 
 // The version is the questions and their choices in each language, not the
 // other translated words: rewording a label, help or title doesn't change
@@ -15,17 +41,31 @@ export const formVersion = (definition: FormDefinition) => sha256Hex(JSON.string
 export async function collectResponse(definition: FormDefinition, input: Record<string, string>, version?: string): Promise<FormResponse> {
   definition = FormDefinition.parse(definition);
   const current = await formVersion(definition);
-  if (version !== undefined && version !== current) throw new ApiError(409, 'This form has changed. Review the updated questions and submit again.');
+  if (version !== undefined && version !== current) throw refuse(409, 'changed');
   const answers: Record<string, string> = Object.create(null);
-  if (Object.keys(input).length > 30) throw new ApiError(400, 'Too many answers.');
+  if (Object.keys(input).length > 30) throw refuse(400, 'tooManyAnswers');
   for (const f of answerFields(definition)) {
     try { answers[f.id] = checkAnswer(f, input[f.id] ?? ''); }
-    catch (e) { if (e instanceof AnswerError) throw new ApiError(400, e.message); throw e; }
+    catch (e) { if (e instanceof AnswerError) throw refuse(400, e.reason, e.field); throw e; }
   }
   return { version: current, definition, answers };
 }
+/**
+ * A stored time ("18:30") as `locale` writes times: "6:30 PM" in en-US,
+ * "6:30 p.m." in es-MX, "18:30" in es-ES. Without a locale (or for anything
+ * that isn't HH:mm) it stays as it is.
+ */
+export function timeText(value: string, locale?: string | null): string {
+  const m = /^(\d{2}):(\d{2})$/.exec(value);
+  if (!m || !locale) return value;
+  try { return new Intl.DateTimeFormat(locale, { hour: 'numeric', minute: '2-digit', timeZone: 'UTC' }).format(Date.UTC(2000, 0, 1, Number(m[1]), Number(m[2]))); }
+  catch { return value; }
+}
 // Labels are a compatibility view only; snapshots are the authoritative record.
-export function displayAnswers(response: FormResponse): Record<string, string> {
+// locale: staff screens and emails show times as the site writes them
+// (timeText); without one they stay as stored, as RSVPs keep them in
+// Booking.answers. Exports never pass one.
+export function displayAnswers(response: FormResponse, locale?: string): Record<string, string> {
   const out: Record<string, string> = Object.create(null);
   for (const f of answerFields(response.definition)) {
     const v = response.answers[f.id];
@@ -33,10 +73,13 @@ export function displayAnswers(response: FormResponse): Record<string, string> {
     let n = 0;
     while (Object.hasOwn(out, label)) label = `${f.label} (${f.id}${n++ ? `-${n}` : ''})`;
     out[label] = f.type === 'checkbox' || f.type === 'consent' ? v === 'yes' ? 'Yes' : 'No'
-      : f.type === 'checkboxes' ? (v ? v.split('\n').join(', ') : '—') : v || '—';
+      : f.type === 'checkboxes' ? (v ? v.split('\n').join(', ') : '—') : f.type === 'time' && v ? timeText(v, locale) : v || '—';
   }
   return out;
 }
+/** A booking's answers as staff read them: an RSVP form's with times in `locale` (displayAnswers), else the stored ones. */
+export const staffAnswers = (b: Pick<Booking, 'answers' | 'formResponse'>, locale: string) =>
+  b.formResponse ? displayAnswers(b.formResponse, locale) : b.answers;
 export function csv(rows: unknown[][]): string {
   return '\uFEFF' + rows.map(row => row.map(cell => {
     let s = String(cell ?? '');

package/src/lib/forms/store.ts

@@ -1,6 +1,7 @@
 import type { SqlDriver, SqlStatement } from '../repo/sql';
 import { ApiError } from '../api';
-import { FormAlerts, FormDefinition, FormResponse, FormSubmission, SavedForm } from './schema';
+import { FormAlerts, FormDefinition, FormResponse, FormSubmission, SavedForm, sameDefinition, sameResponse } from './schema';
+import { refuse } from './service';
 const row = (r: Record<string, unknown>) => SavedForm.parse({ ...r, definition: JSON.parse(String(r.definition)), draft: r.draft ? JSON.parse(String(r.draft)) : null, createdAt: r.created_at, updatedAt: r.updated_at, alerts: JSON.parse(String(r.alerts || '{}')) });
 const submission = (r: Record<string, unknown>) => FormSubmission.parse({ id: r.id, formId: r.form_id, response: JSON.parse(String(r.response)), createdAt: r.created_at });
 export const formInsert = (f: SavedForm): SqlStatement => ({ sql: 'INSERT INTO forms (id,name,kind,purpose,status,definition,draft,revision,created_at,updated_at,alerts) VALUES (?,?,?,?,?,?,?,?,?,?,?)', args: [f.id,f.name,f.kind,f.purpose,f.status,JSON.stringify(f.definition),f.draft ? JSON.stringify(f.draft) : null,f.revision,f.createdAt,f.updatedAt,JSON.stringify(f.alerts)] });
@@ -36,7 +37,7 @@ export class FormStore {
     const r = (await (await this.driver()).all('SELECT * FROM form_submissions WHERE id=? AND form_id=?', [id, formId]))[0];
     return r ? submission(r) : null;
   }
-  /** the response this request id already saved to this form, if any (as stored JSON) */
+  /** the response this request id already saved to this form, if any (as stored JSON; compare it with sameResponse) */
   async receipt(formId: string, requestId: string) {
     const r = (await (await this.driver()).all('SELECT response FROM form_submissions WHERE id=? AND form_id=?', [requestId, formId]))[0];
     return r ? String(r.response) : null;
@@ -51,11 +52,20 @@ export class FormStore {
     const db = await this.driver();
     // The receipt is also the unique request identity, so retries don't duplicate responses.
     const old = (await db.all('SELECT form_id,response FROM form_submissions WHERE id=?', [requestId]))[0];
-    if (old && (old.form_id !== formId || String(old.response) !== JSON.stringify(response))) throw new ApiError(409, 'This request was already submitted with different answers. Reload to send a new response.');
+    if (old && (old.form_id !== formId || !sameResponse(JSON.parse(String(old.response)), response))) throw refuse(409, 'resent');
     const at = Date.now();
-    if (!old) await db.batch([{ sql: 'INSERT OR IGNORE INTO form_submissions (id,form_id,response,created_at) SELECT ?,?,?,? WHERE EXISTS (SELECT 1 FROM forms WHERE id=? AND status=\'published\' AND kind=\'form\' AND purpose=\'general\' AND definition=?)', args: [requestId,formId,JSON.stringify(response),at,formId,JSON.stringify(response.definition)] }, ...(also?.(at) ?? [])]);
+    if (!old) {
+      // The form must still take responses and be the one they answered,
+      // compared by meaning: a definition written straight into the database
+      // or imported may order its keys differently. The insert then checks
+      // the stored text it just read, so a publish or archive in between
+      // still refuses it (a draft save leaves the live definition alone).
+      const live = (await db.all("SELECT definition FROM forms WHERE id=? AND status='published' AND kind='form' AND purpose='general'", [formId]))[0];
+      if (!live || !sameDefinition(JSON.parse(String(live.definition)), response.definition)) throw refuse(409, 'changedAtSave');
+      await db.batch([{ sql: 'INSERT OR IGNORE INTO form_submissions (id,form_id,response,created_at) SELECT ?,?,?,? WHERE EXISTS (SELECT 1 FROM forms WHERE id=? AND status=\'published\' AND kind=\'form\' AND purpose=\'general\' AND definition=?)', args: [requestId,formId,JSON.stringify(response),at,formId,String(live.definition)] }, ...(also?.(at) ?? [])]);
+    }
     const saved = (await db.all('SELECT form_id,response,created_at FROM form_submissions WHERE id=?', [requestId]))[0];
-    if (!saved || saved.form_id !== formId || String(saved.response) !== JSON.stringify(response)) throw new ApiError(409, 'This form changed. Reload and try again.');
+    if (!saved || saved.form_id !== formId || !sameResponse(JSON.parse(String(saved.response)), response)) throw refuse(409, 'changedAtSave');
     return !old && Number(saved.created_at) === at;
   }
   // Archived → draft (the definition is kept; publishing reopens it).