@acms-subir/core 0.3.61 → 0.3.62

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @acms-subir/core
 
+## 0.3.62
+
+### Patch Changes
+
+- 729834a: Unlisted calendars work with app notifications and search.
+
+  - **A rule that names an event covers it in an Unlisted calendar.** Under Admin → Mobile app, the new event, starting soon and event change rules sent notices only for events in Public calendars. A "Class changes" rule (every calendar, tag `Class`) never fired for classes in an Unlisted rooms calendar. A rule now covers an Unlisted calendar's events when it names them, either by listing that calendar or, for an event change rule, by listing a tag the event has. "All public calendars" with no tags still covers only Public calendars, so Unlisted items don't start notifying on their own. Each rule is judged on its own, so a class goes only to the topics of the rule that names it. Private calendars never notify, and neither do appointments from Google booking pages (`#google-booking`). An event's `notify.changes` in the app API follows the same rules.
+  - **The Mobile app page lists Unlisted calendars.** They appear next to the Public ones, marked "unlisted", and saving keeps them in a rule (it used to drop them). In an event change rule that lists tags, "All public calendars" reads "All calendars" and covers the Unlisted ones too.
+  - **One search rule for the app and the website.** App search (`/api/v1/search`) now finds events in Unlisted calendars, as the website's `/search` and `/api/search` already did. None of them return Google booking-page appointments ("Booked") any more. `/api/v1/events?q=`, which continues an app search's "more", finds the same events; without `q`, `/api/v1/events` still lists Public calendars only.
+
+  There's no migration, and nothing to change after updating. To get class change notices from an Unlisted calendar, give the rule the `Class` tag (or tick that calendar) in Admin → Mobile app.
+
 ## 0.3.61
 
 ### Patch Changes

package/docs/mobile.md

@@ -257,7 +257,10 @@ For a search screen across everything, `useSearch(text)` returns groups
 (posts, pages, events) with snippets. Group `posts` by `collection` for
 headings, and when `more.posts` is true link to the collection list with that
 `q`. Search matches the main-language text, so Spanish words find content only
