@acms-subir/core 0.3.3-next.20260929113209 → 0.3.4

package/src/actions/index.ts

@@ -7,7 +7,7 @@ import type { ActionAPIContext } from 'astro:actions';
 import { getRepo } from '../lib/repo';
 import { getMediaStore } from '../lib/media/store';
 import { validateSession, SESSION_COOKIE } from '../lib/auth';
-import { LinkKind, parseConfig, slugify, widgetTypes, type WidgetType } from '../lib/schema';
+import { DocTranslations, LinkKind, parseConfig, slugify, widgetTypes, type WidgetType } from '../lib/schema';
 import { env } from '../lib/env';
 import { CONTENT, collectionUrl } from '../lib/content';
 import { invalidateRedirectCache } from '../middleware';
@@ -16,20 +16,26 @@ import { normalizeCalendarSrc } from '../lib/calendar/src';
 import { getCalendarEvents } from '../lib/calendar/ics';
 import { siteLocale } from '../lib/dates';
 import { normalizePageLocale, localeHomeUrl } from '../lib/i18n';
-import { CALENDAR } from '../lib/calendar/config';
+import { CALENDAR, bookingsEnabled } from '../lib/calendar/config';
+import { holdConflicts } from '../lib/booking/holds';
+import { setBookingStatus } from '../lib/booking/service';
 import { eventTimeZone, featuredOccurrence, formatOccurrence, isValidTimeZone, normalizeEventTimes, safeColor } from '../lib/calendar/events';
 import { eventsFromCsv, eventsFromIcs, eventsFromVEvents } from '../lib/calendar/import';
 import { loadFeed } from '../lib/calendar/ics';
 import { NATIVE_ALL } from '../lib/calendar/render';
 import { collectViewEvents } from '../lib/calendar/data';
+import { loadBoard } from '../lib/calendar/board';
+import { duplicateEvent, moveOccurrence, moveSeries, quickCreate, undoMove } from '../lib/calendar/schedule';
 import { waitUntilFrom } from '../lib/webhooks';
 import { eventChanged, eventDeleted } from '../lib/calendar/hooks';
 import { siteOrigin } from '../lib/seo';
 import type { CalEvent } from '../lib/schema';
+import { CalEvent as CalEventSchema } from '../lib/schema';
 import { diffDesign, revertDesignChange, summarizeChanges } from '../lib/designDiff';
 import { shareEpoch } from '../lib/drafts';
 import { createDesignToken } from '../lib/preview';
 import { getTheme } from '../lib/theme';
