@acms-subir/core 0.3.46 → 0.3.48

package/src/lib/calendar/schedule.ts

@@ -1,17 +1,19 @@
-// Writes behind the admin Schedule: quick add, drag to move (a whole series
-// or one occurrence), undo, duplicate. Everything goes through the same
+// Writes behind the admin Schedule: quick add, drag to move (a whole series,
+// or one date: a moved date, lib/calendar/moves.ts), undo, duplicate. Everything goes through the same
 // save/apply path as the event editor, so hooks, feeds, search and webhooks
 // see the same changes. A move applies at once, even on a published event —
 // the editor's "stage until Update" flow is for content edits, not dates.
 // Cancelling one date of a series applies at once too, without touching any
 // staged edits.
 import type { ContentRepository } from '../repo/types';
-import type { CalEvent } from '../schema';
+import type { CalEvent, MovedDate } from '../schema';
 import { EventLocation, slugify } from '../schema';
 import { defaultPlaceLocation } from '../maps/places';
 import { ApiError } from '../api';
 import { applyEventUpdate, eventSideEffects, flushEventHooks, saveEvent, type SaveHooks } from '../content-service';
-import { addWallDays, findOccurrence, formatWall, parseWall } from './events';
+import { addWallDays, addWallMinutes, findOccurrence, formatWall, parseWall, wallMinutesBetween } from './events';
+import { moveOccurrence, moveOccurrenceBack, type MoveActor } from './moves';
+import type { BusySlot } from '../booking/holds';
 import { rruleMap, WEEKDAY_CODES, weekdayOf } from './rrule';
 import { waitUntilFrom } from '../webhooks';
 import { kickEmail } from '../email/service';
@@ -91,78 +93,80 @@ export function shiftRrule(rrule: string, days: number, newStart: string): strin
   return Object.entries(p).sort(([a], [b]) => order.indexOf(a) - order.indexOf(b)).map(([k, v]) => `${k}=${v}`).join(';');
 }
 