-where the original is Spanish.
+where the original is Spanish. Events include unlisted calendars (a rooms
+calendar's classes, say), never private ones or Google booking-page
+appointments; when `more.events` is true, `useEvents({ q })` lists the same
+events by date (without `q` it lists public calendars only).
 
 **A native version of a coded section.** From the site folder:
 `npx acms section new visit-banner --theme <slug>` (new) or, for an existing
@@ -281,6 +284,9 @@ keyed by `locale`.
 Optional; the owner sends them from **Admin → Mobile app** (manual messages
 plus automatic ones: new post, new event, "starting soon", event changes,
 "we're live"). The app only registers and chooses topics; it never sends.
+Events in an unlisted calendar notify only when a rule names that calendar or a
+tag they have; an event's `notify.changes` says which topics hear about its
+changes.
 
 1. Site: `acms({ mobile: { push: true } })` in `astro.config.mjs` (off by
    default; `/api/v1/devices` and `/api/v1/push/topics` 404 until then).

package/package.json

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

package/src/components/MobileApp.tsx

@@ -53,7 +53,7 @@ function MobileAppView({ state, setState }: { state: AdminPushState; setState: (
   const topicLabel = useMemo(() => {
     const map = new Map(state.topics.map((t) => [t.id, t.label]));
     for (const c of state.collections) if (!map.has(`collection:${c.key}`)) map.set(`collection:${c.key}`, c.label);
-    for (const c of state.calendars) if (!map.has(`calendar:${c.slug}`)) map.set(`calendar:${c.slug}`, c.name);
+    for (const c of state.calendars) if (c.visibility === 'public' && !map.has(`calendar:${c.slug}`)) map.set(`calendar:${c.slug}`, c.name);
     map.set('*', 'Everyone');
     return (id: string) => map.get(id) ?? id;
   }, [state]);
@@ -282,14 +282,19 @@ function Automatic({ state, setState }: { state: AdminPushState; setState: (s: A
   const setRule = (i: number, patch: Partial<ChangeRule>) => setAuto({ ...auto, eventChanges: rules.map((r, j) => (j === i ? { ...r, ...patch } : r)) });
   // focus moves to "Add a rule" (enabled again once the tenth rule goes)
   const removeRule = (i: number) => { setAuto({ ...auto, eventChanges: rules.filter((_, j) => j !== i) }); requestAnimationFrame(() => addRule.current?.focus()); };
-  const calendarChoices = (list: string[], set: (calendars: string[]) => void) => {
+  // '*' covers the public calendars; an unlisted one only when it's ticked, or
+  // (`tagged`: a change rule that lists tags) for events with those tags
+  const calendarChoices = (list: string[], set: (calendars: string[]) => void, tagged = false) => {
     const all = list.includes('*');
+    const unlisted = new Set(state.calendars.filter((c) => c.visibility !== 'public').map((c) => c.id));
+    const covered = (c: AdminPushState['calendars'][number]) => all && (c.visibility === 'public' || tagged);
     return (
       <div className="ma-choices">
-        <label className="ma-check"><input type="checkbox" checked={all} onChange={() => set(all ? [] : ['*'])} /><span>All public calendars</span></label>
+        <label className="ma-check"><input type="checkbox" checked={all}
+          onChange={() => set(all ? list.filter((id) => id !== '*') : ['*', ...list.filter((id) => unlisted.has(id))])} /><span>{tagged ? 'All calendars' : 'All public calendars'}</span></label>
         {state.calendars.map((c) => (
-          <label key={c.id} className="ma-check"><input type="checkbox" disabled={all} checked={all || list.includes(c.id)} onChange={() => set(flip(list, c.id))} />
-            <span><i className="ma-dot" style={{ background: c.color || 'var(--faint)' }} />{c.name}</span></label>
+          <label key={c.id} className="ma-check"><input type="checkbox" disabled={covered(c)} checked={covered(c) || list.includes(c.id)} onChange={() => set(flip(list, c.id))} />
+            <span><i className="ma-dot" style={{ background: c.color || 'var(--faint)' }} />{c.name}{c.visibility !== 'public' && <span className="hint"> · unlisted</span>}</span></label>
         ))}
       </div>
     );
@@ -337,7 +342,7 @@ function Automatic({ state, setState }: { state: AdminPushState; setState: (s: A
                         <b id={`${uid}-rule-${i}`}>Rule {i + 1}</b>
                         <button type="button" className="btn ghost sm" aria-label={`Remove rule ${i + 1}`} onClick={() => removeRule(i)}>Remove</button>
                       </div>
-                      {calendarChoices(r.calendars, (calendars) => setRule(i, { calendars }))}
+                      {calendarChoices(r.calendars, (calendars) => setRule(i, { calendars }), r.tags.length > 0)}
                       <div className="ma-fields">
                         <div className="field ma-lead">
                           <span>Only events tagged</span>

package/src/lib/calendar/events.ts

@@ -398,8 +398,8 @@ export function featuredOccurrence(e: CalEvent, settings: Pick<Settings, 'timezo
 
 // ---- visibility ----------------------------------------------------------
 // An event with no calendars counts as public. Otherwise it follows its most
-// open calendar: any public/unlisted calendar makes the event page public;
-// only public calendars put it on the main calendar page and site feed.
+// open calendar: any public/unlisted calendar makes the event page public (and
+// searchable); only public calendars put it on the main calendar page and site feed.
 
 export function eventIsPublic(e: CalEvent, calendars: Map<string, Calendar>): boolean {
   if (e.status !== 'published') return false;
@@ -416,6 +416,16 @@ export function eventIsListed(e: CalEvent, calendars: Map<string, Calendar>): bo
   return e.calendarIds.some((id) => calendars.get(id)?.visibility === 'public');
 }
 
+/** The internal tag on appointments booked through a Google booking page (they come in titled "Booked"). */
+export const BOOKING_TAG = '#google-booking';
+/** A Google booking-page appointment: search never finds it and push never announces it. */
+export const isGoogleBooking = (e: Pick<CalEvent, 'tags'>) => e.tags.some((t) => t.trim().toLowerCase() === BOOKING_TAG);
+
+/** What search finds, on the website and in the app: events with a public page (unlisted calendars too), but no booking-page appointments. */
+export function eventIsSearchable(e: CalEvent, calendars: Map<string, Calendar>): boolean {
+  return eventIsPublic(e, calendars) && !isGoogleBooking(e);
+}
+
 // ---- formatting ----------------------------------------------------------
 
 export function formatOccurrence(

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

@@ -27,7 +27,7 @@ const DAY = 86_400_000;
 const pad = (n: number) => String(n).padStart(2, '0');
 
 /** The internal tag on booked appointments from Google booking pages (Q16): never shown publicly. */
-export const BOOKING_TAG = '#google-booking';
+export { BOOKING_TAG } from '../events';
 
 /** The few words the sync writes, in the site's main language (Q9). */
 export interface SyncWords { cancelled: string; details: string; link: string; booked: string; untitled: string }

package/src/lib/mobile/calendar.ts

@@ -4,7 +4,7 @@ import { type BookingLink, type CalEvent, type Calendar, type Resource, type Set
 import { ApiError } from '../api';
 import { CALENDAR, bookingsEnabled, resourceUrl, bookingLinkUrl, publicEventFields } from '../calendar/config';
 import { calendarToJson, eventToJson, roomsToJson } from '../calendar/api';
-import { eventIsListed, eventIsPublic, expandEvents, featuredOccurrence, type Occurrence } from '../calendar/events';
+import { eventIsListed, eventIsPublic, eventIsSearchable, expandEvents, featuredOccurrence, type Occurrence } from '../calendar/events';
 import { availabilityContext } from '../booking/service';
 import { roomBusy } from '../booking/holds';
 import { sha256Hex } from '../api-keys';
@@ -40,7 +40,7 @@ export const eventsQuery = z.object({ ...pageQuery, locale: localeQuery, from: i
   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();
+  q: z.string().max(100).optional().describe('Search: the events /search finds (unlisted calendars too, never Google booking-page appointments), listed by date. Without it, only public calendars and the ones named in calendar.') }).strict();
 export async function listEvents(repo: ContentRepository, url: URL) {
   requireCalendar();
   const q = eventsQuery.parse(queryParams(url, FILTER_LISTS));
@@ -65,7 +65,9 @@ export async function listEvents(repo: ContentRepository, url: URL) {
   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))
+  // q continues /search, so it finds what search finds (unlisted calendars too, no booking-page appointments)
+  const shown = (e: CalEvent) => (term ? eventIsSearchable(e, all) : picked ? eventIsPublic(e, all) : eventIsListed(e, all));
+  const visible = events.map(e => localizeDoc(e, locale ?? undefined)).filter(e => (!picked || e.calendarIds.some(id => picked.includes(id))) && shown(e)
     && 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 })
@@ -78,7 +80,7 @@ export async function listEvents(repo: ContentRepository, url: URL) {
     locale, timezone: settings.timezone || 'UTC', from: new Date(from).toISOString(), to: new Date(to).toISOString(),
     occurrences: occurrences.slice(start, start + q.limit).map(o => ({
       ...occurrenceDto(o, resources, locale || siteLang(settings)),
-      event: publicEventDto(o.event, origin, publicCalendars, settings, locale, resources),
+      event: publicEventDto(o.event, origin, publicCalendars, all, settings, locale, resources),
     })),
     pagination: { page: q.page, limit: q.limit, nextPage: occurrences.length > start + q.limit ? q.page + 1 : null },
   };
@@ -102,7 +104,7 @@ export async function getEventDetail(repo: ContentRepository, url: URL, ref: str
   return {
     locale,
     occurrence: o ? occurrenceDto(o, resources, locale || siteLang(settings)) : null,
-    event: publicEventDto(e, siteOrigin(settings, url), publicCalendars, settings, locale, resources),
+    event: publicEventDto(e, siteOrigin(settings, url), publicCalendars, all, settings, locale, resources),
   };
 }
 /** every room by id, for naming the public ones (Resource.showOnEvents) */
@@ -116,8 +118,9 @@ export function occurrenceDto(o: Occurrence, resources: Map<string, Resource>, l
     location: o.location ? { name: o.location.name, address: o.location.address, url: o.location.url } : null,
     rooms: roomsToJson(o.roomIds, resources, false, locale) };
 }
-// e is already localized; publicCalendars limits which calendars are named
-export function publicEventDto(e: CalEvent, origin: string, publicCalendars: Map<string, Calendar>, settings: Settings, locale: string | null, resources?: Map<string, Resource>) {
+// e is already localized; publicCalendars limits which calendars are named,
+// `all` holds every calendar (their visibility decides which changes notify)
+export function publicEventDto(e: CalEvent, origin: string, publicCalendars: Map<string, Calendar>, all: Map<string, Calendar>, settings: Settings, locale: string | null, resources?: Map<string, Resource>) {
   // the repeat line in the request's language, else the site's main one
   const event = eventToJson(e, origin, publicCalendars, settings.timezone, { resources, locale: locale || siteLang(settings) });
   event.url = localizedUrl(event.url, origin, locale);
@@ -126,7 +129,7 @@ export function publicEventDto(e: CalEvent, origin: string, publicCalendars: Map
   event.image = safeUrl(e.cover, origin);
   event.cta = { ...event.cta, href: localizedUrl(safeUrl(event.cta.href, origin, true), origin, locale) };
   // which push topics hear about date, time or place changes ([] = none do)
-  return { ...event, notify: { changes: changeTopics(e, settings, publicCalendars) } };
+  return { ...event, notify: { changes: changeTopics(e, settings, all) } };
 }
 export async function listResources(repo: ContentRepository, url: URL) {
   requireCalendar(true);

package/src/lib/mobile/search.ts

@@ -6,7 +6,7 @@ import { siteOrigin } from '../seo';
 import { siteLang } from '../dates';
 import { SEARCH } from '../search-config';
 import { CALENDAR } from '../calendar/config';
-import { eventIsListed, featuredOccurrence } from '../calendar/events';
+import { eventIsSearchable, featuredOccurrence } from '../calendar/events';
 import { localizeDoc } from '../translations';
 import { ApiError } from '../api';
 import { contentDto } from './content';
@@ -68,12 +68,13 @@ export async function search(repo: ContentRepository, url: URL) {
   const pages = want.has('page') && !q.collection ? found.pages : [];
   const all = new Map(calendars.map((c) => [c.id, c]));
   const listed = new Map(calendars.filter((c) => c.visibility === 'public').map((c) => [c.id, c]));
-  let events = want.has('event') && CALENDAR.enabled && !q.collection ? found.events.filter(({ doc }) => eventIsListed(doc, all)) : [];
-  // the index ranks before visibility is known: if unlisted events filled the
-  // first batch, look deeper once (the repo's 200-row cap) for listed ones
+  // the website's rule: any calendar that isn't private, no booking-page appointments
+  let events = want.has('event') && CALENDAR.enabled && !q.collection ? found.events.filter(({ doc }) => eventIsSearchable(doc, all)) : [];
+  // the index ranks before visibility is known: if private events or bookings
+  // filled the first batch, look deeper once (the repo's 200-row cap)
   if (want.has('event') && CALENDAR.enabled && !q.collection && events.length <= q.limit && found.events.length >= q.limit + 1) {
     const deeper = await repo.searchPublished(q.q, { locale: normalizePageLocale(locale ?? ''), limit: 200, collections: [] });
-    events = deeper.events.filter(({ doc }) => eventIsListed(doc, all));
+    events = deeper.events.filter(({ doc }) => eventIsSearchable(doc, all));
   }
   const now = Date.now();
   return {
@@ -87,7 +88,7 @@ export async function search(repo: ContentRepository, url: URL) {
         snippet: plainSnippet(snippet),
         // the next occurrence, or the latest one when the event is over
         occurrence: o ? (({ id: _, ...rest }) => rest)(occurrenceDto(o, resources, locale || siteLang(settings))) : null,
-        event: publicEventDto(e, origin, listed, settings, locale, resources),
+        event: publicEventDto(e, origin, listed, all, settings, locale, resources),
       };
     }),
     more: { posts: posts.length > q.limit, pages: pages.length > q.limit, events: events.length > q.limit },

package/src/lib/push/api.ts

@@ -136,7 +136,8 @@ export async function adminPushState(repo: ContentRepository, url: URL, locals?:
     calendarEnabled: CALENDAR.enabled,
     // "we're live" needs live video on (Integrations → Live video)
     liveMode: settings.live.mode,
-    calendars: calendars.filter((c) => c.visibility === 'public').map((c) => ({ id: c.id, slug: c.slug, name: c.name, color: c.color })),
+    // a rule can name an unlisted calendar too (a catch-all covers only public ones)
+    calendars: calendars.filter((c) => c.visibility !== 'private').map((c) => ({ id: c.id, slug: c.slug, name: c.name, color: c.color, visibility: c.visibility })),
     // suggestions for the event-change rule's "Only events tagged"
     tags: tags.map((t) => t.name),
     expo: { accessToken: Boolean(expo.accessToken), customEndpoint: expo.base !== EXPO_PUSH_BASE },
@@ -182,7 +183,8 @@ export async function adminPushAction(repo: ContentRepository, input: z.infer<ty
     }
     case 'saveAuto': {
       const collections = new Set(Object.keys(CONTENT.collections));
-      const calendars = new Set((CALENDAR.enabled ? await repo.listCalendars() : []).filter((c) => c.visibility === 'public').map((c) => c.id));
+      // private calendars never notify: a rule can't name one
+      const calendars = new Set((CALENDAR.enabled ? await repo.listCalendars() : []).filter((c) => c.visibility !== 'private').map((c) => c.id));
       const cals = (ids: string[]) => [...new Set(ids)].filter((id) => id === '*' || calendars.has(id));
       const known = await knownTopics(repo);
       const auto = {

package/src/lib/push/service.ts

@@ -5,7 +5,7 @@ import type { ContentRepository } from '../repo/types';
 import type { CalEvent, Calendar, Post, Settings } from '../schema';
 import { CONTENT, collectionUrl } from '../content';
 import { CALENDAR, eventUrl } from '../calendar/config';
-import { cutsAt, eventIsListed, eventTimeZone, expandEvents, findOccurrence, partOf, type Occurrence } from '../calendar/events';
+import { cutsAt, eventIsListed, eventIsPublic, eventTimeZone, expandEvents, findOccurrence, isGoogleBooking, partOf, type Occurrence } from '../calendar/events';
 import { describeRepeat } from '../calendar/rrule';
 import { tzParts } from '../calendar/ics';
 import { I18N, stripLocale } from '../i18n';
@@ -236,22 +236,32 @@ export async function sendNotification(repo: ContentRepository, input: SendInput
 
 // ---- automatic notices ---------------------------------------------------------
 
-const listedCalendars = (calendars: Calendar[]) => new Map(calendars.map((c) => [c.id, c]));
-const inRule = (rule: string[], e: CalEvent) => rule.includes('*') || e.calendarIds.some((id) => rule.includes(id));
-// a change rule: its calendars, and one of its tags when it lists some (any case)
-function inChangeRule(rule: ChangeRule, e: CalEvent) {
-  const tags = new Set(rule.tags.map((t) => t.toLowerCase()));
-  return inRule(rule.calendars, e) && (!tags.size || e.tags.some((t) => tags.has(t.toLowerCase())));
+const calendarMap = (calendars: Calendar[]) => new Map(calendars.map((c) => [c.id, c]));
+// Whether a rule (new event, starting soon, or a change rule) covers a
+// published event: one in its calendars ('*' = any) with, for a change rule
+// that lists tags, one of them (any case). A rule that names the event (one of
+// its calendars, or tags it has) covers it in any calendar that isn't private,
+// so a "Class" rule reaches classes in an unlisted rooms calendar; a catch-all
+// ('*' and no tags) stays with public calendars. Private calendars and Google
+// booking-page appointments never notify.
+function covers(rule: { calendars: string[]; tags?: string[] }, e: CalEvent, calendars: Map<string, Calendar>) {
+  const tags = new Set((rule.tags ?? []).map((t) => t.toLowerCase()));
+  const named = e.calendarIds.some((id) => rule.calendars.includes(id));
+  if (!named && !rule.calendars.includes('*')) return false;
+  if (tags.size && !e.tags.some((t) => tags.has(t.toLowerCase()))) return false;
+  if (isGoogleBooking(e)) return false;
+  return named || tags.size ? eventIsPublic(e, calendars) : eventIsListed(e, calendars);
 }
 // every rule that covers the event adds its topics, or the event's own when it
 // names none: in rule order, once each ([] = no rule covers it)
 function changeAudience(rules: ChangeRule[], e: CalEvent, calendars: Map<string, Calendar>) {
-  return [...new Set(rules.filter((r) => inChangeRule(r, e)).flatMap((r) => (r.topics.length ? r.topics : eventTopics(e, calendars))))];
+  return [...new Set(rules.filter((r) => covers(r, e, calendars)).flatMap((r) => (r.topics.length ? r.topics : eventTopics(e, calendars))))];
 }
 /**
  * The topics this event's change notices go to (Admin → Mobile app → When an
  * event changes), or [] while no rule covers it. Apps show it to promise
- * "we'll let you know if it changes" only when it's true.
+ * "we'll let you know if it changes" only when it's true. `calendars` holds
+ * every calendar (their visibility decides what notifies), not only public ones.
  */
 export function changeTopics(e: CalEvent, settings: Settings, calendars: Map<string, Calendar>): string[] {
   if (!PUSH.enabled || !CALENDAR.enabled) return [];
@@ -409,7 +419,8 @@ export async function queueEventChange(repo: ContentRepository, before: CalEvent
   const was = eventSnapshot(before);
   if (JSON.stringify(was) === JSON.stringify(eventSnapshot(after))) return false;
   const [settings, all] = await Promise.all([repo.getSettings(), repo.listCalendars()]);
-  if (!settings.push.auto.eventChanges.some((r) => inChangeRule(r, after)) || !eventIsListed(after, listedCalendars(all))) return false;
+  const calendars = calendarMap(all);
+  if (!settings.push.auto.eventChanges.some((r) => covers(r, after, calendars))) return false;
   const key = `change:${after.id}`;
   // a change to a date that starts soon waits only a minute (judged from what people last knew)
   const row = await repo.push.queuedChange(key);
@@ -506,7 +517,7 @@ export async function processPushQueue(repo: ContentRepository, opts: PushRunOpt
   if (!rows.length) return 0;
   const settings = await repo.getSettings();
   const auto = settings.push.auto;
-  const calendars = CALENDAR.enabled ? listedCalendars(await repo.listCalendars()) : new Map<string, Calendar>();
+  const calendars = CALENDAR.enabled ? calendarMap(await repo.listCalendars()) : new Map<string, Calendar>();
   const run = { ...opts, now, origin: opts.origin ?? siteOriginOf(settings, opts.fallbackOrigin) };
   let sent = 0;
   for (const row of rows) {
@@ -517,14 +528,14 @@ export async function processPushQueue(repo: ContentRepository, opts: PushRunOpt
         if (post && post.status === 'published' && CONTENT.collections[post.collection] && auto.newPost.collections.includes(post.collection)) notice = postNotice(post, settings);
       } else if (row.kind === 'event' && CALENDAR.enabled) {
         const e = await repo.getEvent(row.docId);
-        if (e && !e.cancelled && eventIsListed(e, calendars) && inRule(auto.newEvent.calendars, e)) notice = eventNotice(e, settings, calendars, now);
+        if (e && !e.cancelled && covers(auto.newEvent, e, calendars)) notice = eventNotice(e, settings, calendars, now);
       } else if (row.kind === 'change' && CALENDAR.enabled) {
         // compared at send time: edits that cancel out, or come too late, send nothing
         const e = await repo.getEvent(row.docId);
         const was = readSnapshot(row.payload);
         // one notice, to everyone the rules that cover it send to
         const topics = e ? changeAudience(auto.eventChanges, e, calendars) : [];
-        const change = e && was && topics.length && eventIsListed(e, calendars) ? eventChange(was, e, settings, now) : null;
+        const change = e && was && topics.length ? eventChange(was, e, settings, now) : null;
         if (e && change && !(await announcedLately(repo, e, run.origin, now))) notice = eventChangeNotice(e, change, settings, calendars, topics);
       }
       if (!notice) { await repo.push.markQueue(row.key, 'skipped', null, now); continue; }
@@ -547,8 +558,8 @@ export async function sendStartingSoon(repo: ContentRepository, opts: PushRunOpt
   const rule = settings.push.auto.startingSoon;
   if (!rule.calendars.length) return 0;
   const [all, events] = await Promise.all([repo.listCalendars(), repo.listPublishedEvents()]);
-  const calendars = listedCalendars(all);
-  const chosen = events.filter((e) => !e.cancelled && eventIsListed(e, calendars) && inRule(rule.calendars, e));
+  const calendars = calendarMap(all);
+  const chosen = events.filter((e) => !e.cancelled && covers(rule, e, calendars));
   if (!chosen.length) return 0;
   const lead = rule.minutes * MINUTE;
   const occurrences = expandEvents(chosen, settings, { displayTz: settings.timezone || 'UTC', now, windowStartMs: now, windowEndMs: now + lead + 1 })

package/src/lib/schema.ts

@@ -288,7 +288,8 @@ export type Redirect = z.infer<typeof Redirect>;
 // admin; `feed` calendars mirror an external ICS feed (Google, Apple,
 // Outlook, any .ics) live, read-only. Visibility decides where a calendar's
 // events surface: `public` = listed on the calendar page + the all-calendars
-// feed; `unlisted` = event pages and its own feed work, but it's not listed;
+// feed; `unlisted` = event pages, its own feed and search work, but it's not
+// listed (push rules cover its events only when they name them);
 // `private` = admin-only, plus a secret-token feed for staff subscriptions.
 export const CalendarKind = z.enum(['native', 'feed']);
 export type CalendarKind = z.infer<typeof CalendarKind>;

package/src/pages/api/search.ts

@@ -6,7 +6,7 @@ import { collectionUrl, tagUrl } from '../../lib/content';
 import { localeHomeUrl, normalizePageLocale } from '../../lib/i18n';
 import { formatDate, siteLocale } from '../../lib/dates';
 import { CALENDAR, eventUrl } from '../../lib/calendar/config';
-import { eventIsPublic, featuredOccurrence, formatOccurrence } from '../../lib/calendar/events';
+import { eventIsSearchable, featuredOccurrence, formatOccurrence } from '../../lib/calendar/events';
 
 // Public search API behind the site's search modal. Published-only by
 // construction — the same contract as rss/sitemap — so it needs no auth and
@@ -42,8 +42,8 @@ export const GET: APIRoute = async ({ locals, url }) => {
       snippet,
       locale: p.locale,
     })),
-    // private-calendar events never surface publicly
-    events: (CALENDAR.enabled ? results.events.filter(({ doc }) => eventIsPublic(doc, calMap)) : []).slice(0, LIMITS.events).map(({ doc: e, snippet }) => {
+    // the app's rule too: never private calendars or booking-page appointments
+    events: (CALENDAR.enabled ? results.events.filter(({ doc }) => eventIsSearchable(doc, calMap)) : []).slice(0, LIMITS.events).map(({ doc: e, snippet }) => {
       const o = featuredOccurrence(e, settings, now);
       return {
         title: e.title,

package/src/pages/search.astro

@@ -7,7 +7,7 @@ import { authorSlug } from '../lib/schema';
 import { I18N, localeFromPath, localeHomeUrl, normalizePageLocale } from '../lib/i18n';
 import { searchStrings } from '../lib/search-i18n';
 import { CALENDAR, eventUrl } from '../lib/calendar/config';
-import { eventIsPublic, featuredOccurrence, formatOccurrence } from '../lib/calendar/events';
+import { eventIsSearchable, featuredOccurrence, formatOccurrence } from '../lib/calendar/events';
 import { siteLocale } from '../lib/dates';
 
 // The no-JS search surface (the modal's form falls back here). Serves both
@@ -25,7 +25,7 @@ const results = q
   ? await repo.searchPublished(q, { locale })
   : { posts: [], pages: [], events: [], tags: [], authors: [] };
 const calMap = new Map((await repo.listCalendars()).map((c) => [c.id, c]));
-const events = CALENDAR.enabled ? results.events.filter(({ doc }) => eventIsPublic(doc, calMap)).slice(0, 10) : [];
+const events = CALENDAR.enabled ? results.events.filter(({ doc }) => eventIsSearchable(doc, calMap)).slice(0, 10) : [];
 const total = results.posts.length + results.pages.length + events.length + results.tags.length + results.authors.length;
 ---