+import { savePost, applyPostUpdate, savePage, applyPageUpdate, saveEvent, applyEventUpdate, type SaveHooks } from '../lib/content-service';
 
 // "What changes" for the Design screen: the staged draft vs the live design
 async function designChanges(repo: Awaited<ReturnType<typeof getRepo>>) {
@@ -65,79 +71,16 @@ const BlockInput = z.object({
 
 // ---- calendar helpers ------------------------------------------------------
 
-type EventSaveInput = Partial<Omit<CalEvent, 'id' | 'draft' | 'startAt' | 'endAt' | 'createdAt' | 'updatedAt' | 'sourceUid' | 'publishedAt'>>;
-
-// Validate + normalize an event save. Times are checked as a PAIR against the
-// merged (staged) state so a half-edited range can't slip through.
-async function cleanEventInput(repo: Awaited<ReturnType<typeof getRepo>>, data: EventSaveInput, before: CalEvent): Promise<EventSaveInput> {
-  const out: EventSaveInput = { ...data };
-  if (out.slug !== undefined) {
-    const base = slugify(out.slug || out.title || before.title);
-    let slug = base;
-    for (let n = 2; ; n++) {
-      const clash = await repo.getEventBySlug(slug);
-      if (!clash || clash.id === before.id) break;
-      slug = `${base}-${n}`;
-    }
-    out.slug = slug;
-  }
-  if (out.timezone !== undefined && out.timezone !== '' && !isValidTimeZone(out.timezone)) {
-    throw new ActionError({ code: 'BAD_REQUEST', message: `“${out.timezone}” isn’t a timezone we recognize.` });
-  }
-  if (out.start !== undefined || out.end !== undefined || out.allDay !== undefined) {
-    const merged = before.draft ? { ...before, ...(before.draft as Partial<CalEvent>) } : before;
-    try {
-      const t = normalizeEventTimes({ start: out.start ?? merged.start, end: out.end ?? merged.end, allDay: out.allDay ?? merged.allDay });
-      out.start = t.start;
-      out.end = t.end;
-    } catch (err) {
-      throw new ActionError({ code: 'BAD_REQUEST', message: err instanceof Error ? err.message : 'Invalid time.' });
-    }
-  }
-  if (out.calendarIds !== undefined) {
-    const known = new Set((await repo.listCalendars()).filter((c) => c.kind === 'native').map((c) => c.id));
-    out.calendarIds = [...new Set(out.calendarIds.filter((c) => known.has(c)))];
-  }
-  if (out.fields !== undefined) {
-    const allowed = new Map(CALENDAR.eventFields.map((f) => [f.key, f]));
-    out.fields = Object.fromEntries(
-      Object.entries(out.fields)
-        .filter(([k, v]) => allowed.has(k) && v !== '')
-        .filter(([k, v]) => allowed.get(k)!.type !== 'select' || allowed.get(k)!.options.includes(v))
-    );
+// Save/Update logic is shared with the editor-app API (lib/content-service).
+// Its ApiErrors become ActionErrors with the same message.
+function asActionError(error: unknown): never {
+  if (error instanceof ApiError) {
+    const code = error.status === 404 ? 'NOT_FOUND' : error.status === 403 ? 'FORBIDDEN' : error.status === 409 ? 'CONFLICT' : error.status === 401 ? 'UNAUTHORIZED' : 'BAD_REQUEST';
+    throw new ActionError({ code, message: error.message });
   }
-  if (out.cta !== undefined) {
-    const href = out.cta.href.trim();
-    if (href && !/^(https?:\/\/|\/(?!\/)|mailto:|tel:|#)/i.test(href)) {
-      throw new ActionError({ code: 'BAD_REQUEST', message: 'The button link must start with https://, /, mailto:, or tel:.' });
-    }
-    out.cta = { ...out.cta, href };
-  }
-  if (out.location?.url) {
-    if (!/^https?:\/\//i.test(out.location.url.trim())) {
-      throw new ActionError({ code: 'BAD_REQUEST', message: 'The map or meeting link must start with https://.' });
-    }
-  }
-  if (out.tags !== undefined) out.tags = [...new Set(out.tags.map((t) => t.trim()).filter(Boolean))];
-  if (out.status === 'scheduled' && !(out.scheduledAt && out.scheduledAt > Date.now())) {
-    throw new ActionError({ code: 'BAD_REQUEST', message: 'Pick a future publish time to schedule.' });
-  }
-  if (out.status === 'published') out.scheduledAt = null;
-  return out;
-}
-
-async function eventSideEffects(
-  repo: Awaited<ReturnType<typeof getRepo>>,
-  ctx: ActionAPIContext,
-  before: CalEvent,
-  after: CalEvent,
-  applied = false
-) {
-  const settings = await repo.getSettings();
-  await eventChanged(repo, before, after, {
-    origin: siteOrigin(settings, ctx.url), waitUntil: waitUntilFrom(ctx.locals), applied, onRedirect: invalidateRedirectCache,
-  });
+  throw error;
 }
+const hooksFor = (ctx: ActionAPIContext): SaveHooks => ({ url: ctx.url, locals: ctx.locals, onRedirect: invalidateRedirectCache });
 
 async function importEvents(
   repo: Awaited<ReturnType<typeof getRepo>>,
@@ -178,6 +121,7 @@ export const server = {
         coverAlt: z.string().optional(),
         seoTitle: z.string().optional(),
         seoDesc: z.string().optional(),
+        translations: DocTranslations.optional(),
         status: StatusInput.optional(),
         featured: z.boolean().optional(),
         authorId: z.string().nullable().optional(),
@@ -189,38 +133,7 @@ export const server = {
       handler: async ({ id, ...data }, ctx) => {
         await requireAdmin(ctx);
         const repo = await getRepo(ctx.locals);
-        if (data.slug !== undefined) data.slug = slugify(data.slug);
-        if (data.collection !== undefined && !CONTENT.collections[data.collection]) {
-          throw new ActionError({ code: 'BAD_REQUEST', message: `Unknown collection "${data.collection}".` });
-        }
-        const before = await repo.getPost(id);
-        if (!before) throw new ActionError({ code: 'NOT_FOUND', message: 'Post not found.' });
-        // A live (published/scheduled) post never takes content edits
-        // directly: they stage into the pending draft until the user hits
-        // Update. Status transitions stay deliberate, immediate writes.
-        const transitions = data.status !== undefined && data.status !== before.status;
-        if ((before.status === 'published' || before.status === 'scheduled') && !transitions) {
-          const { status: _status, scheduledAt: _scheduledAt, authorId: _authorId, ...staged } = data;
-          await repo.savePostDraft(id, staged);
-          return { post: (await repo.getPost(id))! };
-        }
-        await repo.updatePost(id, data);
-        // any new tag names become registry entries with slugs for archives
-        if (data.tags !== undefined) await repo.ensureTags(data.tags);
-        const post = await repo.getPost(id);
-        if (!post) throw new ActionError({ code: 'NOT_FOUND', message: 'Post not found.' });
-        // a published post whose slug or collection changed leaves a 301
-        // behind so old links keep working
-        if (before.status === 'published' && (before.slug !== post.slug || before.collection !== post.collection)) {
-          await repo
-            .createRedirect({
-              fromPath: collectionUrl(before.collection, before.slug),
-              toPath: collectionUrl(post.collection, post.slug),
-            })
-            .catch(() => {});
-          invalidateRedirectCache();
-        }
-        return { post };
+        try { return { post: await savePost(repo, id, data, hooksFor(ctx)) }; } catch (e) { asActionError(e); }
       },
     }),
     // Update button: copy the pending draft onto the live columns. The
@@ -231,21 +144,7 @@ export const server = {
       handler: async ({ id }, ctx) => {
         await requireAdmin(ctx);
         const repo = await getRepo(ctx.locals);
-        const before = await repo.getPost(id);
-        if (!before) throw new ActionError({ code: 'NOT_FOUND', message: 'Post not found.' });
-        await repo.applyPostDraft(id);
-        const post = (await repo.getPost(id))!;
-        if (post.tags.length) await repo.ensureTags(post.tags);
-        if (before.status === 'published' && (before.slug !== post.slug || before.collection !== post.collection)) {
-          await repo
-            .createRedirect({
-              fromPath: collectionUrl(before.collection, before.slug),
-              toPath: collectionUrl(post.collection, post.slug),
-            })
-            .catch(() => {});
-          invalidateRedirectCache();
-        }
-        return { post };
+        try { return { post: await applyPostUpdate(repo, id, hooksFor(ctx)) }; } catch (e) { asActionError(e); }
       },
     }),
     discardChanges: defineAction({
@@ -281,6 +180,7 @@ export const server = {
         locale: z.string().optional(),
         seoTitle: z.string().optional(),
         seoDesc: z.string().optional(),
+        translations: DocTranslations.optional(),
         template: z.string().optional(),
         bodyJson: z.string().optional(),
         bodyHtml: z.string().optional(),
@@ -289,33 +189,13 @@ export const server = {
       handler: async ({ id, blocks, ...data }, ctx) => {
         await requireAdmin(ctx);
         const repo = await getRepo(ctx.locals);
-        if (data.slug !== undefined) data.slug = slugify(data.slug);
-        // default locale stores as '', unknown codes fall back to it
-        if (data.locale !== undefined) data.locale = normalizePageLocale(data.locale);
-        const before = await repo.getPage(id);
-        if (!before) throw new ActionError({ code: 'NOT_FOUND', message: 'Page not found.' });
         const cleanBlocks =
           blocks === undefined
             ? undefined
             : blocks
                 .filter((b) => widgetTypes.includes(b.type as WidgetType))
                 .map((b) => ({ ...b, type: b.type as WidgetType, config: parseConfig(b.type as WidgetType, b.config) as Record<string, unknown> }));
-        // live pages stage their edits until Update, same as posts
-        const transitions = data.status !== undefined && data.status !== before.status;
-        if ((before.status === 'published' || before.status === 'scheduled') && !transitions) {
-          const { status: _status, ...staged } = data;
-          await repo.savePageDraft(id, { ...staged, blocks: cleanBlocks });
-          return { page: (await repo.getPage(id))! };
-        }
-        await repo.updatePage(id, { ...data, blocks: cleanBlocks });
-        const page = await repo.getPage(id);
-        if (!page) throw new ActionError({ code: 'NOT_FOUND', message: 'Page not found.' });
-        // renaming a published slug leaves a 301 behind so old links keep working
-        if (before.status === 'published' && before.slug !== page.slug && !page.isHome) {
-          await repo.createRedirect({ fromPath: `/${before.slug}`, toPath: `/${page.slug}` }).catch(() => {});
-          invalidateRedirectCache();
-        }
-        return { page };
+        try { return { page: await savePage(repo, id, data, cleanBlocks, hooksFor(ctx)) }; } catch (e) { asActionError(e); }
       },
     }),
     applyUpdate: defineAction({
@@ -323,15 +203,7 @@ export const server = {
       handler: async ({ id }, ctx) => {
         await requireAdmin(ctx);
         const repo = await getRepo(ctx.locals);
-        const before = await repo.getPage(id);
-        if (!before) throw new ActionError({ code: 'NOT_FOUND', message: 'Page not found.' });
-        await repo.applyPageDraft(id);
-        const page = (await repo.getPage(id))!;
-        if (before.status === 'published' && before.slug !== page.slug && !page.isHome) {
-          await repo.createRedirect({ fromPath: `/${before.slug}`, toPath: `/${page.slug}` }).catch(() => {});
-          invalidateRedirectCache();
-        }
-        return { page };
+        try { return { page: await applyPageUpdate(repo, id, hooksFor(ctx)) }; } catch (e) { asActionError(e); }
       },
     }),
     discardChanges: defineAction({
@@ -524,11 +396,15 @@ export const server = {
         siteLogo: z.string().optional(),
         siteFavicon: z.string().optional(),
         siteCover: z.string().optional(),
-      }),
+        // IANA zone ('' = UTC) and BCP 47 locale ('' = en-US), same rules as Settings → General
+        timezone: z.string().max(100).refine((tz) => tz === '' || isValidTimeZone(tz), { message: 'Use an IANA timezone like America/New_York.' }).optional(),
+        locale: z.string().max(40).refine((l) => { if (l === '') return true; try { return Intl.getCanonicalLocales(l).length === 1; } catch { return false; } }, { message: 'Use a language tag like en-US or es.' }).optional(),
+      // unknown keys are an error, not silently dropped
+      }).strict(),
       handler: async (data, ctx) => {
         await requireAdmin(ctx);
         const repo = await getRepo(ctx.locals);
-        await repo.updateSettings(data);
+        await repo.updateSettings({ ...data, ...(data.locale ? { locale: Intl.getCanonicalLocales(data.locale)[0] } : {}) });
         return { ok: true };
       },
     }),
@@ -930,6 +806,54 @@ export const server = {
         return { sources: normalized, upcoming, total: events.length, labels };
       },
     }),
+    // Schedule (admin month/week grid): every occurrence between two days
+    range: defineAction({
+      input: z.object({ from: z.string().regex(/^\d{4}-\d{2}-\d{2}$/), to: z.string().regex(/^\d{4}-\d{2}-\d{2}$/) }),
+      handler: async ({ from, to }, ctx) => {
+        await requireAdmin(ctx);
+        const repo = await getRepo(ctx.locals);
+        try { return await loadBoard(repo, await repo.getSettings(), from, to); }
+        catch (e) { throw new ActionError({ code: 'BAD_REQUEST', message: e instanceof Error ? e.message : 'Couldn’t load the calendar.' }); }
+      },
+    }),
+    // Calendar settings → Defaults / Bookings
+    saveSettings: defineAction({
+      input: z.object({
+        weekStart: z.union([z.literal(0), z.literal(1)]).optional(),
+        defaultCalendarId: z.string().max(100).optional(),
+        showBookings: z.boolean().optional(),
+        approval: z.enum(['auto', 'rules', 'manual']).optional(),
+        approvalRules: z.object({
+          longerThan: z.number().int().min(0).max(60 * 24 * 60),
+          firstTime: z.boolean(),
+          moreSeats: z.number().int().min(0).max(100000),
+          deadlineHours: z.number().int().min(0).max(24 * 60),
+          deadlineAction: z.enum(['approve', 'decline']),
+        }).optional(),
+        // reset every booking link to "use the site default"
+        applyToLinks: z.boolean().optional(),
+      }),
+      handler: async ({ applyToLinks, ...patch }, ctx) => {
+        await requireAdmin(ctx);
+        const repo = await getRepo(ctx.locals);
+        const settings = await repo.getSettings();
+        if (patch.defaultCalendarId) {
+          const cal = await repo.getCalendar(patch.defaultCalendarId);
+          if (!cal || cal.kind !== 'native') throw new ActionError({ code: 'BAD_REQUEST', message: 'Pick one of your calendars.' });
+        }
+        const calendar = { ...settings.calendar, ...Object.fromEntries(Object.entries(patch).filter(([, v]) => v !== undefined)) };
+        await repo.updateSettings({ calendar });
+        let updated = 0;
+        if (applyToLinks) {
+          for (const l of await repo.listBookingLinks()) {
+            if (l.approval === 'default') continue;
+            await repo.updateBookingLink(l.id, { approval: 'default' });
+            updated++;
+          }
+        }
+        return { calendar: (await repo.getSettings()).calendar, updated };
+      },
+    }),
   },
 
   events: {
@@ -946,6 +870,7 @@ export const server = {
         coverAlt: z.string().optional(),
         seoTitle: z.string().optional(),
         seoDesc: z.string().optional(),
+        translations: DocTranslations.optional(),
         status: StatusInput.optional(),
         featured: z.boolean().optional(),
         template: z.string().optional(),
@@ -961,26 +886,13 @@ export const server = {
         calendarIds: z.array(z.string()).max(50).optional(),
         fields: z.record(z.string().max(2000)).optional(),
         rsvp: z.object({ enabled: z.boolean(), capacity: z.number().int().min(0).max(100000), autoConfirm: z.boolean(), maxSeats: z.number().int().min(1).max(50) }).optional(),
+        roomHold: z.object({ resourceIds: z.array(z.string()).max(50), span: z.enum(['event', 'day']), before: z.number().int().min(0).max(1440), after: z.number().int().min(0).max(1440), whileDraft: z.boolean(), keep: z.array(z.string()).max(500).default([]) }).optional(),
         scheduledAt: nullableTs.optional(),
       }),
       handler: async ({ id, ...data }, ctx) => {
         await requireAdmin(ctx);
         const repo = await getRepo(ctx.locals);
-        const before = await repo.getEvent(id);
-        if (!before) throw new ActionError({ code: 'NOT_FOUND', message: 'Event not found.' });
-        const clean = await cleanEventInput(repo, data, before);
-        // live events stage edits until Update, exactly like posts
-        const transitions = clean.status !== undefined && clean.status !== before.status;
-        if ((before.status === 'published' || before.status === 'scheduled') && !transitions) {
-          const { status: _s, scheduledAt: _sa, ...staged } = clean;
-          await repo.saveEventDraft(id, staged);
-          return { event: (await repo.getEvent(id))! };
-        }
-        await repo.updateEvent(id, clean);
-        if (clean.tags !== undefined) await repo.ensureTags(clean.tags);
-        const event = (await repo.getEvent(id))!;
-        await eventSideEffects(repo, ctx, before, event);
-        return { event };
+        try { return { event: await saveEvent(repo, id, data, hooksFor(ctx)) }; } catch (e) { asActionError(e); }
       },
     }),
     applyUpdate: defineAction({
@@ -988,13 +900,7 @@ export const server = {
       handler: async ({ id }, ctx) => {
         await requireAdmin(ctx);
         const repo = await getRepo(ctx.locals);
-        const before = await repo.getEvent(id);
-        if (!before) throw new ActionError({ code: 'NOT_FOUND', message: 'Event not found.' });
-        await repo.applyEventDraft(id);
-        const event = (await repo.getEvent(id))!;
-        if (event.tags.length) await repo.ensureTags(event.tags);
-        await eventSideEffects(repo, ctx, before, event, true);
-        return { event };
+        try { return { event: await applyEventUpdate(repo, id, hooksFor(ctx)) }; } catch (e) { asActionError(e); }
       },
     }),
     discardChanges: defineAction({
@@ -1017,6 +923,131 @@ export const server = {
         return { ok: true };
       },
     }),
+    // Event editor → Rooms: which rooms/people are free at this event's time
+    // (for every room, so the picker can label them), and which existing
+    // bookings the selected rooms would overlap. Works on unsaved values.
+    roomStatus: defineAction({
+      input: z.object({
+        eventId: z.string().default(''),
+        title: z.string().max(300).default(''),
+        start: z.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2})?$/),
+        end: z.string().max(20).default(''),
+        allDay: z.boolean(),
+        timezone: z.string().max(100).default(''),
+        rrule: z.string().max(500).default(''),
+        exdates: z.array(z.string()).max(500).default([]),
+        roomHold: z.object({ resourceIds: z.array(z.string()).max(50), span: z.enum(['event', 'day']), before: z.number().int().min(0).max(1440), after: z.number().int().min(0).max(1440), whileDraft: z.boolean(), keep: z.array(z.string()).max(500).default([]) }),
+      }),
+      handler: async (input, ctx) => {
+        await requireAdmin(ctx);
+        const repo = await getRepo(ctx.locals);
+        const settings = await repo.getSettings();
+        if (!bookingsEnabled()) return { rooms: [], holds: '' };
+        let times: { start: string; end: string };
+        try { times = normalizeEventTimes({ start: input.start, end: input.end, allDay: input.allDay }); }
+        catch { throw new ActionError({ code: 'BAD_REQUEST', message: 'Pick a valid date and time.' }); }
+        const resources = await repo.listResources();
+        const now = Date.now();
+        // a stand-in event holding every room, so each one gets a status
+        const probe = CalEventSchema.parse({
+          id: input.eventId || 'probe', slug: 'probe', title: input.title || 'Event', ...times, allDay: input.allDay,
+          timezone: input.timezone, rrule: input.rrule, exdates: input.exdates, status: 'published', startAt: 0, endAt: 0, createdAt: 0, updatedAt: 0,
+          roomHold: { ...input.roomHold, resourceIds: resources.map((r) => r.id), keep: input.roomHold.keep },
+        });
+        const { conflicts, holds } = await holdConflicts(repo, settings, probe, { now });
+        const tz = settings.timezone || 'UTC';
+        const locale = siteLocale(settings);
+        const day = new Intl.DateTimeFormat(locale, { weekday: 'short', month: 'short', day: 'numeric', timeZone: tz });
+        const time = new Intl.DateTimeFormat(locale, { hour: 'numeric', minute: '2-digit', timeZone: tz });
+        const range = (a: number, b: number) => { try { return time.formatRange(a, b); } catch { return `${time.format(a)} – ${time.format(b)}`; } };
+        const occurrences = new Set(holds.map((h) => h.eventStart)).size;
+        const first = holds[0];
+        const holdsLabel = first ? (input.roomHold.span === 'day' ? `Holds all day on ${day.format(first.eventStart)}` : `Holds ${range(first.start, first.end)} on ${day.format(first.eventStart)}`) + (occurrences > 1 ? ` and ${occurrences - 1} more date${occurrences === 2 ? '' : 's'}` : '') : '';
+        return {
+          holds: holdsLabel,
+          rooms: resources.map((r) => {
+            const mine = conflicts.filter((c) => c.booking.resourceId === r.id);
+            return {
+              id: r.id, name: r.name, kind: r.kind, capacity: r.capacity,
+              datesWithBookings: new Set(mine.map((c) => c.hold.eventStart)).size, dates: occurrences,
+              conflicts: mine.slice(0, 20).map((c) => ({
+                id: c.booking.id, name: c.booking.kind === 'block' ? `Blocked${c.booking.notes ? ` · ${c.booking.notes}` : ''}` : c.booking.name,
+                block: c.booking.kind === 'block', status: c.booking.status,
+                when: `${day.format(c.booking.start)} · ${range(c.booking.start, c.booking.end)}`,
+              })),
+            };
+          }),
+        };
+      },
+    }),
+    // Event editor → Rooms → "Cancel and email": frees the room for the event
+    cancelBookingsForEvent: defineAction({
+      input: z.object({ ids: z.array(z.string()).min(1).max(100), message: z.string().max(2000).default('') }),
+      handler: async ({ ids, message }, ctx) => {
+        await requireAdmin(ctx);
+        const repo = await getRepo(ctx.locals);
+        const settings = await repo.getSettings();
+        const opts = { origin: siteOrigin(settings, ctx.url), locals: ctx.locals, waitUntil: waitUntilFrom(ctx.locals) };
+        let cancelled = 0;
+        for (const id of ids) {
+          const b = await repo.getBooking(id);
+          if (!b || (b.status !== 'pending' && b.status !== 'confirmed')) continue;
+          try { await setBookingStatus(repo, b, 'cancelled', opts, message.trim() || undefined); cancelled++; } catch { /* changed meanwhile */ }
+        }
+        return { cancelled };
+      },
+    }),
+    // Schedule: click a day → title, time, calendar → saved (draft or published)
+    quickCreate: defineAction({
+      input: z.object({
+        title: z.string().max(300),
+        start: z.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2})?$/),
+        end: z.string().regex(/^(\d{4}-\d{2}-\d{2}(T\d{2}:\d{2})?)?$/).default(''),
+        allDay: z.boolean(),
+        calendarId: z.string().max(100).default(''),
+        rrule: z.string().max(500).default(''),
+        location: z.string().max(300).default(''),
+        publish: z.boolean().default(false),
+        roomIds: z.array(z.string()).max(50).default([]),
+      }),
+      handler: async (input, ctx) => {
+        await requireAdmin(ctx);
+        const repo = await getRepo(ctx.locals);
+        try { const e = await quickCreate(repo, input, hooksFor(ctx)); return { id: e.id, status: e.status }; } catch (e) { asActionError(e); }
+      },
+    }),
+    // Schedule: drag to another day. `occurrence` + mode 'one' moves a single
+    // repeat; otherwise the whole event moves.
+    move: defineAction({
+      input: z.object({ id: z.string(), days: z.number().int(), mode: z.enum(['series', 'one']).default('series'), occurrence: z.string().max(20).default('') }),
+      handler: async ({ id, days, mode, occurrence }, ctx) => {
+        await requireAdmin(ctx);
+        const repo = await getRepo(ctx.locals);
+        try {
+          const r = mode === 'one' ? await moveOccurrence(repo, id, occurrence, days, hooksFor(ctx)) : await moveSeries(repo, id, days, hooksFor(ctx));
+          return { id: r.event.id, undo: r.undo };
+        } catch (e) { asActionError(e); }
+      },
+    }),
+    undoMove: defineAction({
+      input: z.union([
+        z.object({ kind: z.literal('series'), id: z.string(), days: z.number().int() }),
+        z.object({ kind: z.literal('split'), id: z.string(), seriesId: z.string(), occurrence: z.string().max(20) }),
+      ]),
+      handler: async (undo, ctx) => {
+        await requireAdmin(ctx);
+        const repo = await getRepo(ctx.locals);
+        try { await undoMove(repo, undo, hooksFor(ctx)); return { ok: true }; } catch (e) { asActionError(e); }
+      },
+    }),
+    duplicate: defineAction({
+      input: z.object({ id: z.string() }),
+      handler: async ({ id }, ctx) => {
+        await requireAdmin(ctx);
+        const repo = await getRepo(ctx.locals);
+        try { return { id: (await duplicateEvent(repo, id)).id }; } catch (e) { asActionError(e); }
+      },
+    }),
     // editor pickers (event card): every event with its next date
     list: defineAction({
       input: z.object({ publishedOnly: z.boolean().default(false) }),

package/src/components/AiSettings.tsx

@@ -16,8 +16,8 @@ import { useEffect, useId, useRef, useState } from 'react';
 type Provider = 'openai' | 'custom';
 
 interface PublicSettings {
-  ai: { enabled: boolean; provider: Provider; baseUrl: string; model: string; hasApiKey: boolean };
-  agent: { enabled: boolean; hasKey: boolean; keyPrefix: string; allowPublish: boolean };
+  ai: { enabled: boolean; provider: Provider; baseUrl: string; model: string; hasApiKey: boolean; glossary?: string };
+  agent: { enabled: boolean; hasKey: boolean; keyPrefix: string; allowPublish: boolean; allowSections?: boolean };
   agentUrl: string;
   docsUrl: string;
 }
@@ -58,7 +58,7 @@ const sameUrl = (a: string, b: string) => {
 // only link to same-site paths or http(s) URLs from the server response
 const safeHref = (u: string) => (u.startsWith('/') && !u.startsWith('//')) || /^https?:\/\//i.test(u) ? u : '';
 
-type Busy = 'save' | 'test' | 'generate' | 'revoke' | 'saveAgent';
+type Busy = 'glossary' | 'save' | 'test' | 'generate' | 'revoke' | 'saveAgent';
 
 export default function AiSettings() {
   const uid = useId();
@@ -77,6 +77,9 @@ export default function AiSettings() {
   // agent form
   const [agentEnabled, setAgentEnabled] = useState(false);
   const [allowPublish, setAllowPublish] = useState(false);
+  const [allowSections, setAllowSections] = useState(false);
+  const [glossary, setGlossary] = useState('');
+  const [glossaryMsg, setGlossaryMsg] = useState('');
   const [token, setToken] = useState('');
   const [copied, setCopied] = useState('');
 
@@ -96,15 +99,27 @@ export default function AiSettings() {
       setProvider(s.ai.provider);
       setBaseUrl(s.ai.provider === 'openai' ? OPENAI_URL : s.ai.baseUrl);
       setModel(s.ai.model);
+      setGlossary(s.ai.glossary ?? '');
       setApiKey('');
       setClearApiKey(false);
     }
     if (part !== 'ai') {
       setAgentEnabled(s.agent.enabled);
       setAllowPublish(s.agent.allowPublish);
+      setAllowSections(Boolean(s.agent.allowSections));
     }
   }
 
+  async function saveGlossary() {
+    setBusy('glossary');
+    setGlossaryMsg('');
+    try {
+      adopt(await api<PublicSettings>('/api/ai/settings', { action: 'saveGlossary', glossary }), 'ai');
+      setGlossaryMsg('Saved. New AI translations follow it.');
+    } catch (e) { setGlossaryMsg(e instanceof Error ? e.message : 'Couldn’t save.'); }
+    finally { setBusy(null); }
+  }
+
   async function load() {
     setLoadError('');
     try {
@@ -150,7 +165,7 @@ export default function AiSettings() {
   const keyWillDrop = data.ai.hasApiKey && destinationChanged && !apiKey.trim() && !clearApiKey;
   const formDirty =
     enabled !== data.ai.enabled || destinationChanged || model.trim() !== data.ai.model || !!apiKey || clearApiKey;
-  const agentDirty = agentEnabled !== data.agent.enabled || allowPublish !== data.agent.allowPublish;
+  const agentDirty = agentEnabled !== data.agent.enabled || allowPublish !== data.agent.allowPublish || allowSections !== Boolean(data.agent.allowSections);
   const isCustom = provider !== 'openai';
 
   async function save() {
@@ -238,7 +253,7 @@ export default function AiSettings() {
     setAgentMsg({ ok: '', err: '' });
     await run('saveAgent', async () => {
       try {
-        adopt(await api<PublicSettings>('/api/ai/settings', { action: 'saveAgent', enabled: agentEnabled, allowPublish }), 'agent');
+        adopt(await api<PublicSettings>('/api/ai/settings', { action: 'saveAgent', enabled: agentEnabled, allowPublish, allowSections }), 'agent');
         setAgentMsg({ ok: 'Agent access saved.', err: '' });
       } catch (e) {
         setAgentMsg({ ok: '', err: errText(e) });
@@ -412,6 +427,26 @@ export default function AiSettings() {
         </div>
       </section>
 
+      {/* ---- translation glossary ---- */}
+      <section className="ais-card" aria-labelledby={id('gl-h')}>
+        <header className="ais-head">
+          <div className="ais-grow">
+            <h2 id={id('gl-h')}>Translation glossary</h2>
+            <p>When AI drafts another language, these words always come out your way. One per line: <code>Youth Night = Noche de Jóvenes</code>, or just a name to keep as is (<code>Riverside</code>).</p>
+          </div>
+        </header>
+        <label className="field" htmlFor={id('gl')}>
+          <span>Terms</span>
+          <textarea id={id('gl')} rows={6} className="mono" value={glossary} onChange={(e) => setGlossary(e.target.value)} placeholder={'Youth Night = Noche de Jóvenes\nSunday Worship = Culto dominical\nRiverside'} />
+        </label>
+        <div className="ais-actions">
+          <button type="button" className="btn primary" disabled={busy !== null || glossary.trim() === (data?.ai.glossary ?? '').trim()} onClick={() => void saveGlossary()}>
+            {busy === 'glossary' ? 'Saving…' : 'Save glossary'}
+          </button>
+          {glossaryMsg && <span className="hint" aria-live="polite">{glossaryMsg}</span>}
+        </div>
+      </section>
+
       {/* ---- agent ---- */}
       <section className="ais-card" aria-labelledby={id('ag-h')}>
         <header className="ais-head">
@@ -427,6 +462,7 @@ export default function AiSettings() {
         <ul className="ais-perms" aria-label="What the agent key can do">
           <li className="yes">Read all posts and pages, including unpublished drafts</li>
           <li className="yes">Create drafts and edit drafts of posts and pages</li>
+          <li className={allowSections ? 'yes' : 'no'}>Page sections — {allowSections ? 'can stage layout and content changes for your review' : 'read only unless you turn it on below'}</li>
           <li className={allowPublish ? 'yes' : 'no'}>Publish — {allowPublish ? 'allowed' : 'off unless you turn it on below'}</li>
           <li className="no">Never delete anything or change settings</li>
         </ul>
@@ -486,6 +522,10 @@ export default function AiSettings() {
             <input type="checkbox" checked={allowPublish} onChange={(e) => setAllowPublish(e.target.checked)} />
             <span>Let the agent publish <span className="hint">(off by default, so drafts wait for you to review)</span></span>
           </label>
+          <label className="check-row">
+            <input type="checkbox" checked={allowSections} onChange={(e) => setAllowSections(e.target.checked)} />
+            <span>Let the agent edit page sections <span className="hint">(homepage layouts and section content; changes stay in the design draft)</span></span>
+          </label>
           <div className="ais-actions">
             <button type="button" className="btn primary" onClick={() => void saveAgent()} disabled={busy !== null || !agentDirty}>
               {busy === 'saveAgent' ? 'Saving…' : 'Save agent access'}