@acms-subir/core 0.3.46 → 0.3.48

package/src/lib/repo/sql.ts

@@ -13,7 +13,7 @@ import { LiveConfig } from '../live/types';
 import { ApiError } from '../api';
 import { EmailStore, bookingJobs, rsvpStaffJobs } from '../email/store';
 import type { ContentRepository, DesignVersion, EventUpdate, ImportRecord, ImportRecordKind, ImportRun, SearchResults, Stats } from './types';
-import { DocTranslations, Page, Post, Link, Media, NavItem, Redirect, Settings, Snippet, Tag, User, Calendar, CalEvent, ApiKey, Webhook, WebhookDelivery, Resource, BookingLink, Booking, Place, EventLocation, EventRequest, isInternalTag, roomColor, normalizeRedirectPath, publicTags, slugify, type WidgetInstance } from '../schema';
+import { DocTranslations, Page, Post, Link, Media, NavItem, Redirect, Settings, Snippet, Tag, User, Calendar, CalEvent, ApiKey, Webhook, WebhookDelivery, Resource, BookingLink, Booking, Place, EventLocation, EventRequest, MovedDate, isInternalTag, roomColor, normalizeRedirectPath, publicTags, slugify, type WidgetInstance } from '../schema';
 import { designSnapshot, draftNavItems, pickDesignDraft, pickEventDraft, pickPageDraft, pickPostDraft } from '../drafts';
 import { eventInstants, eventTimeZone, normalizeEventTimes } from '../calendar/events';
 import { cleanRrule } from '../calendar/rrule';
@@ -148,6 +148,15 @@ function parseRequest(raw: unknown): EventRequest | null {
   if (raw === null || raw === undefined || raw === '') return null;
   try { const r = EventRequest.safeParse(JSON.parse(String(raw))); return r.success ? r.data : null; } catch { return null; }
 }