-const shift = (wall: string, days: number) => {
+// a wall time moved by whole minutes (date-only walls by whole days)
+const shiftBy = (wall: string, minutes: number) => {
   const w = parseWall(wall);
-  return w ? formatWall(addWallDays(w, days)) : wall;
+  return w ? formatWall(addWallMinutes(w, w.dateOnly ? Math.round(minutes / 1440) * 1440 : minutes)) : wall;
+};
+const dayOf = (wall: string) => {
+  const w = parseWall(wall);
+  return w ? { ...w, hh: 0, mm: 0, dateOnly: true } : null;
 };
 
 export type MoveUndo =
-  | { kind: 'series'; id: string; days: number }
+  | { kind: 'series'; id: string; days: number; minutes?: number }
+  // one date moved (previous: where it was moved before, null = not moved)
+  | { kind: 'date'; id: string; key: string; previous: Pick<MovedDate, 'start' | 'end' | 'roomIds' | 'location' | 'note'> | null }
+  // undo tokens from before moved dates: the date was split off into a copy
   | { kind: 'split'; id: string; seriesId: string; occurrence: string };
 
-// Move a whole event (and every repeat) by `days`
-export async function moveSeries(repo: ContentRepository, id: string, days: number, hooks: SaveHooks): Promise<{ event: CalEvent; undo: MoveUndo }> {
+// Move a whole event (and every repeat) by `days`, and `minutes` more (a drag
+// in the week view; all-day events move by whole days only)
+export async function moveSeries(repo: ContentRepository, id: string, days: number, hooks: SaveHooks, minutes = 0): Promise<{ event: CalEvent; undo: MoveUndo }> {
   const e = await repo.getEvent(id);
   if (!e) throw new ApiError(404, 'Event not found.');
-  if (!Number.isInteger(days) || Math.abs(days) > 3660) throw new ApiError(400, 'Pick a day to move it to.');
-  const start = shift(e.start, days);
+  if (!Number.isInteger(days) || Math.abs(days) > 3660 || !Number.isInteger(minutes) || Math.abs(minutes) > 1440 * 7) throw new ApiError(400, 'Pick a day to move it to.');
+  const total = days * 1440 + (e.allDay ? 0 : minutes);
+  const start = shiftBy(e.start, total);
+  // the rule's weekdays follow the start's new day
+  const from = dayOf(e.start), to = dayOf(start);
+  const dayShift = from && to ? Math.round(wallMinutesBetween(from, to) / 1440) : days;
   let event = await saveNow(repo, e, {
-    start, end: shift(e.end, days), allDay: e.allDay,
-    ...(e.rrule ? { rrule: shiftRrule(e.rrule, days, start), exdates: e.exdates.map((x) => shift(x, days)) } : {}),
+    start, end: shiftBy(e.end, total), allDay: e.allDay,
+    ...(e.rrule ? { rrule: shiftRrule(e.rrule, dayShift, start), exdates: e.exdates.map((x) => shiftBy(x, total)) } : {}),
   }, hooks);
-  // cancelled dates move with the series, like skipped ones
-  if (e.rrule && e.cancelledDates.length) {
-    await repo.setEventCancelledDates(id, e.cancelledDates.map((x) => shift(x, days)));
+  // cancelled dates move with the series, like skipped ones; a moved date
+  // keeps its new time and follows under its new key
+  if (e.rrule && (e.cancelledDates.length || Object.keys(e.movedDates).length)) {
+    const moved = Object.fromEntries(Object.entries(e.movedDates).map(([k, m]) => [shiftBy(k, total), m]));
+    await repo.setEventMovedDates(id, moved, e.cancelledDates.map((x) => shiftBy(x, total)));
     await flushEventHooks(repo, hooks);
     event = (await repo.getEvent(id))!;
   }
-  return { event, undo: { kind: 'series', id, days: -days } };
+  return { event, undo: { kind: 'series', id, days: -days, minutes: -minutes } };
 }
 
-// Move one occurrence of a repeating event: skip that date in the series and
-// add a one-off copy on the new date. No schema change, and the copy is a
-// normal event the editor can open. The copy keeps the series' hosts, room
-// hold and translations, and that date's RSVPs move to it (people get the
-// "new time" email).
-export async function moveOccurrence(repo: ContentRepository, id: string, occurrence: string, days: number, hooks: SaveHooks): Promise<{ event: CalEvent; undo: MoveUndo }> {
+// Move one date of a repeating event by `minutes` (a drag on the Schedule):
+// a stored move (lib/calendar/moves.ts) that keeps its key, RSVPs and hosts,
+// and its length. A date already moved moves on from where it is. A one-off
+// event moves as a whole.
+export async function moveDateBy(repo: ContentRepository, actor: MoveActor, id: string, key: string, minutes: number, hooks: SaveHooks): Promise<{ event: CalEvent; undo: MoveUndo; clashes: BusySlot[] }> {
   const e = await repo.getEvent(id);
   if (!e) throw new ApiError(404, 'Event not found.');
-  if (!e.rrule) return moveSeries(repo, id, days, hooks);
-  const occ = parseWall(occurrence);
-  const first = parseWall(e.start);
-  if (!occ || !first) throw new ApiError(400, 'That date isn’t part of this event.');
-  if (e.exdates.includes(occurrence)) throw new ApiError(409, 'That date was already removed from the series.');
-  // keep the occurrence's own length (first occurrence's start → end)
-  const toMs = (w: { y: number; m: number; d: number; hh: number; mm: number }) => Date.UTC(w.y, w.m - 1, w.d, w.hh, w.mm);
-  const lenMs = toMs(parseWall(e.end) ?? first) - toMs(first);
-  const newStart = addWallDays(occ, days);
-  const t = new Date(toMs(newStart) + lenMs);
-  const pad = (n: number) => String(n).padStart(2, '0');
-  const endDay = `${t.getUTCFullYear()}-${pad(t.getUTCMonth() + 1)}-${pad(t.getUTCDate())}`;
-  const endStr = e.allDay ? endDay : `${endDay}T${pad(t.getUTCHours())}:${pad(t.getUTCMinutes())}`;
-
-  const settings = await repo.getSettings();
-  const was = findOccurrence(e, occurrence, settings);
-  await saveNow(repo, e, { exdates: [...e.exdates, occurrence] }, hooks);
-  const copy = await repo.createEvent({
-    title: e.title, slug: await uniqueSlug(repo, e.title), start: formatWall(newStart), end: endStr, allDay: e.allDay,
-    timezone: e.timezone, status: 'draft', excerpt: e.excerpt, bodyJson: e.bodyJson, bodyHtml: e.bodyHtml, cover: e.cover, coverAlt: e.coverAlt,
-    seoTitle: e.seoTitle, seoDesc: e.seoDesc, location: e.location, cta: e.cta, calendarIds: e.calendarIds, fields: e.fields, tags: e.tags,
-    // a cancelled date stays cancelled on its new day
-    cancelled: e.cancelled || e.cancelledDates.includes(occurrence), rsvp: e.rsvp,
-    template: e.template, featured: false, roomHold: e.roomHold, hostIds: e.hostIds, translations: e.translations,
-  });
-  const event = live(e.status) ? await saveEvent(repo, copy.id, { status: 'published' }, hooks) : copy;
-  const now = findOccurrence(event, event.start, settings);
-  if (was && now && await repo.moveOccurrenceRsvps(e.id, was.start, { eventId: event.id, start: now.start, end: now.end })) {
-    await kickEmail(repo, hooks.locals, waitUntilFrom(hooks.locals));
+  if (!e.rrule) {
+    const r = await moveSeries(repo, id, Math.trunc(minutes / 1440), hooks, minutes % 1440);
+    return { ...r, clashes: [] };
   }
-  return { event, undo: { kind: 'split', id: copy.id, seriesId: e.id, occurrence } };
+  if (!Number.isInteger(minutes) || Math.abs(minutes) > 1440 * 3660) throw new ApiError(400, 'Pick a day to move it to.');
+  const prior = e.movedDates[key];
+  const es = parseWall(e.start), ee = parseWall(e.end) ?? es;
+  const k = parseWall(key);
+  if (!k || !es || !ee) throw new ApiError(400, 'That date isn’t part of this event.');
+  const startWall = prior?.start ?? key;
+  const endWall = prior?.end ?? formatWall(addWallMinutes(k, wallMinutesBetween(es, ee)));
+  const r = await moveOccurrence(repo, actor, id, key, { start: shiftBy(startWall, minutes), end: shiftBy(endWall, minutes) }, hooks);
+  const previous = prior ? { start: prior.start, end: prior.end, roomIds: prior.roomIds, location: prior.location, note: prior.note } : null;
+  return { event: r.event, clashes: r.clashes, undo: { kind: 'date', id, key, previous } };
 }
 
-export async function undoMove(repo: ContentRepository, undo: MoveUndo, hooks: SaveHooks): Promise<void> {
+export async function undoMove(repo: ContentRepository, actor: MoveActor, undo: MoveUndo, hooks: SaveHooks): Promise<void> {
   if (undo.kind === 'series') {
-    await moveSeries(repo, undo.id, undo.days, hooks);
+    await moveSeries(repo, undo.id, undo.days, hooks, undo.minutes ?? 0);
+    return;
+  }
+  if (undo.kind === 'date') {
+    if (undo.previous) await moveOccurrence(repo, actor, undo.id, undo.key, { ...undo.previous, roomIds: undo.previous.roomIds ?? [], location: undo.previous.location ?? null }, hooks);
+    else await moveOccurrenceBack(repo, actor, undo.id, undo.key, hooks);
     return;
   }
   let series = await repo.getEvent(undo.seriesId);
@@ -185,21 +189,29 @@ export async function undoMove(repo: ContentRepository, undo: MoveUndo, hooks: S
 // The date stays on the calendar struck through ("Cancelled"), its room holds
 // are released, feeds mark it STATUS:CANCELLED, and its RSVPs are cancelled
 // (each person gets the "cancelled" email; no reminder). Restoring the date
-// leaves those RSVPs cancelled: people sign up again. These do no permission
+// leaves those RSVPs cancelled: people sign up again. Cancelling a moved date
+// cancels it where it was moved to, and drops the move. These do no permission
 // checks: callers (admin actions, site code through @acms-subir/core/server)
 // decide who may do this.
 
 async function setOccurrenceCancelled(repo: ContentRepository, id: string, key: string, cancel: boolean, hooks: SaveHooks, now = Date.now()): Promise<CalEvent> {
   const e = await repo.getEvent(id);
   if (!e) throw new ApiError(404, 'Event not found.');
-  if (!e.rrule) throw new ApiError(400, 'Only a repeating event has single dates to cancel. Cancel the whole event instead.');
+  // error.code as for moves (lib/calendar/moves.ts MoveRefusal)
+  const refuse = (code: string, message: string) => Object.assign(new ApiError(400, message), { code });
+  if (!e.rrule) throw refuse('one-off', 'Only a repeating event has single dates to cancel. Cancel the whole event instead.');
   const settings = await repo.getSettings();
   const o = typeof key === 'string' && key.length <= 20 ? findOccurrence(e, key, settings) : null;
-  if (!o) throw new ApiError(400, 'That date isn’t part of this event.');
-  if (o.start <= now) throw new ApiError(400, 'That date has already started or passed.');
+  if (!o) throw refuse('not-a-date', 'That date isn’t part of this event.');
   const has = e.cancelledDates.includes(key);
-  if (has === cancel) return e; // already so: nothing to change
-  await repo.setEventCancelledDates(id, cancel ? [...e.cancelledDates, key].sort() : e.cancelledDates.filter((x) => x !== key));
+  if (has === cancel) return e; // already so: nothing to change (also once it has started)
+  if (o.start <= now) throw refuse('started', 'That date has already started or passed.');
+  const cancelledDates = cancel ? [...e.cancelledDates, key].sort() : e.cancelledDates.filter((x) => x !== key);
+  // a date is moved or cancelled, never both: cancelling a moved date drops its move (its RSVPs, at the new time, are cancelled below)
+  if (cancel && Object.hasOwn(e.movedDates, key)) {
+    const { [key]: _moved, ...moved } = e.movedDates;
+    await repo.setEventMovedDates(id, moved, cancelledDates);
+  } else await repo.setEventCancelledDates(id, cancelledDates);
   if (cancel && await repo.cancelOccurrenceRsvps(id, o.start)) await kickEmail(repo, hooks.locals, waitUntilFrom(hooks.locals));
   const after = (await repo.getEvent(id))!;
   await eventSideEffects(repo, hooks, after);

package/src/lib/email/booking-words.ts

@@ -79,7 +79,8 @@ const STRINGS: Record<string, BookingStrings> = {
       offered: { subject: 'A spot opened: {title}', heading: 'A spot opened for {title}', intro: 'We’re holding it for you until {until}. Confirm it before then, or it goes to the next person in line.' },
       left: { subject: 'Off the waitlist: {title}', heading: 'You’re off the waitlist', intro: 'You’re no longer on the waitlist for this date.' },
     },
-    manage: 'View or change your booking', rsvp: { manage: 'View or change your booking' },
+    manage: 'View or change your booking',
+    rsvp: { manage: 'View or change your booking' },
     waitlist: { manage: 'See your place or leave the waitlist', confirm: 'Confirm my spot' },
     what: 'What', when: 'When', where: 'Where', seats: 'Seats', reference: 'Reference {ref}', icsManage: 'Manage: {url}',
     lateDecline: 'We weren’t able to confirm this booking in time. Please pick another time.',
@@ -118,6 +119,8 @@ const STRINGS: Record<string, BookingStrings> = {
     manage: 'Ver o cambiar su reservación',
     rsvp: {
       manage: 'Ver o cambiar su confirmación',
+      // one date of the event moved (its RSVPs go with it); staff's note follows
+      rescheduled: { subject: 'Nuevo horario: {title} — {when}', heading: 'Esta fecha cambió', intro: 'Tiene un nuevo horario y su lugar se mantiene. Importe el archivo de calendario adjunto para actualizar su calendario, o cancele con el botón de abajo si no puede asistir.' },
       confirmed: { subject: 'Confirmado: {title} — {when}', heading: 'Ya tiene su lugar', intro: 'Está confirmado. Importe el archivo adjunto para agregarlo a su calendario.' },
       declined: { intro: 'Lo sentimos, el organizador no pudo confirmar su lugar.' },
       cancelled: { subject: 'Cancelado: {title}', heading: 'Confirmación cancelada', intro: 'Esta confirmación se canceló.' },
@@ -163,6 +166,7 @@ const STRINGS: Record<string, BookingStrings> = {
     manage: 'Voir ou modifier votre réservation',
     rsvp: {
       manage: 'Voir ou modifier votre inscription',
+      rescheduled: { subject: 'Nouvel horaire : {title} — {when}', heading: 'Cette date a changé', intro: 'Elle a un nouvel horaire et votre place est conservée. Importez le fichier de calendrier joint pour mettre à jour votre calendrier, ou annulez avec le bouton ci-dessous si vous ne pouvez pas venir.' },
       confirmed: { heading: 'Votre place est réservée' },
       declined: { intro: 'Désolés, l’organisateur n’a pas pu confirmer votre inscription.' },
       cancelled: { heading: 'Inscription annulée', intro: 'Cette inscription a été annulée.' },
@@ -208,6 +212,7 @@ const STRINGS: Record<string, BookingStrings> = {
     manage: 'Buchung ansehen oder ändern',
     rsvp: {
       manage: 'Anmeldung ansehen oder ändern',
+      rescheduled: { subject: 'Neuer Termin: {title} — {when}', heading: 'Dieser Termin wurde verschoben', intro: 'Er hat eine neue Uhrzeit, und Ihr Platz bleibt reserviert. Importieren Sie die angehängte Kalenderdatei, um Ihren Kalender zu aktualisieren, oder sagen Sie über die Schaltfläche unten ab, wenn Sie nicht kommen können.' },
       confirmed: { heading: 'Ihr Platz ist reserviert' },
       declined: { intro: 'Leider konnte der Veranstalter Ihre Anmeldung nicht bestätigen.' },
       cancelled: { heading: 'Anmeldung storniert', intro: 'Diese Anmeldung wurde storniert.' },
@@ -253,6 +258,7 @@ const STRINGS: Record<string, BookingStrings> = {
     manage: 'Ver ou alterar sua reserva',
     rsvp: {
       manage: 'Ver ou alterar sua inscrição',
+      rescheduled: { subject: 'Novo horário: {title} — {when}', heading: 'Esta data mudou', intro: 'Ela tem um novo horário e sua vaga foi mantida. Importe o arquivo de calendário anexo para atualizar seu calendário ou cancele pelo botão abaixo se não puder ir.' },
       confirmed: { heading: 'Sua vaga está reservada' },
       declined: { intro: 'Desculpe, o organizador não pôde confirmar sua inscrição.' },
       cancelled: { heading: 'Inscrição cancelada', intro: 'Esta inscrição foi cancelada.' },

package/src/lib/email/service.ts

@@ -47,9 +47,14 @@ async function render(repo: ContentRepository, job: EmailJob, locals?: unknown,
     return accountMail(payload.purpose, job.recipient, settings.siteTitle, `${origin}/account/${payload.purpose}?token=${encodeURIComponent(raw)}`);
   }
   if (job.kind === 'event-request') {
-    const p = JSON.parse(job.payload) as { eventId: string; kind: 'staff-new' | 'staff-changes' | 'approved' | 'declined'; at: number; reply: string };
+    const p = JSON.parse(job.payload) as { eventId: string; kind: 'staff-new' | 'staff-changes' | 'staff-moved' | 'approved' | 'declined'; at: number; reply: string; by?: string; note?: string; when?: string };
     const e = await repo.getEvent(p.eventId);
     if (!e) return null;
+    // a host moved one date (lib/calendar/moves.ts): the words were fixed when it happened
+    if (p.kind === 'staff-moved') {
+      const by = p.by ? await repo.getUser(p.by) : null;
+      return eventRequestMail('staff-moved', job.recipient, settings.siteTitle, { title: e.title, when: p.when ?? '', by: by?.name ?? '', note: p.note ?? '' }, '', `${origin}/admin/calendar/events/${e.id}`);
+    }
     const staff = p.kind.startsWith('staff');
     // staff hear only about requests still waiting (not withdrawn or already answered)
     if (staff && (e.request?.state !== 'pending' || e.request.at !== p.at)) return null;

package/src/lib/email/templates.ts

@@ -12,11 +12,15 @@ export function accountMail(kind: 'invite'|'reset'|'welcome'|'password-changed'|
   return { to, subject: `${copy[0]} · ${site}`, text: [copy[0], '', copy[1], ...(url ? ['',`${copy[2]}: ${url}`] : [])].join('\n'),
     html: `<!doctype html><html><body style="margin:0;background:#f6f5f2;color:#24211c;font:16px/1.6 system-ui,sans-serif"><div style="max-width:520px;margin:auto;padding:32px 24px"><p style="color:#7d776e">${escape(site)}</p><h1 style="font-size:24px">${escape(copy[0])}</h1><p>${escape(copy[1])}</p>${url ? `<p><a style="display:inline-block;background:#ee5d20;color:#fff;padding:10px 18px;border-radius:8px;text-decoration:none" href="${escape(url)}">${escape(copy[2])}</a></p>` : ''}</div></body></html>` };
 }
-/** members' event requests (lib/calendar/requests.ts): to staff when one arrives, to the member when it's answered */
-export function eventRequestMail(kind: 'staff-new' | 'staff-changes' | 'approved' | 'declined', to: string, site: string, event: { title: string; when: string; by: string; note: string }, reply: string, url: string): Mail {
+/**
+ * members' event requests (lib/calendar/requests.ts): to staff when one arrives, to the member when it's answered;
+ * staff-moved: a host moved one date (lib/calendar/moves.ts), `when` = "old → new"
+ */
+export function eventRequestMail(kind: 'staff-new' | 'staff-changes' | 'staff-moved' | 'approved' | 'declined', to: string, site: string, event: { title: string; when: string; by: string; note: string }, reply: string, url: string): Mail {
   const copy = {
     'staff-new': [`New event request: ${event.title}`, `${event.by || 'A member'} asked for “${event.title}” (${event.when}). It stays a draft until someone approves it.`, 'Review it'],
     'staff-changes': [`Changes to review: ${event.title}`, `${event.by || 'A host'} suggested changes to “${event.title}” (${event.when}). The live event stays as it is until someone approves them.`, 'Review the changes'],
+    'staff-moved': [`Date moved: ${event.title}`, `${event.by || 'A host'} moved one date of “${event.title}”: ${event.when}. People who signed up for it were emailed the new time.`, 'Open the event'],
     approved: [`Approved: ${event.title}`, `Your event “${event.title}” (${event.when}) was approved and is now on the calendar.`, 'See your events'],
     declined: [`Not approved: ${event.title}`, `Your request for “${event.title}” (${event.when}) wasn’t approved.`, 'See your events'],
   }[kind];

package/src/lib/mobile/calendar.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import type { ContentRepository } from '../repo/types';
-import { publicTags, tagFilter, type BookingLink, type CalEvent, type Calendar, type Resource, type Settings } from '../schema';
+import { type BookingLink, type CalEvent, type Calendar, type Resource, type Settings } from '../schema';
 import { ApiError } from '../api';
 import { CALENDAR, bookingsEnabled, resourceUrl, bookingLinkUrl, publicEventFields } from '../calendar/config';
 import { calendarToJson, eventToJson, roomsToJson } from '../calendar/api';
@@ -17,6 +17,7 @@ import { localizeDoc } from '../translations';
 import { localeQuery, mobileLocale, localizedUrl } from './locale';
 import { confirmsInstantly, linkApproval } from '../booking/approval';
 import { changeTopics } from '../push/service';
+import { occurrenceMatches, readEventFilter, resolveEventFilter, tagsMatch } from '../calendar/filter';
 
 export function requireCalendar(bookings = false) {
   if (!CALENDAR.enabled || (bookings && !bookingsEnabled())) throw new ApiError(404, 'This feature is disabled.');
@@ -27,14 +28,24 @@ export async function listCalendars(repo: ContentRepository, url: URL) {
   const origin = siteOrigin(await repo.getSettings(), url);
   return { calendars: (await repo.listCalendars()).filter(c => c.visibility === 'public').map(c => calendarToJson(c, origin)) };
 }
-// tag/excludeTag: a public tag's name or slug (internal "#" tags are never matched, as they are never shown)
-export const eventsQuery = z.object({ ...pageQuery, locale: localeQuery, from: isoDayOrInstant.optional(), to: isoDayOrInstant.optional(), calendar: z.string().min(1).max(200).optional(),
-  tag: z.string().min(1).max(100).optional(), excludeTag: z.string().min(1).max(100).optional(), q: z.string().max(100).optional() }).strict();
+// The website calendar's filters (calendar/filter.ts). Each takes one or more
+// values, comma-separated or repeated. Tags are a public tag's name or slug
+// (internal "#" tags never match, as they are never shown).
+const FILTER_LISTS = ['calendar', 'cal', 'tag', 'excludeTag', 'notag', 'room'] as const;
+const filterList = (what: string) => z.string().min(1).max(2100)
+  .refine((v) => { const parts = v.split(','); return parts.length <= 20 && parts.every((p) => p.trim().length <= 100); }, 'Use up to 20 values of up to 100 characters each.')
+  .optional().describe(`${what} One or more, comma-separated (a,b) or repeated.`);
+export const eventsQuery = z.object({ ...pageQuery, locale: localeQuery, from: isoDayOrInstant.optional(), to: isoDayOrInstant.optional(),
+  calendar: filterList('Only events in these calendars (slugs).'), cal: filterList('Alias of calendar.'),
+  tag: filterList('Only events with one of these tags (a name in any case, or a slug).'), excludeTag: filterList('Leave out events with any of these tags.'), notag: filterList('Alias of excludeTag.'),
+  room: filterList('Only events held in one of these rooms (slugs of rooms shown on public events).'),
+  q: z.string().max(100).optional() }).strict();
 export async function listEvents(repo: ContentRepository, url: URL) {
   requireCalendar();
-  const q = eventsQuery.parse(queryParams(url));
+  const q = eventsQuery.parse(queryParams(url, FILTER_LISTS));
   const locale = mobileLocale(q.locale);
   const term = q.q?.trim() ?? '';
+  const filter = readEventFilter(url.searchParams);
   const [settings, calendars, events, resources, indexed] = await Promise.all([repo.getSettings(), repo.listCalendars(), repo.listPublishedEvents(), roomMap(repo),
     // the search index's matches (body text, word prefixes), so "more" from /search continues here
     term ? repo.searchPublished(term, { limit: 200, collections: [] }).then((r) => new Set(r.events.map(({ doc }) => doc.id))) : null]);
@@ -47,14 +58,18 @@ export async function listEvents(repo: ContentRepository, url: URL) {
   const to = q.to ? at(q.to) : fromDay.length === 10 ? localMidnight(addDaysYmd(fromDay, 30), tz) : from + 30 * 86400000;
   if (to <= from || to - from > 90 * 86400000 + 3600000) throw new ApiError(400, 'Use an event window of 1 to 90 days.');
   const all = new Map(calendars.map(c => [c.id, c]));
-  const cal = q.calendar ? calendars.find(c => c.slug === q.calendar && c.visibility !== 'private') : null;
-  if (q.calendar && !cal) throw new ApiError(404, 'Calendar not found.');
-  const publicCalendars = new Map(calendars.filter(c => c.visibility === 'public' || c.id === cal?.id).map(c => [c.id, c]));
-  const tagged = tagFilter(q.tag, q.excludeTag);
-  const visible = events.map(e => localizeDoc(e, locale ?? undefined)).filter(e => (cal ? e.calendarIds.includes(cal.id) && eventIsPublic(e, all) : eventIsListed(e, all))
-    && tagged(publicTags(e.tags))
+  // private calendars and rooms not shown on public events answer like missing ones
+  const f = resolveEventFilter(filter, { calendars, resources: [...resources.values()] });
+  if (f.calendarIds && f.calendarIds.length < filter.cal.length) throw new ApiError(404, 'Calendar not found.');
+  if (f.roomIds && f.roomIds.length < filter.room.length) throw new ApiError(404, 'Room not found.');
+  const picked = f.calendarIds;
+  const publicCalendars = new Map(calendars.filter(c => c.visibility === 'public' || picked?.includes(c.id)).map(c => [c.id, c]));
+  const visible = events.map(e => localizeDoc(e, locale ?? undefined)).filter(e => (picked ? e.calendarIds.some(id => picked.includes(id)) && eventIsPublic(e, all) : eventIsListed(e, all))
+    && tagsMatch(f, e.tags)
     && (!term || indexed!.has(e.id) || `${e.title} ${e.excerpt} ${e.location.name}`.toLowerCase().includes(term.toLowerCase())));
-  const occurrences = expandEvents(visible, settings, { displayTz: settings.timezone || 'UTC', now: Date.now(), windowStartMs: from, windowEndMs: to });
+  const occurrences = expandEvents(visible, settings, { displayTz: settings.timezone || 'UTC', now: Date.now(), windowStartMs: from, windowEndMs: to })
+    // rooms are per date (a moved date can change them)
+    .filter(o => !f.roomIds || occurrenceMatches(f, o));
   occurrences.sort((a, b) => a.start - b.start || (a.event.id < b.event.id ? -1 : a.event.id > b.event.id ? 1 : 0));
   const start = (q.page - 1) * q.limit;
   const origin = siteOrigin(settings, url);
@@ -91,9 +106,12 @@ export async function getEventDetail(repo: ContentRepository, url: URL, ref: str
 }
 /** every room by id, for naming the public ones (Resource.showOnEvents) */
 export const roomMap = async (repo: ContentRepository) => new Map((await repo.listResources()).map((r) => [r.id, r]));
-// one date: its time, whether it's cancelled, and the public rooms it holds
+// one date: its time, whether it's cancelled, where it moved from, and the public rooms it holds
 export function occurrenceDto(o: Occurrence, resources: Map<string, Resource>) {
-  return { id: `${o.event.id}:${o.start}`, start: new Date(o.start).toISOString(), end: new Date(o.end).toISOString(), allDay: o.allDay, cancelled: o.cancelled,
+  const iso = (n: number) => new Date(n).toISOString();
+  return { id: `${o.event.id}:${o.start}`, start: iso(o.start), end: iso(o.end), allDay: o.allDay, cancelled: o.cancelled,
+    moved: o.moved ? { from: { start: iso(o.moved.from.start), end: iso(o.moved.from.end) }, note: o.moved.note,
+      location: o.moved.location ? { name: o.moved.location.name, address: o.moved.location.address, url: o.moved.location.url } : null } : null,
     rooms: roomsToJson(o.roomIds, resources) };
 }
 // e is already localized; publicCalendars limits which calendars are named

package/src/lib/mobile/http.ts

@@ -43,11 +43,13 @@ export async function limitRequest(repo: ContentRepository, address: string, wri
   const key = `mobile:${write ? 'write' : 'read'}:${await sha256Hex(address)}`;
   if (!await repo.email.rateLimit(key, write ? 20 : 300, 60_000)) throw new ApiError(429, 'Too many requests. Try again in a minute.');
 }
-export function queryParams(url: URL) {
+// lists: parameters that may repeat (tag=a&tag=b); their values are joined
+// with commas, the same as tag=a,b
+export function queryParams(url: URL, lists: readonly string[] = []) {
   const result: Record<string, string> = {};
   for (const [key, value] of url.searchParams) {
-    if (key in result) throw new ApiError(400, `Duplicate query parameter: ${key}.`);
-    result[key] = value;
+    if (key in result && !lists.includes(key)) throw new ApiError(400, `Duplicate query parameter: ${key}.`);
+    result[key] = key in result ? `${result[key]},${value}` : value;
   }
   return result;
 }

package/src/lib/mobile/schemas.ts

@@ -29,24 +29,28 @@ export const Page = ContentSummary.extend({
 });
 // a room an event (or one date) holds, named only when set to show on public events; color null = none
 export const EventRoom = z.object({ slug: str, name: str, color: str.nullable() });
+// one date moved here from `from` (null when it wasn't); location: its own place, null = the event's
+export const OccurrenceMoved = z.object({ from: z.object({ start: date, end: date }), note: str, location: z.object({ name: str, address: str, url: str }).nullable() }).nullable();
 export const Event = CalEvent.pick({
   id: true, slug: true, title: true, excerpt: true, status: true, cancelled: true, featured: true, start: true, end: true,
   allDay: true, timezone: true, rrule: true, exdates: true, cancelledDates: true, location: true, cta: true, tags: true, fields: true,
 }).extend({ rsvp: CalEvent.shape.rsvp.removeDefault().omit({ notifyStaff: true }).default({}).optional(), url: str, icsUrl: str, repeats: str, image: str, imageAlt: str, updatedAt: date,
   calendars: z.array(z.object({ id: str, slug: str, name: str, color: str })),
   rooms: z.array(EventRoom),
+  // single dates at another time, by original occurrence key (wall-clock, like start/end)
+  movedDates: z.record(z.object({ start: str, end: str, note: str })),
   // push topics told about date, time or place changes (Admin → Mobile app → When an event changes); [] = none
   notify: z.object({ changes: strings }),
 });
 export const Events = z.object({ locale, timezone: str, from: date, to: date, pagination: Pagination,
-  occurrences: z.array(z.object({ id: str, start: date, end: date, allDay: bool, cancelled: bool, rooms: z.array(EventRoom), event: Event })),
+  occurrences: z.array(z.object({ id: str, start: date, end: date, allDay: bool, cancelled: bool, moved: OccurrenceMoved, rooms: z.array(EventRoom), event: Event })),
 });
 const Snippet = z.object({ text: str, highlights: z.array(z.object({ start: z.number().int(), end: z.number().int() })) });
 const ContentHit = ContentSummary.extend({ snippet: Snippet });
-export const EventDetail = z.object({ locale, occurrence: z.object({ id: str, start: date, end: date, allDay: bool, cancelled: bool, rooms: z.array(EventRoom) }).nullable(), event: Event });
+export const EventDetail = z.object({ locale, occurrence: z.object({ id: str, start: date, end: date, allDay: bool, cancelled: bool, moved: OccurrenceMoved, rooms: z.array(EventRoom) }).nullable(), event: Event });
 export const SearchResults = z.object({ locale, query: str,
   posts: z.array(ContentHit), pages: z.array(ContentHit),
-  events: z.array(z.object({ snippet: Snippet, occurrence: z.object({ start: date, end: date, allDay: bool, cancelled: bool, rooms: z.array(EventRoom) }).nullable(), event: Event })),
+  events: z.array(z.object({ snippet: Snippet, occurrence: z.object({ start: date, end: date, allDay: bool, cancelled: bool, moved: OccurrenceMoved, rooms: z.array(EventRoom) }).nullable(), event: Event })),
   more: z.object({ posts: bool, pages: bool, events: bool }),
 });
 const Icon = z.object({ type: z.enum(['svg', 'image', 'emoji']), value: str }).nullable();

package/src/lib/push/service.ts

@@ -96,23 +96,30 @@ interface Words {
   // event changes: dates come formatted, `more` ends a list of cancelled dates
   moved: (to: string, was: string) => string; movedTo: (to: string, place: string) => string; place: (p: string) => string;
   cancelled: (d: string) => string; cancelledFrom: (d: string) => string; cancelledOn: (d: string) => string; more: (n: number) => string;
+  // one date of a series moved (CalEvent.movedDates), or several: their new days
+  dateMoved: (to: string, was: string) => string; datesMoved: (d: string) => string;
 }
 const STRINGS: Record<string, Words> = {
   en: { startsIn: (m) => `Starts in ${m} min`, now: 'Starting now', live: 'We’re live',
     moved: (to, was) => `Now ${to} (was ${was})`, movedTo: (to, p) => `Now ${to} · ${p}`, place: (p) => `New place: ${p}`,
-    cancelled: (d) => `Cancelled: ${d}`, cancelledFrom: (d) => `Cancelled: every date from ${d}`, cancelledOn: (d) => `Cancelled on ${d}`, more: (n) => `${n} more` },
+    cancelled: (d) => `Cancelled: ${d}`, cancelledFrom: (d) => `Cancelled: every date from ${d}`, cancelledOn: (d) => `Cancelled on ${d}`, more: (n) => `${n} more`,
+    dateMoved: (to, was) => `Moved to ${to} (was ${was})`, datesMoved: (d) => `New times on ${d}` },
   es: { startsIn: (m) => `Empieza en ${m} min`, now: 'Empieza ahora', live: 'Estamos en vivo',
     moved: (to, was) => `Ahora ${to} (antes ${was})`, movedTo: (to, p) => `Ahora ${to} · ${p}`, place: (p) => `Nuevo lugar: ${p}`,
-    cancelled: (d) => `Cancelado: ${d}`, cancelledFrom: (d) => `Cancelado: todas las fechas desde el ${d}`, cancelledOn: (d) => `Cancelado el ${d}`, more: (n) => `${n} más` },
+    cancelled: (d) => `Cancelado: ${d}`, cancelledFrom: (d) => `Cancelado: todas las fechas desde el ${d}`, cancelledOn: (d) => `Cancelado el ${d}`, more: (n) => `${n} más`,
+    dateMoved: (to, was) => `Se cambia al ${to} (antes ${was})`, datesMoved: (d) => `Nuevo horario el ${d}` },
   fr: { startsIn: (m) => `Commence dans ${m} min`, now: 'Commence maintenant', live: 'Nous sommes en direct',
     moved: (to, was) => `Désormais ${to} (au lieu de ${was})`, movedTo: (to, p) => `Désormais ${to} · ${p}`, place: (p) => `Nouveau lieu : ${p}`,
-    cancelled: (d) => `Annulé : ${d}`, cancelledFrom: (d) => `Annulé : toutes les dates à partir du ${d}`, cancelledOn: (d) => `Annulé le ${d}`, more: (n) => `${n} autres` },
+    cancelled: (d) => `Annulé : ${d}`, cancelledFrom: (d) => `Annulé : toutes les dates à partir du ${d}`, cancelledOn: (d) => `Annulé le ${d}`, more: (n) => `${n} autres`,
+    dateMoved: (to, was) => `Déplacé au ${to} (au lieu de ${was})`, datesMoved: (d) => `Nouveaux horaires le ${d}` },
   de: { startsIn: (m) => `Beginnt in ${m} Min.`, now: 'Beginnt jetzt', live: 'Wir sind live',
     moved: (to, was) => `Jetzt ${to} (statt ${was})`, movedTo: (to, p) => `Jetzt ${to} · ${p}`, place: (p) => `Neuer Ort: ${p}`,
-    cancelled: (d) => `Abgesagt: ${d}`, cancelledFrom: (d) => `Abgesagt: alle Termine ab ${d}`, cancelledOn: (d) => `Abgesagt am ${d}`, more: (n) => `${n} weitere` },
+    cancelled: (d) => `Abgesagt: ${d}`, cancelledFrom: (d) => `Abgesagt: alle Termine ab ${d}`, cancelledOn: (d) => `Abgesagt am ${d}`, more: (n) => `${n} weitere`,
+    dateMoved: (to, was) => `Verschoben auf ${to} (statt ${was})`, datesMoved: (d) => `Neue Zeiten am ${d}` },
   pt: { startsIn: (m) => `Começa em ${m} min`, now: 'Começa agora', live: 'Estamos ao vivo',
     moved: (to, was) => `Agora ${to} (antes ${was})`, movedTo: (to, p) => `Agora ${to} · ${p}`, place: (p) => `Novo local: ${p}`,
-    cancelled: (d) => `Cancelado: ${d}`, cancelledFrom: (d) => `Cancelado: todas as datas a partir de ${d}`, cancelledOn: (d) => `Cancelado em ${d}`, more: (n) => `mais ${n}` },
+    cancelled: (d) => `Cancelado: ${d}`, cancelledFrom: (d) => `Cancelado: todas as datas a partir de ${d}`, cancelledOn: (d) => `Cancelado em ${d}`, more: (n) => `mais ${n}`,
+    dateMoved: (to, was) => `Mudou para ${to} (antes ${was})`, datesMoved: (d) => `Novos horários em ${d}` },
 };
 export const pushStrings = (locale: string) => STRINGS[locale.split('-')[0]] ?? STRINGS.en;
 
@@ -291,7 +298,8 @@ export const CHANGE_SOON = 3 * HOUR;
 /** The public fields a change notice compares (staged edits live in `draft` and don't count until applied). */
 export function eventSnapshot(e: CalEvent): EventSnapshot {
   return { start: e.start, end: e.end, allDay: e.allDay, timezone: e.timezone, rrule: e.rrule, exdates: [...e.exdates].sort(),
-    cancelled: e.cancelled, cancelledDates: [...e.cancelledDates].sort(), location: { name: e.location.name.trim(), address: e.location.address.trim() } };
+    cancelled: e.cancelled, cancelledDates: [...e.cancelledDates].sort(), location: { name: e.location.name.trim(), address: e.location.address.trim() },
+    movedDates: Object.fromEntries(Object.keys(e.movedDates ?? {}).sort().map((k) => [k, { start: e.movedDates[k].start, end: e.movedDates[k].end }])) };
 }
 function readSnapshot(raw: string | null): EventSnapshot | null {
   try { const r = EventSnapshot.safeParse(JSON.parse(raw ?? '')); return r.success ? r.data : null; } catch { return null; }
@@ -307,6 +315,8 @@ export interface EventChange {
   cancelled?: Slot;
   /** single dates of a repeating event newly cancelled, soonest first */
   cancelledDates?: Slot[];
+  /** single dates of a repeating event at a new time (moved, moved again or moved back), by their new time */
+  movedDates?: { from: Slot; to: Slot }[];
   /** when the soonest date it touches starts (a move: the old or the new time, whichever is sooner) */
   at: number;
 }
@@ -331,6 +341,7 @@ export function eventChange(was: EventSnapshot, e: CalEvent, settings: Pick<Sett
   const { upcoming } = slots(e, settings, now);
   if (!upcoming) return null;
   if (e.cancelled) return { cancelled: upcoming, at: upcoming.start };
+  // the series as people knew it, with today's moved dates (those are compared one by one below)
   const then: CalEvent = { ...e, start: was.start, end: was.end, allDay: was.allDay, timezone: was.timezone, rrule: was.rrule, exdates: was.exdates, cancelledDates: was.cancelledDates };
   // a date taken out of the series (dragged to its own event) or put back isn't a move
   const exdates = [...new Set([...was.exdates, ...e.exdates])];
@@ -353,6 +364,16 @@ export function eventChange(was: EventSnapshot, e: CalEvent, settings: Pick<Sett
     out.cancelledDates = dates.map((o) => ({ start: o.start, allDay: o.allDay }));
     starts.push(dates[0].start);
   }
+  // single dates at a new time (a cancelled one is reported above as cancelled)
+  const knew: CalEvent = { ...then, movedDates: Object.fromEntries(Object.entries(was.movedDates).map(([k, m]) => [k, { ...m, note: '', by: '', at: 0 }])) };
+  const moves = [...new Set([...Object.keys(was.movedDates), ...Object.keys(e.movedDates ?? {})])].filter((k) => !e.cancelledDates.includes(k))
+    .map((k) => ({ a: findOccurrence(knew, k, settings), b: findOccurrence(e, k, settings) }))
+    .filter((m): m is { a: Occurrence; b: Occurrence } => m.a !== null && m.b !== null && (m.a.start !== m.b.start || m.a.end !== m.b.end) && m.b.start > now)
+    .sort((x, y) => x.b.start - y.b.start);
+  if (moves.length) {
+    out.movedDates = moves.map(({ a, b }) => ({ from: { start: a.start, allDay: a.allDay }, to: { start: b.start, allDay: b.allDay } }));
+    starts.push(Math.min(...moves.map(({ a, b }) => (a.start > now ? Math.min(a.start, b.start) : b.start))));
+  }
   return starts.length ? { ...out, at: Math.min(...starts) } : null;
 }
 
@@ -396,11 +417,13 @@ export function eventChangeNotice(e: CalEvent, change: EventChange, settings: Se
   // all-day dates start at midnight in the site's zone (how they were expanded)
   const zone = (x: Slot) => (x.allDay ? siteTz : tz);
   const dates = change.cancelledDates ?? [];
-  const kind = change.cancelled ? 'cancelled' : change.moved ? 'moved' : change.place ? 'place' : 'dateCancelled';
-  // one cancelled date opens that date (?on= is its day in the site's zone, like calendar links)
+  const movedDates = change.movedDates ?? [];
+  const kind = change.cancelled ? 'cancelled' : change.moved ? 'moved' : change.place ? 'place' : movedDates.length ? 'dateMoved' : 'dateCancelled';
+  // one cancelled or moved date opens that date (?on= is its day in the site's zone, like calendar links)
   let on = '';
-  if (kind === 'dateCancelled' && dates.length === 1) {
-    const p = tzParts(dates[0].start, siteTz);
+  const one = kind === 'dateCancelled' && dates.length === 1 ? dates[0] : kind === 'dateMoved' && movedDates.length === 1 && !dates.length ? movedDates[0].to : null;
+  if (one) {
+    const p = tzParts(one.start, siteTz);
     on = `?on=${p.y}-${String(p.m).padStart(2, '0')}-${String(p.d).padStart(2, '0')}`;
   }
   const words = (ev: CalEvent, locale: string): Composed => {
@@ -418,6 +441,17 @@ export function eventChangeNotice(e: CalEvent, change: EventChange, settings: Se
         const sameDay = !from.allDay && !to.allDay && day(from) === day(to);
         parts.push(place ? s.movedTo(at(to), place) : s.moved(at(to), sameDay ? when(from.start, false, zone(from), locale, 'time') : at(from)));
       } else if (place) parts.push(s.place(place));
+      if (movedDates.length === 1) {
+        const { from, to } = movedDates[0];
+        const sameDay = !from.allDay && !to.allDay && day(from) === day(to);
+        parts.push(s.dateMoved(at(to), sameDay ? when(from.start, false, zone(from), locale, 'time') : at(from)));
+      } else if (movedDates.length) {
+        const list = movedDates.slice(0, 3).map(({ to }) => when(to.start, true, zone(to), locale, 'monthDay'));
+        if (movedDates.length > 3) list.push(s.more(movedDates.length - 3));
+        let joined: string;
+        try { joined = new Intl.ListFormat(locale, { type: 'conjunction' }).format(list); } catch { joined = list.join(', '); }
+        parts.push(s.datesMoved(joined));
+      }
       if (dates.length) {
         const list = dates.length === 1 ? [day(dates[0])] : dates.slice(0, 3).map((x) => when(x.start, true, zone(x), locale, 'monthDay'));
         if (dates.length > 3) list.push(s.more(dates.length - 3));

package/src/lib/push/types.ts

@@ -38,6 +38,8 @@ export type PushSettings = z.infer<typeof PushSettings>;
 export const EventSnapshot = z.object({
   start: z.string(), end: z.string(), allDay: z.boolean(), timezone: z.string(), rrule: z.string(), exdates: z.array(z.string()),
   cancelled: z.boolean(), cancelledDates: z.array(z.string()), location: z.object({ name: z.string(), address: z.string() }),
+  // single dates at another time (key → new wall times); notices queued before moved dates have none
+  movedDates: z.record(z.object({ start: z.string(), end: z.string() })).default({}),
 });
 export type EventSnapshot = z.infer<typeof EventSnapshot>;
 

package/src/lib/repo/migrations.ts

@@ -5,7 +5,7 @@ import { WEBHOOK_MIGRATION } from '../webhook-sql';
 import { PUSH_MIGRATION } from '../push/migration';
 import { EDITOR_MIGRATION, EDITOR_GRACE_MIGRATION } from '../editor/migration';
 import { CALENDAR_SETTINGS_MIGRATION, ROOM_HOLD_MIGRATION } from '../calendar/migration';
-import { EVENT_CHANGES_MIGRATION } from '../calendar/change-migration';
+import { EVENT_CHANGES_MIGRATION, MOVED_DATES_MIGRATION } from '../calendar/change-migration';
 import { PLACES_MIGRATION } from '../maps/migration';
 import { ROLES_MIGRATION } from '../permissions/migration';
 import { SYNC_MIGRATION } from '../sync/migration';
@@ -724,13 +724,16 @@ export const MIGRATIONS: Migration[] = [
   // every change to a published event, from any write path, queued for its
   // side effects (webhooks, "event changed" pushes, slug redirects)
   EVENT_CHANGES_MIGRATION,
+  // single dates of a series moved (CalEvent.movedDates): a column on the
+  // row, so the triggers on events (content version, event_changes) see a move
+  MOVED_DATES_MIGRATION(contentVersionTriggers('events', [...CONTENT_VERSION_COLUMNS.events, 'cancelled_dates', 'moved_dates'])[2]),
 ];
 
 // Current cache coverage; keep earlier migration inputs frozen for upgrade compatibility.
 export const CURRENT_CONTENT_VERSION_COLUMNS = {
   ...CONTENT_VERSION_COLUMNS,
   settings: [...CONTENT_VERSION_COLUMNS.settings, 'links_verified', 'links_avatar_shape', 'links_avatar_fit', 'links_avatar_scale', 'legal'],
-  events: [...CONTENT_VERSION_COLUMNS.events, 'cancelled_dates'],
+  events: [...CONTENT_VERSION_COLUMNS.events, 'cancelled_dates', 'moved_dates'],
   resources: [...CONTENT_VERSION_COLUMNS.resources, 'color', 'show_on_events'],
   announcements: ANNOUNCEMENT_VISIBLE_COLUMNS,
 };