@acms-subir/core 0.3.6 → 0.3.7

package/src/layouts/Admin.astro

@@ -30,7 +30,7 @@ const [pages, posts, links, home, settings, sessionUser] = await Promise.all([
   sessionUserId && sessionUserId !== OWNER_ENV ? repo.getUser(sessionUserId) : Promise.resolve(null),
 ]);
 // pending booking requests, shown as a count on the Bookings nav item
-const pendingBookings = bookingsEnabled() ? (await repo.listBookings({ from: Date.now(), statuses: ['pending'] })).length : 0;
+const pendingBookings = CALENDAR.enabled ? (await repo.listBookings({ from: Date.now(), statuses: ['pending'], ...(!bookingsEnabled() ? { kinds: ['rsvp'] as const as ['rsvp'] } : {}) })).length : 0;
 const me = {
   name: sessionUser?.name || 'Admin',
   role: roleLabels[sessionUserId === OWNER_ENV ? 'owner' : sessionUser?.role ?? 'editor'],
@@ -101,6 +101,7 @@ const groups: { id: string; label: string; items: Item[] }[] = [
     items: [
       ...collectionItems,
       { key: 'pages', label: 'Pages', href: '/admin/pages', icon: icons.pages, count: pages.length },
+      { key: 'forms', label: 'Forms', href: '/admin/forms', icon: icons.pages, count: null },
       { key: 'tags', label: 'Tags', href: '/admin/tags', icon: icons.tags, count: null },
       { key: 'media', label: 'Media', href: '/admin/media', icon: icons.media, count: null },
     ],
@@ -114,7 +115,7 @@ const groups: { id: string; label: string; items: Item[] }[] = [
         // people, booking links). Sub-pages highlight their home.
         items: [
           { key: 'calendar:schedule', label: 'Schedule', href: '/admin/calendar', icon: icons.calendar, count: null },
-          ...(bookingsEnabled()
+          ...(CALENDAR.enabled
             ? [{ key: 'calendar:bookings', label: 'Bookings', href: '/admin/calendar/bookings', icon: icons.bookings, count: pendingBookings || null, attention: pendingBookings > 0 }]
             : []),
         ],

package/src/lib/backup/content.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
-import { Page, Post, Media, Link, Tag, User, NavItem, Redirect, Settings, Calendar, CalEvent, Resource, BookingLink, Booking } from '../schema';
+import { SavedForm, FormSubmission } from '../forms/schema';
+import { Page, Post, Media, Link, Tag, User, NavItem, Redirect, Settings, Calendar, CalEvent, Resource, BookingLink, Booking, Place } from '../schema';
 import type { ContentRepository } from '../repo/types';
 
 // backups from before booking approval modes: a link that didn't confirm on
@@ -10,12 +11,15 @@ const legacyApproval = (l: unknown) =>
 export const BookingRequest = z.object({ keyHash: z.string().regex(/^[a-f0-9]{64}$/), requestHash: z.string().regex(/^[a-f0-9]{64}$/), bookingId: z.string().min(1), createdAt: z.number().int().nonnegative() });
 export type BookingRequest = z.infer<typeof BookingRequest>;
 export const BackupContent = z.object({
-  format: z.literal('acms-backup'), version: z.number().int().min(1).max(5), exportedAt: z.string().optional(),
+  format: z.literal('acms-backup'), version: z.number().int().min(1).max(6), exportedAt: z.string().optional(),
   settings: Settings.partial(), pages: z.array(Page), posts: z.array(Post), media: z.array(Media), links: z.array(Link),
   tags: z.array(Tag), navItems: z.array(NavItem), users: z.array(User), redirects: z.array(Redirect).default([]),
   calendars: z.array(Calendar).default([]), events: z.array(CalEvent).default([]), resources: z.array(Resource).default([]),
   bookingLinks: z.array(z.preprocess(legacyApproval, BookingLink)).default([]), bookings: z.array(Booking).default([]), bookingRequests: z.array(BookingRequest).optional(),
+  places: z.array(Place).default([]),
+  forms: z.array(SavedForm).optional(), formSubmissions: z.array(FormSubmission).optional(),
 }).superRefine((data, ctx) => {
+  if (data.version >= 6 && (!data.forms || !data.formSubmissions)) ctx.addIssue({ code: 'custom', message: 'Version 6 requires forms and their submissions.' });
   if (data.version >= 5 && !data.bookingRequests) ctx.addIssue({ code: 'custom', message: 'Version 5 requires booking retry records.' });
   const keys = new Set<string>();
   for (const r of data.bookingRequests ?? []) {
@@ -27,15 +31,16 @@ export const BackupContent = z.object({
   }
 });
 export async function exportContent(repo: ContentRepository, now = Date.now()) {
-  const [settings, pages, posts, media, links, tags, navItems, users, redirects, calendars, events, resources, bookingLinks, bookingState] = await Promise.all([
+  const [settings, pages, posts, media, links, tags, navItems, users, redirects, calendars, events, resources, bookingLinks, bookingState, places, forms, formSubmissions] = await Promise.all([
     repo.getSettings(), repo.listPages(), repo.listPosts(), repo.listMedia(), repo.listLinks(), repo.listTags(), repo.listNavItems(),
     repo.listUsers(), repo.listRedirects(), repo.listCalendars(), repo.listEvents(), repo.listResources(), repo.listBookingLinks(), repo.exportBookingState(),
+    repo.listPlaces(), repo.forms.list(), repo.forms.submissions(undefined, -1),
   ]);
   return {
-    format: 'acms-backup' as const, version: 5, exportedAt: new Date(now).toISOString(),
+    format: 'acms-backup' as const, version: 6, exportedAt: new Date(now).toISOString(),
     settings: { ...settings, live: { ...settings.live, mode: 'off' as const, manual: { watchUrl: '', title: 'We’re live', until: 0 } }, ai: { ...settings.ai, enabled: false, encryptedKey: '' }, agent: { ...settings.agent, enabled: false, keyHash: '', keyPrefix: '', allowPublish: false } },
     pages, posts, media, links, tags, navItems, users, redirects,
     calendars: calendars.map(c => ({ ...c, feedToken: '' })), events,
-    resources: resources.map(r => ({ ...r, feedToken: '' })), bookingLinks, ...bookingState,
+    resources: resources.map(r => ({ ...r, feedToken: '' })), bookingLinks, ...bookingState, places, forms, formSubmissions,
   };
 }

package/src/lib/booking/service.ts

@@ -1,3 +1,4 @@
+import { collectResponse, displayAnswers } from '../forms/service';
 // Booking workflows shared by the public booking pages, the admin, the REST
 // API and agent tools, so every path validates, notifies and fires webhooks
 // the same way. Auto-confirm links confirm on the spot (and show on the
@@ -101,7 +102,7 @@ export function bookingJson(b: Booking, extra: { title?: string; resourceSlug?:
     id: b.id, kind: b.kind, status: b.status,
     start: new Date(b.start).toISOString(), end: new Date(b.end).toISOString(),
     resourceId: b.resourceId || null, linkId: b.linkId || null, eventId: b.eventId || null,
-    name: b.name, email: b.email, phone: b.phone, seats: b.seats, answers: b.answers,
+    name: b.name, email: b.email, phone: b.phone, seats: b.seats, answers: b.answers, formResponse: b.formResponse,
     source: b.source, createdAt: new Date(b.createdAt).toISOString(), ...extra,
   };
 }
@@ -140,6 +141,7 @@ export interface BookerInput {
   email: string;
   phone?: string;
   answers?: Record<string, string>;
+  formVersion?: string;
 }
 
 export function validateBooker(link: Pick<BookingLink, 'questions' | 'askPhone'> | null, input: BookerInput): { name: string; email: string; phone: string; answers: Record<string, string> } {
@@ -217,10 +219,12 @@ export async function createRsvp(
   if (args.end <= (opts.now ?? Date.now())) throw new BookingError(410, 'This event has already happened.');
   const seats = Math.max(1, Math.min(e.rsvp.maxSeats || 1, Math.floor(args.seats) || 1));
   const booker = validateBooker(null, args.booker);
+  const formResponse = e.rsvp.form ? await collectResponse(e.rsvp.form, args.booker.answers ?? {}, args.booker.formVersion) : undefined;
+  if (formResponse) booker.answers = displayAnswers(formResponse);
   const b = await repo.createBooking({
     kind: 'rsvp', resourceId: '', linkId: '', eventId: e.id, status: e.rsvp.autoConfirm ? 'confirmed' : 'pending',
     start: args.start, end: args.end, holdStart: args.start, holdEnd: args.end, timezone: e.timezone, ...booker, seats,
-    notes: '', manageToken: token(), source: args.source ?? 'web',
+    formResponse, notes: '', manageToken: token(), source: args.source ?? 'web',
   }, { capacity: e.rsvp.capacity, idempotency: opts.idempotency });
   if (!b) throw new BookingError(409, e.rsvp.capacity ? 'Sorry — that’s more seats than are left.' : 'Couldn’t save your RSVP.');
   await notify(repo, b, [b.status === 'confirmed' ? 'confirmed' : 'received'], opts);

package/src/lib/calendar/agent-schema.ts

@@ -12,7 +12,13 @@ const eventFields = {
   allDay: z.boolean().optional(),
   timezone: z.string().max(80).optional(),
   rrule: z.string().max(500).optional(),
-  location: z.object({ name: z.string().max(300).default(''), address: z.string().max(500).default(''), url: z.string().max(1000).default('') }).strict().optional(),
+  // lat/lng pin the map image; placeId links a saved place (its details are
+  // copied in); showMap: false hides the map image on the event page
+  location: z.object({
+    name: z.string().max(300).default(''), address: z.string().max(500).default(''), url: z.string().max(1000).default(''),
+    lat: z.number().min(-90).max(90).nullable().optional(), lng: z.number().min(-180).max(180).nullable().optional(),
+    placeId: z.string().max(100).optional(), showMap: z.boolean().optional(),
+  }).strict().refine((l) => (l.lat === undefined || l.lat === null) === (l.lng === undefined || l.lng === null), { message: 'Give both lat and lng, or neither.' }).optional(),
   cta: z.object({ label: z.string().max(120).default(''), href: z.string().max(1000).default(''), style: z.enum(['primary', 'outline']).default('primary') }).strict().optional(),
   calendars: z.array(z.string().max(100)).max(20).optional(),
   // bookable rooms/people (slugs from the booking resources) this event uses:

package/src/lib/calendar/agent.ts

@@ -14,12 +14,35 @@ import { mergeEventDraft } from '../drafts';
 import { eventChanged } from './hooks';
 import { eventToJson } from './api';
 import { siteLocale } from '../dates';
+import { EventLocation } from '../schema';
+import { ensureMapImages, mergeLocationInput } from '../maps/service';
 
 export type EventToolInput = z.infer<(typeof EventToolInputs)[number]>;
 
 export interface AgentContext {
   origin: string;
   waitUntil?: (p: Promise<unknown>) => void;
+  // request locals (maps provider + media storage for map images)
+  locals?: unknown;
+}
+
+type LocationArg = NonNullable<Extract<EventToolInput, { tool: 'create_event' }>['arguments']['location']>;
+
+// A location from the API/agent: a known placeId copies the saved place's
+// details in (typed fields still win), a pin gets its map image. On update,
+// unchanged text keeps the existing pin (mergeLocationInput).
+async function locationFrom(repo: ContentRepository, a: LocationArg, prev: EventLocation, ctx: AgentContext): Promise<EventLocation> {
+  let input: Partial<EventLocation> = { ...a };
+  if (a.placeId) {
+    const place = await repo.getPlace(a.placeId);
+    if (!place) throw new ApiError(400, `Unknown place "${a.placeId}".`);
+    input = {
+      name: a.name || place.name, address: a.address || place.address, url: a.url || place.url,
+      lat: a.lat ?? place.lat, lng: a.lng ?? place.lng, placeId: place.id, showMap: a.showMap,
+    };
+  }
+  const loc = mergeLocationInput(prev, input);
+  return ensureMapImages(repo, loc, { locals: ctx.locals, origin: ctx.origin });
 }
 
 const editUrl = (id: string) => `/admin/calendar/events/${id}`;
@@ -100,7 +123,8 @@ export async function runEventTool(repo: ContentRepository, input: EventToolInpu
       for (let n = 2; await repo.getEventBySlug(slug); n++) slug = `${base}-${n}`;
       const e = await repo.createEvent({
         title: a.title, slug, ...times, allDay: a.allDay ?? a.start.length === 10, timezone: a.timezone ?? '',
-        rrule: a.rrule ?? '', excerpt: a.excerpt ?? '', location: a.location, cta: a.cta, tags: a.tags,
+        rrule: a.rrule ?? '', excerpt: a.excerpt ?? '', cta: a.cta, tags: a.tags,
+        ...(a.location ? { location: await locationFrom(repo, a.location, EventLocation.parse({}), ctx) } : {}),
         cancelled: a.cancelled ?? false, seoTitle: a.seoTitle, seoDesc: a.seoDesc,
         calendarIds: (await resolveCalendars(repo, a.calendars)) ?? [],
         ...(a.rooms ? { roomHold: await resolveRooms(repo, a.rooms) } : {}),
@@ -110,11 +134,12 @@ export async function runEventTool(repo: ContentRepository, input: EventToolInpu
       return { ...summary(e) };
     }
     case 'update_event': {
-      const { id, content, calendars: slugs, rooms, ...rest } = input.arguments;
-      checkLinks(rest);
+      const { id, content, calendars: slugs, rooms, location, ...rest } = input.arguments;
+      checkLinks({ ...rest, location });
       const before = await repo.getEvent(id);
       if (!before) throw new ApiError(404, 'Event not found.');
       const data: Partial<CalEvent> = { ...rest };
+      if (location) data.location = await locationFrom(repo, location, mergeEventDraft(before).location, ctx);
       if (content !== undefined) {
         data.bodyHtml = renderAgentMarkdown(content);
         data.bodyJson = '';

package/src/lib/calendar/api.ts

@@ -25,6 +25,7 @@ export interface EventJson {
   exdates: string[];
   location: CalEvent['location'];
   cta: CalEvent['cta'];
+  rsvp?: CalEvent['rsvp'];
   image: string;
   imageAlt: string;
   tags: string[];
@@ -55,6 +56,7 @@ export function eventToJson(e: CalEvent, origin: string, calendars: Map<string,
     exdates: e.exdates,
     location: e.location,
     cta: e.cta,
+    rsvp: e.rsvp,
     image: e.cover ? abs(origin, e.cover) : '',
     imageAlt: e.coverAlt,
     tags: e.tags.filter((t) => !t.startsWith('#')),

package/src/lib/calendar/ics-write.ts

@@ -92,6 +92,8 @@ export function eventToVevent(e: CalEvent, siteTz: string, opts: FeedOptions): s
   lines.push(`SUMMARY:${escapeText(e.title || 'Untitled event')}`);
   const loc = locationLine(e.location);
   if (loc) lines.push(`LOCATION:${escapeText(loc)}`);
+  // RFC 5545 GEO: latitude;longitude
+  if (typeof e.location.lat === 'number' && typeof e.location.lng === 'number') lines.push(`GEO:${e.location.lat.toFixed(6)};${e.location.lng.toFixed(6)}`);
   const desc = [e.excerpt, e.location.url && e.location.url !== loc ? e.location.url : '', url].filter(Boolean).join('\n\n');
   lines.push(`DESCRIPTION:${escapeText(desc)}`, `URL:${url}`);
   const cats = e.calendarIds.map((id) => opts.calendars?.get(id)?.name).filter((n): n is string => Boolean(n));

package/src/lib/calendar/ics.ts

@@ -55,6 +55,7 @@ const DAY = 86_400_000;
 /* ---------------- timezone math (no dependencies) ---------------- */
 
 const fmtCache = new Map<string, Intl.DateTimeFormat>();
+const FORMATTER_CACHE_MAX = 64;
 function tzFormatter(tz: string): Intl.DateTimeFormat | null {
   let f = fmtCache.get(tz);
   if (f) return f;
@@ -68,6 +69,9 @@ function tzFormatter(tz: string): Intl.DateTimeFormat | null {
     return null; // unknown TZID (Outlook's "Customized Time Zone" etc.)
   }
   fmtCache.set(tz, f);
+  // Intl formatters retain native ICU data; timezone aliases/case variants
+  // must not accumulate for the lifetime of a self-hosted server.
+  if (fmtCache.size > FORMATTER_CACHE_MAX) fmtCache.delete(fmtCache.keys().next().value!);
   return f;
 }
 

package/src/lib/calendar/import.ts

@@ -3,7 +3,7 @@
 // import action saves as DRAFTS — nothing goes live without a review.
 // Recurring ICS events keep their RRULE/EXDATEs; per-instance overrides
 // (RECURRENCE-ID) are skipped, since a native event can't hold them yet.
-import type { EventLocation } from '../schema';
+import { EventLocation } from '../schema';
 import { parseICS, tzParts, type IcsTime, type VEvent } from './ics';
 import { isValidTimeZone, normalizeEventTimes, parseWall, addWallDays, formatWall } from './events';
 import { cleanRrule } from './rrule';
@@ -78,7 +78,7 @@ export function eventsFromVEvents(vevents: VEvent[], calTz: string, siteTz: stri
       exdates: v.exdates.map((t) => wallOf(t, siteTz).wall),
       excerpt: v.description.slice(0, 300),
       bodyHtml: paragraphs(v.description),
-      location: { name: v.location.slice(0, 300), address: '', url: '' },
+      location: EventLocation.parse({ name: v.location.slice(0, 300) }),
       cancelled: v.cancelled,
       sourceUid: v.uid,
     });
@@ -192,7 +192,7 @@ export function eventsFromCsv(text: string): { events: ImportedEvent[]; skipped:
       events.push({
         title: title.slice(0, 300), ...times, allDay, timezone: '', rrule: '', exdates: [],
         excerpt: desc.slice(0, 300), bodyHtml: paragraphs(desc),
-        location: { name: get(r, 'location').slice(0, 300), address: get(r, 'address').slice(0, 300), url: get(r, 'url').slice(0, 500) },
+        location: EventLocation.parse({ name: get(r, 'location').slice(0, 300), address: get(r, 'address').slice(0, 300), url: get(r, 'url').slice(0, 500) }),
         cancelled: false, sourceUid: '',
       });
     } catch {

package/src/lib/calendar/schedule.ts

@@ -5,7 +5,8 @@
 // the editor's "stage until Update" flow is for content edits, not dates.
 import type { ContentRepository } from '../repo/types';
 import type { CalEvent } from '../schema';
-import { slugify } from '../schema';
+import { EventLocation, slugify } from '../schema';
+import { defaultPlaceLocation } from '../maps/places';
 import { ApiError } from '../api';
 import { applyEventUpdate, saveEvent, type SaveHooks } from '../content-service';
 import { addWallDays, formatWall, parseWall } from './events';
@@ -49,10 +50,13 @@ export interface QuickEvent {
 export async function quickCreate(repo: ContentRepository, q: QuickEvent, hooks: SaveHooks): Promise<CalEvent> {
   const title = q.title.trim().slice(0, 300) || 'Untitled event';
   const cal = q.calendarId ? await repo.getCalendar(q.calendarId) : null;
+  // no place typed → the site's default place (if one is set)
+  const typed = q.location.trim().slice(0, 300);
+  const location = typed ? EventLocation.parse({ name: typed }) : (await defaultPlaceLocation(repo)) ?? EventLocation.parse({});
   const created = await repo.createEvent({
     title, slug: await uniqueSlug(repo, title), start: q.start, allDay: q.allDay, status: 'draft',
     calendarIds: cal?.kind === 'native' ? [cal.id] : [],
-    location: { name: q.location.trim().slice(0, 300), address: '', url: '' },
+    location,
   });
   if (q.roomIds?.length) await saveEvent(repo, created.id, { roomHold: { resourceIds: q.roomIds, span: 'event', before: 0, after: 0, whileDraft: false, keep: [] } }, hooks);
   // times + repeat go through the editor's validation (end defaults, pairs)

package/src/lib/calendar/seo.ts

@@ -24,8 +24,11 @@ export function eventJsonLd(e: CalEvent, o: Pick<Occurrence, 'start' | 'end' | '
     return `${p.y}-${pad(p.m)}-${pad(p.d)}`;
   };
   const online = Boolean(e.location.url && isMeetingUrl(e.location.url));
+  const pin = typeof e.location.lat === 'number' && typeof e.location.lng === 'number'
+    ? { geo: { '@type': 'GeoCoordinates', latitude: e.location.lat, longitude: e.location.lng } }
+    : {};
   const place = e.location.name || e.location.address
-    ? { '@type': 'Place', name: e.location.name || e.location.address, ...(e.location.address ? { address: e.location.address } : {}) }
+    ? { '@type': 'Place', name: e.location.name || e.location.address, ...(e.location.address ? { address: e.location.address } : {}), ...pin }
     : null;
   const virtual = online ? { '@type': 'VirtualLocation', url: e.location.url } : null;
   const location = place && virtual ? [place, virtual] : place ?? virtual;

package/src/lib/content-service.ts

@@ -1,5 +1,6 @@
 import type { ContentRepository } from './repo/types';
-import type { CalEvent, Page, Post, WidgetInstance } from './schema';
+import { FormDefinition } from './forms/schema';
+import type { CalEvent, EventLocation, Page, Post, WidgetInstance } from './schema';
 import { slugify } from './schema';
 import { ApiError } from './api';
 import { CONTENT, collectionUrl } from './content';
@@ -9,6 +10,8 @@ import { eventChanged } from './calendar/hooks';
 import { normalizePageLocale } from './i18n';
 import { siteOrigin } from './seo';
 import { waitUntilFrom } from './webhooks';
+import { mergeEventDraft } from './drafts';
+import { ensureMapImages, mergeLocationInput } from './maps/service';
 
 // Saving posts, pages and events: the one implementation behind the admin
 // editor (astro:actions) and the editor-app API (/api/v1/admin/documents).
@@ -27,7 +30,12 @@ export interface SaveHooks {
 
 export type PostSave = Parameters<ContentRepository['updatePost']>[1];
 export type PageSave = Omit<Parameters<ContentRepository['updatePage']>[1], 'blocks'>;
-export type EventSave = Partial<Omit<CalEvent, 'id' | 'draft' | 'startAt' | 'endAt' | 'createdAt' | 'updatedAt' | 'sourceUid' | 'publishedAt'>>;
+// location may be partial: missing pin fields are filled from the current
+// location (see mergeLocationInput) — older clients send name/address/url only
+export type EventSave = Partial<Omit<CalEvent, 'id' | 'draft' | 'startAt' | 'endAt' | 'createdAt' | 'updatedAt' | 'sourceUid' | 'publishedAt' | 'location'>> & {
+  location?: Partial<EventLocation>;
+};
+type EventClean = Omit<EventSave, 'location'> & { location?: EventLocation };
 
 const live = (status: string) => status === 'published' || status === 'scheduled';
 
@@ -107,8 +115,21 @@ export async function applyPageUpdate(repo: ContentRepository, id: string, hooks
 
 // 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.
-export async function cleanEventInput(repo: ContentRepository, data: EventSave, before: CalEvent): Promise<EventSave> {
-  const out: EventSave = { ...data };
+export async function cleanEventInput(repo: ContentRepository, data: EventSave, before: CalEvent): Promise<EventClean> {
+  const { location, ...rest } = data;
+  const out: EventClean = { ...rest };
+  // Older editor clients resend the original RSVP shape. Omission must not
+  // erase questions that were authored in a newer editor.
+  if (out.rsvp && !Object.hasOwn(out.rsvp, 'form')) {
+    const previous = mergeEventDraft(before).rsvp.form;
+    if (previous) out.rsvp = { ...out.rsvp, form: previous };
+  }
+  if (out.rsvp?.form !== undefined) {
+    const form = FormDefinition.safeParse(out.rsvp.form);
+    if (!form.success) throw new ApiError(400, form.error.issues[0]?.message || 'Invalid registration form.');
+    out.rsvp = { ...out.rsvp, form: form.data };
+  }
+  if (location !== undefined) out.location = mergeLocationInput(mergeEventDraft(before).location, location);
   if (out.slug !== undefined) {
     const base = slugify(out.slug || out.title || before.title);
     let slug = base;
@@ -178,6 +199,11 @@ export async function saveEvent(repo: ContentRepository, id: string, data: Event
   const before = await repo.getEvent(id);
   if (!before) throw new ApiError(404, 'Event not found.');
   const clean = await cleanEventInput(repo, data, before);
+  // static map images follow the pin (fetched once per pin, never blocking)
+  if (clean.location) {
+    const settings = await repo.getSettings();
+    clean.location = await ensureMapImages(repo, clean.location, { locals: hooks.locals, origin: siteOrigin(settings, hooks.url) });
+  }
   // live events stage edits until Update, exactly like posts
   const transitions = clean.status !== undefined && clean.status !== before.status;
   if (live(before.status) && !transitions) {

package/src/lib/drafts.ts

@@ -1,4 +1,5 @@
 import type { CalEvent, NavItem, Page, Post, Settings } from './schema';
+import { EventLocation } from './schema';
 
 // Pending-edit ("draft") snapshots for live documents. A published or
 // scheduled post/page never receives content edits directly: they accumulate
@@ -44,7 +45,14 @@ export function pickPostDraft(draft: Record<string, unknown>): Partial<Pick<Post
   return pick(draft, POST_DRAFT_KEYS) as Partial<Pick<Post, PostDraftKey>>;
 }
 export function pickEventDraft(draft: Record<string, unknown>): Partial<Pick<CalEvent, EventDraftKey>> {
-  return pick(draft, EVENT_DRAFT_KEYS) as Partial<Pick<CalEvent, EventDraftKey>>;
+  const out = pick(draft, EVENT_DRAFT_KEYS) as Partial<Pick<CalEvent, EventDraftKey>>;
+  // snapshots staged before maps support lack the pin fields: fill defaults
+  // so merged events always carry a complete location
+  if (out.location !== undefined) {
+    const loc = EventLocation.safeParse(out.location);
+    if (loc.success) out.location = loc.data; else delete out.location;
+  }
+  return out;
 }
 export function pickPageDraft(draft: Record<string, unknown>): Partial<Pick<Page, PageDraftKey>> {
   return pick(draft, PAGE_DRAFT_KEYS) as Partial<Pick<Page, PageDraftKey>>;

package/src/lib/dynamicBlocks.ts

@@ -19,7 +19,7 @@ import { renderEventCards, type EventCardAttrs } from './calendar/cards';
 //   <div data-dyn="events" data-mode="upcoming" data-calendar="youth"
 //        data-event="" data-limit="3" data-layout="grid" data-show-image="1"></div>
 
-const PLACEHOLDER = /<div[^>]*data-dyn="(?:post-list|calendar|toc|events)"[^>]*>\s*<\/div>/g;
+const PLACEHOLDER = /<div[^>]*data-dyn="(?:post-list|calendar|toc|events|form)"[^>]*>\s*<\/div>/g;
 
 const esc = (s: string) =>
   s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
@@ -133,11 +133,12 @@ function eventCardAttrs(tag: string): EventCardAttrs {
 
 export async function expandDynamicBlocks(html: string, repo: ContentRepository): Promise<string> {
   html = stampHeadingAnchors(html);
+  const hasForms = html.includes('data-dyn="form"');
   const hasPostList = html.includes('data-dyn="post-list"');
   const hasCalendar = html.includes('data-dyn="calendar"');
   const hasToc = html.includes('data-dyn="toc"');
   const hasEvents = html.includes('data-dyn="events"');
-  if (!hasPostList && !hasCalendar && !hasToc && !hasEvents) return html;
+  if (!hasPostList && !hasCalendar && !hasToc && !hasEvents && !hasForms) return html;
   const [posts, settings] = await Promise.all([
     hasPostList ? repo.listPublishedPosts() : Promise.resolve([] as Post[]), // newest first; shared by all blocks on the page
     repo.getSettings(),
@@ -160,9 +161,19 @@ export async function expandDynamicBlocks(html: string, repo: ContentRepository)
     await Promise.all(tags.map(async (tag) => calendarHtml.set(tag, await renderEventCards(eventCardAttrs(tag), repo, settings, now))));
   }
 
+  if (hasForms) {
+    const tags = [...new Set((html.match(PLACEHOLDER) ?? []).filter(t => t.includes('data-dyn="form"')))];
+    await Promise.all(tags.map(async tag => {
+      const form = await repo.forms.get(attr(tag, 'form'));
+      // A same-origin frame gives each visitor an uncached form/receipt even
+      // when the containing content page is served from a shared cache.
+      calendarHtml.set(tag, form?.kind === 'form' && form.purpose === 'general' && form.status === 'published'
+        ? `<iframe class="pc-form-embed" src="/forms/${encodeURIComponent(form.id)}?embed=1" title="${esc(form.definition.title || form.name)}" loading="lazy"></iframe>` : '');
+    }));
+  }
   const anchored = html;
   return html.replace(PLACEHOLDER, (tag) => {
-    if (tag.includes('data-dyn="calendar"') || tag.includes('data-dyn="events"')) return calendarHtml.get(tag) ?? '';
+    if (tag.includes('data-dyn="form"') || tag.includes('data-dyn="calendar"') || tag.includes('data-dyn="events"')) return calendarHtml.get(tag) ?? '';
     if (tag.includes('data-dyn="toc"')) return renderToc(anchored, attr(tag, 'title'));
     const source = attr(tag, 'source') || 'latest';
     const tagName = attr(tag, 'tag');

package/src/lib/editor/documents.ts

@@ -1,3 +1,4 @@
+import { FormDefinition } from '../forms/schema';
 import { z } from 'zod';
 import type { ContentRepository } from '../repo/types';
 import type { CalEvent, DocTranslations, Page, Post } from '../schema';
@@ -10,6 +11,7 @@ import { draftSavedAt, mergeEventDraft, mergePageDraft, mergePostDraft, pickEven
 import { localeHomeUrl } from '../i18n';
 import { pageQuery } from '../mobile/http';
 import { applyEventUpdate, applyPageUpdate, applyPostUpdate, saveEvent, savePage, savePost, type SaveHooks } from '../content-service';
+import { defaultPlaceLocation } from '../maps/places';
 
 // Posts, pages and events for editor apps. Reads show the document as it
 // will look after Update (staged edits merged); writes go through the same
@@ -134,7 +136,9 @@ export async function createDoc(repo: ContentRepository, input: z.infer<typeof C
   catch (err) { throw new ApiError(400, err instanceof Error ? err.message : 'Invalid start time.'); }
   let slug = base;
   for (let n = 2; await repo.getEventBySlug(slug); n++) slug = `${base}-${n}`;
-  return repo.createEvent({ title: input.title, slug, start: times.start, end: times.end, allDay: input.allDay ?? !input.start.includes('T') });
+  // new events start at the site's default place, like the admin
+  const place = await defaultPlaceLocation(repo);
+  return repo.createEvent({ title: input.title, slug, start: times.start, end: times.end, allDay: input.allDay ?? !input.start.includes('T'), ...(place ? { location: place } : {}) });
 }
 
 // ---- save ----------------------------------------------------------------
@@ -148,10 +152,15 @@ export const PostFields = z.object({ ...common, excerpt: text(5000), tags: z.arr
 export const PageFields = z.object({ ...common, isHome: z.boolean(), locale: text(20) }).partial().strict();
 export const EventFields = z.object({ ...common, excerpt: text(1000), tags: z.array(text(100)).max(100), cover: text(2000), coverAlt: text(1000), featured: z.boolean(),
   start: text(40), end: text(40), allDay: z.boolean(), timezone: text(100), rrule: text(500), exdates: z.array(text(40)).max(500), cancelled: z.boolean(),
-  location: z.object({ name: text(300), address: text(500), url: text(1000) }).strict(),
+  location: z.object({
+    name: text(300), address: text(500), url: text(1000),
+    // optional pin fields; omitted = kept while the text is unchanged
+    lat: z.number().min(-90).max(90).nullable(), lng: z.number().min(-180).max(180).nullable(),
+    placeId: text(100), showMap: z.boolean(), mapImage: text(500), mapImageDark: text(500),
+  }).partial({ lat: true, lng: true, placeId: true, showMap: true, mapImage: true, mapImageDark: true }).strict(),
   cta: z.object({ label: text(120), href: text(1000), style: z.enum(['primary', 'outline']) }).strict(),
   calendarIds: z.array(text(100)).max(50), fields: z.record(text(2000)),
-  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) }).strict(),
+  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), form: FormDefinition.optional() }).strict(),
 }).partial().strict();
 export const SaveInput = z.object({ revision: z.string().max(60), fields: z.record(z.unknown()) }).strict();
 

package/src/lib/editor/schemas.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { FormDefinition } from '../forms/schema';
 import { Booking } from '../schema';
 
 // Response shapes of the editor-app API (OpenAPI components, client types).
@@ -40,8 +41,8 @@ export const EditorDocument = EditorDocumentSummary.extend({
   authorIds: z.array(str), locale: str.nullable(), isHome: bool, publishedAt: date.nullable(), scheduledAt: date.nullable(), createdAt: date,
   event: z.object({
     start: str, end: str, allDay: bool, timezone: str, rrule: str, exdates: z.array(str), cancelled: bool,
-    location: z.object({ name: str, address: str, url: str }), cta: z.object({ label: str, href: str, style: z.enum(['primary', 'outline']) }),
-    calendarIds: z.array(str), fields: z.record(str), rsvp: z.object({ enabled: bool, capacity: num, autoConfirm: bool, maxSeats: num }),
+    location: z.object({ name: str, address: str, url: str, lat: num.nullable(), lng: num.nullable(), placeId: str, showMap: bool, mapImage: str, mapImageDark: str }), cta: z.object({ label: str, href: str, style: z.enum(['primary', 'outline']) }),
+    calendarIds: z.array(str), fields: z.record(str), rsvp: z.object({ enabled: bool, capacity: num, autoConfirm: bool, maxSeats: num, form: FormDefinition.optional() }),
   }).nullable(),
   languages: z.array(str),
 });
@@ -79,7 +80,7 @@ export const EditorMedia = z.object({
 });
 export const EditorMediaList = z.object({ items: z.array(EditorMedia), pagination: Pagination });
 
-export const EditorBooking = Booking.pick({ id: true, kind: true, status: true, name: true, email: true, phone: true, seats: true, answers: true, source: true, notes: true })
+export const EditorBooking = Booking.pick({ id: true, kind: true, status: true, name: true, email: true, phone: true, seats: true, answers: true, formResponse: true, source: true, notes: true })
   .extend({ start: date, end: date, resourceId: str.nullable(), linkId: str.nullable(), eventId: str.nullable(), createdAt: date, updatedAt: date, title: str });
 export const EditorBookingList = z.object({ pending: num.int(), items: z.array(EditorBooking), pagination: Pagination });
 

package/src/lib/forms/events.ts

@@ -0,0 +1,40 @@
+import type { ContentRepository } from '../repo/types';
+import type { CalEvent } from '../schema';
+import { ApiError } from '../api';
+import { sha256Hex } from '../api-keys';
+import { createRsvp } from '../booking/service';
+import { collectResponse, formVersion } from './service';
+import { starter } from './schema';
+import { readAnswers } from './http';
+
+// Older custom EventTemplate components only post name/email/seats. Keep
+// that exact legacy case working; customized forms require versioned markup.
+export async function prepareLegacyEventForm(event: CalEvent, start: number, data: FormData) {
+  if (!event.rsvp.form && !data.has('requestId') && !data.has('formVersion') && !data.has('occurrence')) {
+    data.set('requestId', crypto.randomUUID());
+    data.set('formVersion', await formVersion(starter('simple')));
+    data.set('occurrence', String(start));
+  }
+}
+
+export async function submitEventForm(repo: ContentRepository, event: CalEvent, occurrence: { start: number; end: number }, data: FormData, requestId: string, flow: Parameters<typeof createRsvp>[2]) {
+  if (event.status !== 'published') throw new ApiError(404, 'Event not found.');
+  if (Number(data.get('occurrence')) !== occurrence.start) throw new ApiError(409, 'The event time has changed. Review the date and try again.');
+  const seats = Number(data.get('seats') || 1);
+  if (!Number.isInteger(seats) || seats < 1 || seats > event.rsvp.maxSeats) throw new ApiError(400, 'Choose a valid number of seats.');
+  const definition = event.rsvp.form ?? starter('simple');
+  const booker = { name: String(data.get('name') || ''), email: String(data.get('email') || ''), answers: readAnswers(data, definition), formVersion: String(data.get('formVersion') || '') };
+  const idempotency = { keyHash: await sha256Hex(`event-form:${requestId}`), requestHash: await sha256Hex(JSON.stringify({ event: event.id, start: occurrence.start, seats, booker })) };
+  const replay = async () => {
+    const record = await repo.getBookingRequest(idempotency.keyHash);
+    if (!record) return null;
+    if (record.requestHash !== idempotency.requestHash) throw new ApiError(409, 'This registration was already sent with different details. Reload to register again.');
+    const booking = await repo.getBooking(record.bookingId);
+    if (!booking) throw new ApiError(410, 'This registration was removed. Reload to register again.');
+    return booking;
+  };
+  const existing = await replay(); if (existing) return existing;
+  await collectResponse(definition, booker.answers, booker.formVersion);
+  try { return await createRsvp(repo, { event, ...occurrence, seats, booker }, { ...flow, idempotency }); }
+  catch (e) { const existing = await replay(); if (existing) return existing; throw e; }
+}

package/src/lib/forms/export.ts

@@ -0,0 +1,62 @@
+// Pure helpers for the admin Responses screen and its CSV export. Kept out of
+// service.ts so the public submit path stays small.
+import type { FormField, FormSubmission } from './schema';
+
+type Field = Pick<FormField, 'id' | 'type' | 'label'>;
+
+// Questions that collect an answer (section headings are layout only).
+export const answerFields = <F extends Field>(fields: F[]) => fields.filter(f => (f.type as string) !== 'heading');
+
+// One spreadsheet cell: yes/no for consent-style boxes, multi-choice answers
+// (stored newline-separated) joined with commas; paragraphs keep their lines.
+export function cellText(field: Pick<FormField, 'type'> | undefined, value: string | undefined): string {
+  if (!field) return '';
+  const type = field.type as string;
+  if (type === 'checkbox' || type === 'consent') return value === 'yes' ? 'Yes' : 'No';
+  if (type === 'textarea') return value ?? '';
+  return (value ?? '').split(/\r?\n/).map(s => s.trim()).filter(Boolean).join(', ');
+}
+
+// v1…vN in first-seen order; the live definition is the next number when no
+// response has used it yet. Unknown hashes fall back to a short hash.
+export function versionLabeler(seen: string[], current?: string) {
+  const order = [...seen];
+  if (current && !order.includes(current)) order.push(current);
+  const index = new Map(order.map((v, i) => [v, i + 1]));
+  return (v: string) => (index.has(v) ? `v${index.get(v)}` : v.slice(0, 7));
+}
+
+// Wide export: one row per response. Columns are the current questions first,
+// then questions only found in older snapshots (labelled from the newest one).
+export function wideRows(current: Field[], rows: FormSubmission[], version: (v: string) => string = v => v.slice(0, 7)): string[][] {
+  const cols: { id: string; label: string }[] = answerFields(current).map(f => ({ id: f.id, label: f.label }));
+  const known = new Set(cols.map(c => c.id));
+  for (const r of rows) for (const f of answerFields(r.response.definition.fields)) {
+    if (known.has(f.id)) continue;
+    known.add(f.id); cols.push({ id: f.id, label: f.label });
+  }
+  const used = new Set(['Reference', 'Submitted', 'Version']);
+  const header = cols.map(c => {
+    const label = used.has(c.label) ? `${c.label} (${c.id})` : c.label;
+    used.add(label); return label;
+  });
+  return [
+    ['Reference', 'Submitted', 'Version', ...header],
+    ...rows.map(r => {
+      const byId = new Map(r.response.definition.fields.map(f => [f.id, f]));
+      return [r.id, new Date(r.createdAt).toISOString(), version(r.response.version), ...cols.map(c => cellText(byId.get(c.id), r.response.answers[c.id]))];
+    }),
+  ];
+}
+
+export function relativeTime(ts: number, now = Date.now(), timeZone?: string): string {
+  const s = Math.floor((now - ts) / 1000);
+  if (s < 60) return 'Just now';
+  if (s < 3600) return `${Math.floor(s / 60)}m ago`;
+  if (s < 86400) return `${Math.floor(s / 3600)}h ago`;
+  if (s < 86400 * 2) return 'Yesterday';
+  if (s < 86400 * 7) return `${Math.floor(s / 86400)}d ago`;
+  const opts: Intl.DateTimeFormatOptions = { month: 'short', day: 'numeric', ...(new Date(ts).getFullYear() !== new Date(now).getFullYear() ? { year: 'numeric' } : {}) };
+  try { return new Date(ts).toLocaleDateString('en-US', { ...opts, timeZone }); }
+  catch { return new Date(ts).toLocaleDateString('en-US', opts); }
+}