+// a corrupt moved-dates map, or one bad entry, reads as "not moved" rather than breaking the event
+function parseMovedDates(raw: unknown): CalEvent['movedDates'] {
+  let value: unknown;
+  try { value = JSON.parse(String(raw ?? '{}')); } catch { return {}; }
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
+  const out: CalEvent['movedDates'] = {};
+  for (const [key, entry] of Object.entries(value)) { const m = MovedDate.safeParse(entry); if (m.success) out[key] = m.data; }
+  return out;
+}
 function rowToEvent(r: Row): CalEvent {
   return CalEvent.parse({
     id: r.id, slug: r.slug, title: r.title, bodyJson: r.body_json ?? '', bodyHtml: r.body_html ?? '',
@@ -155,7 +164,7 @@ function rowToEvent(r: Row): CalEvent {
     seoTitle: r.seo_title ?? '', seoDesc: r.seo_desc ?? '', status: r.status,
     featured: Boolean(r.featured), tags: json(r.tags, []), template: r.template ?? '',
     start: r.starts, end: r.ends ?? '', allDay: Boolean(r.all_day), timezone: r.timezone ?? '',
-    rrule: r.rrule ?? '', exdates: json(r.exdates, []), cancelled: Boolean(r.cancelled), cancelledDates: json(r.cancelled_dates, []),
+    rrule: r.rrule ?? '', exdates: json(r.exdates, []), cancelled: Boolean(r.cancelled), cancelledDates: json(r.cancelled_dates, []), movedDates: parseMovedDates(r.moved_dates),
     location: json(r.location, {}), cta: json(r.cta, {}), calendarIds: json(r.calendar_ids, []),
     fields: json(r.fields, {}), sourceUid: r.source_uid ?? '', rsvp: json(r.rsvp, {}), roomHold: json(r.room_hold, {}),
     hostIds: json(r.host_ids, []), request: parseRequest(r.request),
@@ -848,8 +857,8 @@ export class SqlRepository implements ContentRepository {
     await this.driver.run(
       `INSERT INTO events (id, slug, title, body_json, body_html, excerpt, cover, cover_alt, seo_title, seo_desc, status, featured, tags, template,
         starts, ends, all_day, timezone, rrule, exdates, cancelled, location, cta, calendar_ids, fields, source_uid, start_at, end_at,
-        published_at, scheduled_at, created_at, updated_at, rsvp, room_hold, cancelled_dates, host_ids, request, translations)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        published_at, scheduled_at, created_at, updated_at, rsvp, room_hold, cancelled_dates, host_ids, request, translations, moved_dates)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       [
         id, data.slug, data.title, data.bodyJson ?? '', data.bodyHtml ?? '', data.excerpt ?? '', data.cover ?? '', data.coverAlt ?? '',
         data.seoTitle ?? '', data.seoDesc ?? '', data.status ?? 'draft', data.featured ? 1 : 0, JSON.stringify(data.tags ?? []), data.template ?? '',
@@ -859,6 +868,7 @@ export class SqlRepository implements ContentRepository {
         data.publishedAt ?? (data.status === 'published' ? now : null), data.scheduledAt ?? null, now, now,
         JSON.stringify(data.rsvp ?? {}), JSON.stringify(data.roomHold ?? {}), JSON.stringify(data.cancelledDates ?? []),
         JSON.stringify(data.hostIds ?? []), data.request ? JSON.stringify(data.request) : null, JSON.stringify(data.translations ?? {}),
+        JSON.stringify(data.movedDates ?? {}),
       ]
     );
     await this.syncEventIndex(id);
@@ -883,7 +893,7 @@ export class SqlRepository implements ContentRepository {
       if (v !== undefined) { sets.push(`${col} = ?`); args.push(v); }
     }
     const jsonCols: Record<string, string> = {
-      tags: 'tags', exdates: 'exdates', cancelledDates: 'cancelled_dates', location: 'location', cta: 'cta', calendarIds: 'calendar_ids', fields: 'fields', rsvp: 'rsvp', translations: 'translations', roomHold: 'room_hold',
+      tags: 'tags', exdates: 'exdates', cancelledDates: 'cancelled_dates', movedDates: 'moved_dates', location: 'location', cta: 'cta', calendarIds: 'calendar_ids', fields: 'fields', rsvp: 'rsvp', translations: 'translations', roomHold: 'room_hold',
     };
     for (const [k, col] of Object.entries(jsonCols)) {
       const v = (data as Record<string, unknown>)[k];
@@ -955,6 +965,14 @@ export class SqlRepository implements ContentRepository {
     await this.ready;
     await this.driver.run('UPDATE events SET cancelled_dates = ?, updated_at = ? WHERE id = ?', [JSON.stringify(dates), Date.now(), id]);
   }
+  async setEventMovedDates(id: string, moved: CalEvent['movedDates'], cancelledDates?: string[], opts: { quiet?: boolean } = {}) {
+    await this.ready;
+    const write = cancelledDates
+      ? { sql: 'UPDATE events SET moved_dates = ?, cancelled_dates = ?, updated_at = ? WHERE id = ?', args: [JSON.stringify(moved), JSON.stringify(cancelledDates), Date.now(), id] }
+      : { sql: 'UPDATE events SET moved_dates = ?, updated_at = ? WHERE id = ?', args: [JSON.stringify(moved), Date.now(), id] };
+    // quiet: the change it records sends its webhook but no member push (the flag shares this transaction)
+    await this.driver.batch(opts.quiet ? [{ sql: 'UPDATE push_control SET quiet=1 WHERE id=1' }, write, { sql: 'UPDATE push_control SET quiet=0 WHERE id=1' }] : [write]);
+  }
   async cancelOccurrenceRsvps(id: string, start: number) {
     await this.ready;
     // the mutation id limits the "cancelled" emails to exactly these RSVPs (as deleteEvent does)
@@ -966,12 +984,12 @@ export class SqlRepository implements ContentRepository {
     ]);
     return Number((await this.first("SELECT COUNT(*) AS n FROM bookings WHERE event_id=? AND kind='rsvp' AND email_mutation=?", [id, mutation]))?.n ?? 0);
   }
-  async moveOccurrenceRsvps(id: string, start: number, to: { eventId?: string; start: number; end: number }) {
+  async moveOccurrenceRsvps(id: string, start: number, to: { eventId?: string; start: number; end: number }, message = '') {
     await this.ready;
     const target = to.eventId || id;
     // one mutation id marks every moved row; only the seated ones are emailed
     const mutation = crypto.randomUUID();
-    const notifications = bookingJobs(target,'rescheduled',undefined,false,mutation).map(s=>({...s,sql:s.sql.replace('b.id = ?',"b.event_id = ? AND b.kind='rsvp' AND b.status IN ('pending','confirmed')")}));
+    const notifications = bookingJobs(target,'rescheduled',undefined,false,mutation,message).map(s=>({...s,sql:s.sql.replace('b.id = ?',"b.event_id = ? AND b.kind='rsvp' AND b.status IN ('pending','confirmed')")}));
     await this.driver.batch([
       {sql:`UPDATE bookings SET event_id=?,start_at=?,end_at=?,hold_start=?,hold_end=?,notification_version=notification_version+1,email_mutation=?,reminder_sent_at=NULL,updated_at=?
         WHERE event_id=? AND kind='rsvp' AND start_at=? AND status IN ${RSVP_ACTIVE}`,args:[target,to.start,to.end,to.start,to.end,mutation,Date.now(),id,start]},
@@ -1906,15 +1924,15 @@ export class SqlRepository implements ContentRepository {
       ...(content.events ?? []).map((e) => ({
         sql: `INSERT INTO events (id, slug, title, body_json, body_html, excerpt, cover, cover_alt, seo_title, seo_desc, status, featured, tags, template,
           starts, ends, all_day, timezone, rrule, exdates, cancelled, location, cta, calendar_ids, fields, source_uid, start_at, end_at,
-          draft, published_at, scheduled_at, created_at, updated_at, rsvp, room_hold, cancelled_dates, host_ids, request)
-          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          draft, published_at, scheduled_at, created_at, updated_at, rsvp, room_hold, cancelled_dates, host_ids, request, moved_dates)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
         args: [
           e.id, e.slug, e.title, e.bodyJson, e.bodyHtml, e.excerpt, e.cover, e.coverAlt, e.seoTitle, e.seoDesc, e.status, e.featured ? 1 : 0,
           JSON.stringify(e.tags), e.template, e.start, e.end, e.allDay ? 1 : 0, e.timezone, e.rrule, JSON.stringify(e.exdates),
           e.cancelled ? 1 : 0, JSON.stringify(e.location), JSON.stringify(e.cta), JSON.stringify(e.calendarIds), JSON.stringify(e.fields),
           e.sourceUid, e.startAt, e.endAt, e.draft ? JSON.stringify(e.draft) : null, e.publishedAt, e.scheduledAt, e.createdAt, e.updatedAt,
           JSON.stringify(e.rsvp ?? {}), JSON.stringify(e.roomHold ?? {}), JSON.stringify(e.cancelledDates ?? []),
-          JSON.stringify(e.hostIds ?? []), e.request ? JSON.stringify(e.request) : null,
+          JSON.stringify(e.hostIds ?? []), e.request ? JSON.stringify(e.request) : null, JSON.stringify(e.movedDates ?? {}),
         ],
       })),
       // announcements (a backup made before them leaves the current ones). Restored

package/src/lib/repo/types.ts

@@ -48,7 +48,7 @@ export type EventUpdate = Partial<
     CalEvent,
     | 'title' | 'slug' | 'bodyJson' | 'bodyHtml' | 'excerpt' | 'cover' | 'coverAlt'
     | 'seoTitle' | 'seoDesc' | 'status' | 'featured' | 'tags' | 'template'
-    | 'start' | 'end' | 'allDay' | 'timezone' | 'rrule' | 'exdates' | 'cancelled' | 'cancelledDates'
+    | 'start' | 'end' | 'allDay' | 'timezone' | 'rrule' | 'exdates' | 'cancelled' | 'cancelledDates' | 'movedDates'
     | 'location' | 'cta' | 'calendarIds' | 'fields' | 'sourceUid' | 'rsvp' | 'translations' | 'roomHold'
     | 'publishedAt' | 'scheduledAt'
   >
@@ -168,15 +168,18 @@ export interface ContentRepository {
   discardEventDraft(id: string): Promise<void>;
   /** replace an event's cancelled occurrence keys at once, keeping any staged draft */
   setEventCancelledDates(id: string, dates: string[]): Promise<void>;
+  /** replace an event's moved dates (and cancelled dates, when given) at once, keeping any staged draft; quiet: no member push for it */
+  setEventMovedDates(id: string, moved: CalEvent['movedDates'], cancelledDates?: string[], opts?: { quiet?: boolean }): Promise<void>;
   /** Cancels the RSVPs for one date of an event (they get the "cancelled" email). Returns how many. */
   cancelOccurrenceRsvps(id: string, start: number): Promise<number>;
   /**
    * Moves the RSVPs for one date of an event (those starting at `start`) to a
    * new time, and to another event when `to.eventId` is set. Pending and
-   * confirmed ones get the "new time" email; places in line move quietly.
+   * confirmed ones get the "new time" email (with `message`, when given);
+   * places in line move quietly.
    * Returns how many moved.
    */
-  moveOccurrenceRsvps(id: string, start: number, to: { eventId?: string; start: number; end: number }): Promise<number>;
+  moveOccurrenceRsvps(id: string, start: number, to: { eventId?: string; start: number; end: number }, message?: string): Promise<number>;
   deleteEvent(id: string): Promise<void>;
   // saved-place sync (lib/maps/places.ts): rewrite just the location of the
   // live row and/or the staged draft, leaving every other field — and the

package/src/lib/schema.ts

@@ -357,6 +357,24 @@ export const RoomHold = z.object({
 });
 export type RoomHold = z.infer<typeof RoomHold>;
 
+// One date of a repeating event at another time (and maybe in other rooms or
+// another place): CalEvent.movedDates, keyed by the date's ORIGINAL occurrence
+// key. start/end are wall-clock in the event's zone like the event's own
+// (dates for all-day events, end inclusive). Unset roomIds/location = the
+// event's. note is public ("Moved for the youth retreat"); by is who moved it
+// (a user id, or 'google-sync'), at when. lib/calendar/moves.ts writes these.
+export const MovedDate = z.object({
+  start: z.string(),
+  end: z.string(),
+  roomIds: z.array(z.string()).optional(),
+  location: EventLocation.optional(),
+  note: z.string().max(500).default(''),
+  by: z.string().default(''),
+  at: z.number().default(0),
+});
+export type MovedDate = z.infer<typeof MovedDate>;
+export const MovedDates = z.record(z.string(), MovedDate).default({});
+
 // A member's event request (lib/calendar/requests.ts): a new event waiting
 // for approval (kind 'new', the event stays a draft), or changes to a live
 // event staged in its `draft` (kind 'changes'). Staff approve or decline;
@@ -407,6 +425,9 @@ export const CalEvent = z.object({
   // cancelled: shown struck through, but they don't hold rooms. Keys that no
   // longer match an occurrence (the series moved) are ignored.
   cancelledDates: z.array(z.string()).default([]),
+  // single dates at another time (MovedDate above); a date is moved or
+  // cancelled, never both. Keys that no longer match an occurrence are ignored.
+  movedDates: MovedDates,
   location: EventLocation.default({}),
   cta: EventCta.default({}),
   calendarIds: z.array(z.string()).default([]),

package/src/lib/sections.ts

@@ -32,6 +32,8 @@ export interface LinkValue { label: string; href: string; external: boolean }
 export interface EventItem {
   title: string; url: string; summary: string; image: string; imageAlt: string; location: string;
   start: string; end: string; allDay: boolean; cancelled: boolean;
+  /** this date was moved here: from "Thu, Oct 1 · 6:00 PM" (where it was), with staff's public note; null when not moved */
+  moved: { from: string; note: string } | null;
   /** "Sat, Oct 3 · 11:00 AM" */ when: string; /** "Saturday, October 3, 2026" */ date: string;
   /** "11:00 AM – 1:00 PM EDT" */ time: string; month: string; day: string; weekday: string;
   cta: { label: string; href: string } | null;
@@ -141,11 +143,12 @@ async function resolveSource(field: Extract<FieldDef, { type: 'source' }>, value
     return (await upcomingEvents(repo, settings, now, { calendarIds, limit, tag: cfg.tag, excludeTag: cfg.excludeTag })).map((o): EventItem => {
       const e = lang ? localizeDoc(o.event, lang) : o.event;
       const f = formatOccurrence(o, tz, locale);
+      const was = o.moved ? formatOccurrence({ ...o, start: o.moved.from.start, end: o.moved.from.end }, tz, locale) : null;
       const ctaHref = safeUrl(e.cta.href);
       return {
         title: e.title || 'Untitled event', url: lp(eventUrl(e.slug)), summary: e.excerpt, image: safeUrl(e.cover), imageAlt: e.coverAlt,
-        location: locationLine(e.location), start: new Date(o.start).toISOString(), end: new Date(o.end).toISOString(),
-        allDay: o.allDay, cancelled: o.cancelled, when: f.range, date: f.date, time: f.time, month: f.month, day: f.day, weekday: f.weekday,
+        location: locationLine(o.moved?.location ?? e.location), start: new Date(o.start).toISOString(), end: new Date(o.end).toISOString(),
+        allDay: o.allDay, cancelled: o.cancelled, moved: was && o.moved ? { from: o.allDay ? was.date : was.range, note: o.moved.note } : null, when: f.range, date: f.date, time: f.time, month: f.month, day: f.day, weekday: f.weekday,
         cta: e.cta.label && ctaHref && !o.cancelled ? { label: e.cta.label, href: ctaHref } : null,
       };
     });

package/src/lib/sync/catalog.ts

@@ -130,6 +130,7 @@ const jsonFields = new Set([
   "roomHold",
   "exdates",
   "cancelledDates",
+  "movedDates",
   "amenities",
   "hours",
   "overrides",

package/src/pages/api/calendar/events/index.ts

@@ -14,16 +14,20 @@ import { readJson } from '../../../../lib/api';
 import { runAgentTool } from '../../../../lib/agent';
 import { waitUntilFrom } from '../../../../lib/webhooks';
 import { fail } from '../../../../lib/calendar/http';
-import { publicTags, tagFilter } from '../../../../lib/schema';
+import { occurrenceMatches, readEventFilter, resolveEventFilter, tagsMatch } from '../../../../lib/calendar/filter';
 
 // Public read API for other sites, apps and lobby screens.
 //   GET /api/calendar/events?from=2026-10-01&to=2026-10-31&calendar=youth&q=night
 //   GET /api/calendar/events?tag=class (or excludeTag=class; a tag's name or slug)
+//   GET /api/calendar/events?calendar=youth,events&notag=Class&room=chapel
+//   (the /calendar page's filters: each takes several values, comma-separated
+//   or repeated; cal and notag are aliases of calendar and excludeTag)
 //   → { timezone, from, to, occurrences: [{ id, start, end, allDay, cancelled, event }] }
 //   GET /api/calendar/events?expand=0 → { events: [...] } (rules, not instances)
 // Anonymous callers see public calendars (and an unlisted one when asked by
 // slug). A key with events:read also sees private calendars and private
-// custom fields, and its tag filters also match internal "#" tags.
+// custom fields, its tag filters also match internal "#" tags, and its room
+// filter matches every room (anonymous callers: rooms shown on public events).
 const CORS = {
   'Access-Control-Allow-Origin': '*',
   'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
@@ -43,28 +47,28 @@ export const GET: APIRoute = async ({ request, locals, url }) => {
     const principal = await authenticate(request, repo);
     if (request.headers.get('authorization') && !principal) throw new ApiError(401, 'Invalid API key.');
     const full = principal ? hasScope(principal, 'events:read') : false;
+    const filter = readEventFilter(url.searchParams);
     const [settings, calendars, published, rooms] = await Promise.all([repo.getSettings(), repo.listCalendars(), repo.listPublishedEvents(), repo.listResources()]);
     const tz = settings.timezone || 'UTC';
     const map = new Map(calendars.map((c) => [c.id, c]));
     const resources = new Map(rooms.map((r) => [r.id, r]));
     const origin = siteOrigin(settings, url);
 
-    const slug = url.searchParams.get('calendar');
-    const cal = slug ? calendars.find((c) => c.slug === slug) : null;
-    if (slug && (!cal || (cal.visibility === 'private' && !full))) throw new ApiError(404, 'Unknown calendar.');
+    const f = resolveEventFilter(filter, { calendars, resources: rooms, allowPrivate: full });
+    if (f.calendarIds && f.calendarIds.length < filter.cal.length) throw new ApiError(404, 'Unknown calendar.');
+    if (f.roomIds && f.roomIds.length < filter.room.length) throw new ApiError(404, 'Unknown room.');
+    const picked = f.calendarIds;
     const q = (url.searchParams.get('q') ?? '').trim().toLowerCase();
     let events = published.filter((e) => {
-      if (cal) return e.calendarIds.includes(cal.id) && (full || eventIsPublic(e, map));
+      if (picked) return e.calendarIds.some((id) => picked.includes(id)) && (full || eventIsPublic(e, map));
       return full ? true : eventIsListed(e, map);
     });
     if (q) events = events.filter((e) => `${e.title} ${e.excerpt} ${e.location.name}`.toLowerCase().includes(q));
-    const tag = url.searchParams.get('tag')?.slice(0, 100), excludeTag = url.searchParams.get('excludeTag')?.slice(0, 100);
-    if (tag || excludeTag) {
-      const tagged = tagFilter(tag, excludeTag);
-      events = events.filter((e) => tagged(full ? e.tags : publicTags(e.tags)));
-    }
+    events = events.filter((e) => tagsMatch(f, e.tags, { internal: full }));
 
     if (url.searchParams.get('expand') === '0') {
+      // rules, not dates: a room filter matches the series' own rooms
+      if (f.roomIds) events = events.filter((e) => occurrenceMatches(f, { event: e }));
       return withCors(json({ timezone: tz, events: events.map((e) => eventToJson(e, origin, map, settings.timezone, { includePrivate: full, resources })) }));
     }
     const day = (param: string, fallback: number) => {
@@ -76,7 +80,9 @@ export const GET: APIRoute = async ({ request, locals, url }) => {
     const to = Math.min(day('to', from + 90 * 86_400_000), from + 400 * 86_400_000);
     if (to <= from) throw new ApiError(400, '"to" must be after "from".');
     const limit = Math.min(1000, Math.max(1, Number(url.searchParams.get('limit')) || 200));
-    const occ = expandEvents(events, settings, { displayTz: tz, now, windowStartMs: from, windowEndMs: to }).slice(0, limit);
+    const occ = expandEvents(events, settings, { displayTz: tz, now, windowStartMs: from, windowEndMs: to })
+      .filter((o) => !f.roomIds || occurrenceMatches(f, o))
+      .slice(0, limit);
     const cache = new Map<string, ReturnType<typeof eventToJson>>();
     const toJson = (id: string) => {
       if (!cache.has(id)) cache.set(id, eventToJson(events.find((e) => e.id === id)!, origin, map, settings.timezone, { includePrivate: full, resources }));
@@ -94,6 +100,12 @@ export const GET: APIRoute = async ({ request, locals, url }) => {
           end: o.allDay ? isoWithOffset(o.end - 86_400_000, etz).slice(0, 10) : isoWithOffset(o.end, etz),
           allDay: o.allDay,
           cancelled: o.cancelled,
+          // the date's key (a moved date keeps its original one), and where it moved from
+          key: o.key,
+          moved: o.moved ? {
+            from: { start: o.allDay ? isoWithOffset(o.moved.from.start, etz).slice(0, 10) : isoWithOffset(o.moved.from.start, etz), end: o.allDay ? isoWithOffset(o.moved.from.end - 86_400_000, etz).slice(0, 10) : isoWithOffset(o.moved.from.end, etz) },
+            note: o.moved.note, location: o.moved.location ?? null,
+          } : null,
           // that date's rooms
           rooms: roomsToJson(o.roomIds, resources, full),
           event: toJson(o.event.id),

package/src/pages/calendar/[slug].ics.ts

@@ -4,10 +4,13 @@ import { getRepo } from '../../lib/repo';
 import { siteOrigin } from '../../lib/seo';
 import { CALENDAR } from '../../lib/calendar/config';
 import { feedFor, icsResponse } from '../../lib/calendar/feeds';
+import { readEventFilter, resolveEventFilter } from '../../lib/calendar/filter';
 
 // One calendar's subscribe feed. Public and unlisted calendars are open;
 // private ones need the secret ?t= token from Calendars → Copy link (staff
 // subscriptions). A wrong token looks exactly like a missing calendar.
+// ?tag=, ?notag= and ?room= narrow it like the /calendar page (a `cal` here
+// is ignored: the address names the calendar).
 const sameToken = (a: string, b: string) =>
   a.length === b.length && a.length > 0 && timingSafeEqual(Buffer.from(a), Buffer.from(b));
 
@@ -18,8 +21,11 @@ export const GET: APIRoute = async ({ locals, url, params }) => {
   if (!calendar || calendar.kind !== 'native') return new Response(null, { status: 404 });
   const isPrivate = calendar.visibility === 'private';
   if (isPrivate && !sameToken(url.searchParams.get('t') ?? '', calendar.feedToken)) return new Response(null, { status: 404 });
-  const settings = await repo.getSettings();
-  const { body } = await feedFor(repo, settings, siteOrigin(settings, url), { calendar, allowPrivate: isPrivate });
+  const filter = { ...readEventFilter(url.searchParams), cal: [] };
+  const [settings, resources] = await Promise.all([repo.getSettings(), filter.room.length ? repo.listResources() : []]);
+  const resolved = resolveEventFilter(filter, { calendars: [], resources, allowPrivate: isPrivate });
+  if (resolved.unknown) return new Response(null, { status: 404 });
+  const { body } = await feedFor(repo, settings, siteOrigin(settings, url), { calendar, allowPrivate: isPrivate, filter: resolved });
   // private feeds must never sit in shared caches
   const res = icsResponse(body, `${calendar.slug}.ics`, isPrivate ? 0 : 300);
   if (isPrivate) res.headers.set('Cache-Control', 'private, no-store');

package/src/pages/calendar/feed.ics.ts

@@ -3,13 +3,20 @@ import { getRepo } from '../../lib/repo';
 import { siteOrigin } from '../../lib/seo';
 import { CALENDAR } from '../../lib/calendar/config';
 import { feedFor, icsResponse } from '../../lib/calendar/feeds';
+import { readEventFilter, resolveEventFilter } from '../../lib/calendar/filter';
 
 // Every public calendar in one subscribe feed (/calendar.ics). Feed
 // calendars are not re-published — subscribers can add those at the source.
+// The /calendar page's filters narrow it: /calendar.ics?tag=Class,
+// ?cal=youth,events&notag=Class, ?room=chapel. A calendar or room that isn't
+// public answers 404, like one that doesn't exist.
 export const GET: APIRoute = async ({ locals, url }) => {
   if (!CALENDAR.enabled) return new Response(null, { status: 404 });
   const repo = await getRepo(locals);
-  const settings = await repo.getSettings();
-  const { body } = await feedFor(repo, settings, siteOrigin(settings, url), {});
+  const filter = readEventFilter(url.searchParams);
+  const [settings, calendars, resources] = await Promise.all([repo.getSettings(), repo.listCalendars(), filter.room.length ? repo.listResources() : []]);
+  const resolved = resolveEventFilter(filter, { calendars, resources });
+  if (resolved.unknown) return new Response(null, { status: 404 });
+  const { body } = await feedFor(repo, settings, siteOrigin(settings, url), { filter: resolved });
   return icsResponse(body, 'calendar.ics');
 };

package/src/pages/calendar/index.astro

@@ -3,50 +3,69 @@ import Site from '../../layouts/Site.astro';
 import { getRepo } from '../../lib/repo';
 import { effectiveSettings } from '../../lib/designPreview';
 import { siteOrigin } from '../../lib/seo';
-import { siteLocale } from '../../lib/dates';
-import { CALENDAR, calendarFeedUrl, calendarPageUrl } from '../../lib/calendar/config';
+import { siteLang, siteLocale } from '../../lib/dates';
+import { I18N, localePath, requestLocale } from '../../lib/i18n';
+import { isExtraLocale } from '../../lib/translations';
+import { fill } from '../../lib/live/words';
+import { eventStrings } from '../../lib/calendar/event-words';
+import { CALENDAR, calendarFeedUrl, eventUrl } from '../../lib/calendar/config';
 import { calendarWindow, renderCalendarView } from '../../lib/calendar/render';
 import { collectViewEvents, type ViewEvent } from '../../lib/calendar/data';
 import { eventCardHtml } from '../../lib/calendar/cards';
 import { safeColor } from '../../lib/calendar/events';
 import { tzParts } from '../../lib/calendar/ics';
+import { eventFilterQuery, hasEventFilter, readEventFilter, resolveEventFilter, type EventFilter } from '../../lib/calendar/filter';
 
 // The main calendar page: filter chips per public calendar, Month / Week /
 // List views (the same renderer as the calendar card), image cards for
 // what's coming up, and subscribe links for every calendar app. On phones the
 // month grid gives way to a two-week day strip over the agenda.
+// The address carries the filters (filter.ts): ?cal=youth,events, ?tag=Class,
+// ?notag=Class, ?room=chapel. Active ones show as removable chips, and the
+// subscribe links carry them. /es/calendar speaks Spanish (the same languages
+// as event pages) and keeps its links under /es.
 if (!CALENDAR.enabled) return new Response(null, { status: 404, statusText: 'Not found' });
 
 const repo = await getRepo(Astro.locals);
-const settings = await effectiveSettings(await repo.getSettings(), Astro.url, Astro.cookies, Astro.locals);
+const reqLocale = I18N.enabled ? requestLocale(Astro.url, Astro.locals) : '';
+const baseSettings = await effectiveSettings(await repo.getSettings(), Astro.url, Astro.cookies, Astro.locals);
+// dates and the renderer's words follow the page's language, like event pages
+const settings = isExtraLocale(reqLocale) ? { ...baseSettings, locale: reqLocale } : baseSettings;
+const lang = reqLocale || siteLang(settings);
+const w = eventStrings(lang);
+const cw = w.calendar;
+const here = (path: string) => localePath(path, reqLocale);
 const now = Date.now();
 const tz = settings.timezone || 'UTC';
 const locale = siteLocale(settings);
 const origin = siteOrigin(settings, Astro.url);
 
-const all = await repo.listCalendars();
+const filter = readEventFilter(Astro.url.searchParams);
+const filtered = hasEventFilter(filter);
+const [all, resources] = await Promise.all([repo.listCalendars(), filter.room.length ? repo.listResources() : []]);
+const resolved = resolveEventFilter(filter, { calendars: all, resources });
 const listed = all.filter((c) => c.visibility === 'public');
-const calSlug = Astro.url.searchParams.get('cal') ?? '';
-// unlisted calendars work when linked directly, they just aren't offered
-const active = calSlug ? all.find((c) => c.slug === calSlug && c.visibility !== 'private') ?? null : null;
+// exactly one calendar picked: its name, description and own feed
+const active = filter.cal.length === 1 && resolved.calendars.length === 1 ? resolved.calendars[0] : null;
+const picked = new Set(resolved.calendarIds ?? []);
 const viewParam = Astro.url.searchParams.get('view');
 const view = (['month', 'week', 'list'] as const).find((v) => v === viewParam) ?? CALENDAR.defaultView;
-const explicitView = Boolean(viewParam);
-const monthParam = /^(\d{4})-(\d{2})$/.exec(Astro.url.searchParams.get('m') ?? '');
+const explicitView = viewParam === view;
+const monthRaw = Astro.url.searchParams.get('m') ?? '';
+const monthParam = /^(\d{4})-(\d{2})$/.exec(monthRaw);
 
 const win = calendarWindow(settings, now);
-const { events, calendars, errors } = await collectViewEvents(repo, settings, win, {
-  audience: 'public',
-  ...(active ? { calendarIds: [active.id] } : {}),
-});
+const { events, calendars, errors } = await collectViewEvents(repo, settings, win, { audience: 'public', filter: resolved, locale: lang });
 
-const calendarHtml = renderCalendarView(events, settings, now, {
+const gridHtml = renderCalendarView(events, settings, now, {
   view: view === 'list' ? 'upcoming' : view,
   limit: 50,
-  multi: !active && calendars.length > 1,
-  emptyText: 'Nothing on the calendar yet.',
+  multi: calendars.length > 1,
+  emptyText: filtered ? cw.noMatch : cw.empty,
   focus: monthParam ? { y: Number(monthParam[1]), m: Number(monthParam[2]) } : undefined,
 });
+// an empty month or week grid says why (the list says it itself)
+const calendarHtml = (filtered && !events.length && view !== 'list' ? '<p class="pc-cal-empty">' + cw.noMatch + '</p>' : '') + gridHtml;
 
 // coming up: the next occurrence of each distinct native event
 const seen = new Set<string>();
@@ -79,19 +98,44 @@ const stripDays = Array.from({ length: 14 }, (_, i) => {
   return { k, dow: fmt({ weekday: 'narrow' }).format(ms), d: tzParts(ms, tz).d, has: agenda.has(k), today: i === 0 };
 });
 
-const feed = origin + calendarFeedUrl(active?.slug);
+// links keep the filters, the view, the month and the page's language
+const pageHref = (f: EventFilter, opts: { view?: string | null; m?: string | null } = {}) => {
+  const v = opts.view === undefined ? (explicitView ? view : null) : opts.view;
+  const m = opts.m === undefined ? (monthParam ? monthRaw : null) : opts.m;
+  const q = [eventFilterQuery(f), v ? `view=${v}` : '', m ? `m=${m}` : ''].filter(Boolean).join('&');
+  return here(CALENDAR.base) + (q ? `?${q}` : '');
+};
+const viewHref = (v: string) => pageHref(filter, { view: v, m: null });
+const without = (key: keyof EventFilter, value: string) => pageHref({ ...filter, [key]: filter[key].filter((x) => x !== value) });
+// calendar chips switch a calendar on or off; "All" drops the calendar filter
+const toggleCal = (slug: string) => {
+  const on = filter.cal.some((s) => s.toLowerCase() === slug);
+  return pageHref({ ...filter, cal: on ? filter.cal.filter((s) => s.toLowerCase() !== slug) : [...filter.cal, slug] });
+};
+const offered = [...listed, ...resolved.calendars.filter((c) => c.visibility !== 'public')];
+const roomName = (slug: string) => resolved.rooms.find((r) => r.slug === slug.toLowerCase())?.name ?? slug;
+// the removable chips: tags, left-out tags, rooms, and calendars that didn't resolve
+const chips = [
+  ...filter.tag.map((t) => ({ label: t, href: without('tag', t) })),
+  ...filter.notag.map((t) => ({ label: fill(cw.without, { tag: t }), href: without('notag', t) })),
+  ...filter.room.map((r) => ({ label: fill(cw.room, { room: roomName(r) }), href: without('room', r) })),
+  ...filter.cal.filter((s) => !resolved.calendars.some((c) => c.slug === s.toLowerCase())).map((s) => ({ label: s, href: without('cal', s) })),
+];
+
+// subscribe: one calendar alone keeps its own feed; anything else is the
+// site feed with the same filters
+const ownFeed = active && !filter.tag.length && !filter.notag.length && !filter.room.length;
+const feedQuery = eventFilterQuery(filter);
+const feed = origin + (ownFeed ? calendarFeedUrl(active.slug) : calendarFeedUrl() + (feedQuery ? `?${feedQuery}` : ''));
 const webcal = feed.replace(/^https?:\/\//, 'webcal://');
 const googleAdd = `https://calendar.google.com/calendar/r?cid=${encodeURIComponent(webcal)}`;
 const outlookAdd = `https://outlook.live.com/calendar/0/addfromweb?url=${encodeURIComponent(feed)}&name=${encodeURIComponent(active?.name ?? settings.siteTitle)}`;
-const viewHref = (v: string) => {
-  const p = new URLSearchParams(Astro.url.search);
-  p.set('view', v);
-  p.delete('m');
-  return `${CALENDAR.base}?${p}`;
-};
-const title = active ? active.name : 'Calendar';
-const lede = active?.description || `What’s happening at ${settings.siteTitle}. Subscribe to keep it in your own calendar.`;
+const subscribeNote = ownFeed ? fill(cw.subscribeNamed, { name: active.name }) : filtered ? cw.subscribeFiltered : cw.subscribeAll;
+const title = active ? active.name : cw.title;
+const lede = active?.description || fill(cw.lede, { site: settings.siteTitle });
 const zoneName = fmt({ timeZoneName: 'long' }).formatToParts(now).find((p) => p.type === 'timeZoneName')?.value ?? tz;
+const agendaEmpty = filtered && !events.length ? cw.noMatch : cw.emptySoon;
+const cardHref = (v: ViewEvent) => here(eventUrl(v.event!.slug));
 ---
 
 <Site title={title} description={lede}>
@@ -102,40 +146,51 @@ const zoneName = fmt({ timeZoneName: 'long' }).formatToParts(now).find((p) => p.
     </header>
 
     <div class="pc-calpage-bar">
-      {(listed.length > 1 || active) && (
-        <nav class="pc-calpage-chips" aria-label="Calendars">
-          <a class={!active ? 'is-on' : ''} href={CALENDAR.base} aria-current={!active ? 'page' : undefined}>All</a>
-          {listed.map((c) => (
-            <a class={active?.id === c.id ? 'is-on' : ''} href={calendarPageUrl(c.slug)} aria-current={active?.id === c.id ? 'page' : undefined}>
+      {(offered.length > 1 || picked.size > 0) && (
+        <nav class="pc-calpage-chips" aria-label={cw.calendars}>
+          <a class={!filter.cal.length ? 'is-on' : ''} href={pageHref({ ...filter, cal: [] })} aria-current={!filter.cal.length ? 'page' : undefined}>{cw.all}</a>
+          {offered.map((c) => (
+            <a class={picked.has(c.id) ? 'is-on' : ''} href={toggleCal(c.slug)} aria-current={picked.has(c.id) ? 'true' : undefined}>
               <i style={`background:${safeColor(c.color)}`} aria-hidden="true" />{c.name}
             </a>
           ))}
-          {active && active.visibility !== 'public' && <a class="is-on" href={calendarPageUrl(active.slug)}><i style={`background:${safeColor(active.color)}`} aria-hidden="true" />{active.name}</a>}
         </nav>
       )}
       <div class="pc-calpage-tools">
-        <nav class="pc-calpage-views" aria-label="View">
-          <a class={view === 'month' ? 'is-on' : ''} href={viewHref('month')}>Month</a>
-          <a class={view === 'week' ? 'is-on' : ''} href={viewHref('week')}>Week</a>
-          <a class={view === 'list' ? 'is-on' : ''} href={viewHref('list')}>List</a>
+        <nav class="pc-calpage-views" aria-label={cw.views}>
+          <a class={view === 'month' ? 'is-on' : ''} href={viewHref('month')}>{cw.month}</a>
+          <a class={view === 'week' ? 'is-on' : ''} href={viewHref('week')}>{cw.week}</a>
+          <a class={view === 'list' ? 'is-on' : ''} href={viewHref('list')}>{cw.list}</a>
         </nav>
         <details class="pc-calpage-sub">
           <summary>
             <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M12 4v11M7 10l5 5 5-5M5 20h14" /></svg>
-            Subscribe
+            {cw.subscribe}
           </summary>
           <div class="pc-calpage-sub-menu">
-            <p>Add {active ? `“${active.name}”` : 'this calendar'} to your calendar app. New events show up on their own.</p>
+            <p>{subscribeNote}</p>
             <a href={googleAdd} target="_blank" rel="noopener">Google Calendar</a>
             <a href={webcal}>Apple Calendar</a>
             <a href={outlookAdd} target="_blank" rel="noopener">Outlook</a>
-            <button type="button" data-copy={feed}>Copy link</button>
+            <button type="button" data-copy={feed} data-copied={w.linkCopied}>{cw.copyLink}</button>
           </div>
         </details>
       </div>
     </div>
 
-    <div class="pc-calpage-strip" aria-label="Next two weeks">
+    {chips.length > 0 && (
+      <nav class="pc-calpage-filters" aria-label={cw.filters}>
+        {chips.map((c) => (
+          <a class="pc-calpage-filter" href={c.href} aria-label={fill(cw.remove, { filter: c.label })}>
+            <span>{c.label}</span>
+            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" aria-hidden="true"><path d="M7 7l10 10M17 7L7 17" /></svg>
+          </a>
+        ))}
+        {chips.length > 1 && <a class="pc-calpage-clear" href={pageHref({ cal: [], tag: [], notag: [], room: [] })}>{cw.clear}</a>}
+      </nav>
+    )}
+
+    <div class="pc-calpage-strip" aria-label={cw.nextTwoWeeks}>
       {stripDays.map((d) => (
         <a class={`${d.has ? 'has' : ''}${d.today ? ' today' : ''}`} href={d.has ? `#d-${d.k}` : undefined} aria-label={d.k}>
           <small>{d.dow}</small><b>{d.d}</b><i aria-hidden="true" />
@@ -145,13 +200,13 @@ const zoneName = fmt({ timeZoneName: 'long' }).formatToParts(now).find((p) => p.
 
     <div class="pc-calpage-view" set:html={calendarHtml} />
 
-    <section class="pc-calpage-agenda" aria-label="Agenda">
-      {agenda.size === 0 ? <p class="pc-cal-empty">Nothing in the next two months.</p> : [...agenda.entries()].map(([k, list]) => (
+    <section class="pc-calpage-agenda" aria-label={cw.agenda}>
+      {agenda.size === 0 ? <p class="pc-cal-empty">{agendaEmpty}</p> : [...agenda.entries()].map(([k, list]) => (
         <div class="pc-agenda-day" id={`d-${k}`}>
           <h3>{dayLabel.format(list[0].start < now ? now : list[0].start)}</h3>
           {list.map((v) => (
             <a class={`pc-agenda-row${v.cancelled ? ' is-cancelled' : ''}`} href={v.url ?? undefined}>
-              <span class="t">{v.allDay ? 'All day' : timeLabel.format(v.start)}</span>
+              <span class="t">{v.allDay ? w.allDay : timeLabel.format(v.start)}</span>
               <span class="ti">
                 {v.color && <i style={`background:${v.color}`} aria-hidden="true" />}
                 <b>{v.title}</b>
@@ -165,14 +220,14 @@ const zoneName = fmt({ timeZoneName: 'long' }).formatToParts(now).find((p) => p.
 
     {view !== 'list' && comingUp.length > 0 && (
       <section class="pc-calpage-up">
-        <h2>Coming up</h2>
-        <div class="pc-ev-cards" data-layout="grid" set:html={comingUp.map((v) => eventCardHtml({ event: v.event!, start: v.start, end: v.end, allDay: v.allDay, days: v.days, cancelled: v.cancelled }, settings, { showImage: true })).join('')} />
+        <h2>{cw.comingUp}</h2>
+        <div class="pc-ev-cards" data-layout="grid" set:html={comingUp.map((v) => eventCardHtml({ event: v.event!, start: v.start, end: v.end, allDay: v.allDay, days: v.days, cancelled: v.cancelled }, settings, { showImage: true, href: cardHref(v) })).join('')} />
       </section>
     )}
 
     <footer class="pc-calpage-foot">
-      <span>Times in {zoneName}</span>
-      {errors.length > 0 && <span>Some linked calendars couldn’t be loaded right now.</span>}
+      <span>{fill(cw.timesIn, { zone: zoneName })}</span>
+      {errors.length > 0 && <span>{cw.feedErrors}</span>}
     </footer>
   </div>
   <script>
@@ -180,8 +235,9 @@ const zoneName = fmt({ timeZoneName: 'long' }).formatToParts(now).find((p) => p.
       const b = e.target instanceof Element ? e.target.closest<HTMLButtonElement>('[data-copy]') : null;
       if (b) {
         await navigator.clipboard.writeText(b.dataset.copy ?? '');
-        b.textContent = 'Link copied';
-        setTimeout(() => (b.textContent = 'Copy link'), 1400);
+        const label = (b.dataset.label ??= b.textContent ?? '');
+        b.textContent = b.dataset.copied ?? label;
+        setTimeout(() => (b.textContent = label), 1400);
       }
       document.querySelectorAll<HTMLDetailsElement>('details.pc-calpage-sub[open]').forEach((d) => {
         if (!(e.target instanceof Node && d.contains(e.target))) d.open = false;