@acms-subir/core 0.3.6 → 0.3.7

package/src/lib/maps/service.ts

@@ -0,0 +1,281 @@
+// Server-side maps work behind the actions: address suggestions (with a small
+// bounded cache), expanding short map links safely, and the static map images
+// stored in the media library. Nothing here runs without a configured
+// provider except link parsing.
+import type { ContentRepository } from '../repo/types';
+import { EventLocation, slugify } from '../schema';
+import { getMediaStore } from '../media/store';
+import type { GeoResult, MapsProviderId, ParsedLocation } from './types';
+import { activeProvider } from './config';
+import { isShortMapLink, parseMapLink, validLat, validLng } from './parse';
+import { ATTRIBUTION, PROVIDERS } from './providers';
+
+export interface MapsContext {
+  locals?: unknown;
+  // the site origin, for the provider User-Agent
+  origin?: string;
+}
+
+/* ---------------- suggestions ---------------- */
+
+const SEARCH_TTL = 10 * 60_000;
+export const SEARCH_CACHE_MAX = 100;
+const searchCache = new Map<string, { at: number; results: GeoResult[] }>();
+
+/**
+ * Address suggestions for the event editor. [] when maps aren't set up or the
+ * query is too short; provider failures throw (the action reports them).
+ * Results are cached briefly per provider/query/area — typing the same
+ * prefix twice costs one request — and the cache is size-bounded so a
+ * long-lived Node server can't grow it forever.
+ */
+export async function searchPlaces(q: string, near: { lat: number; lng: number } | undefined, ctx: MapsContext = {}): Promise<GeoResult[]> {
+  const query = q.replace(/\s+/g, ' ').trim().slice(0, 200);
+  if (query.length < 3) return [];
+  const provider = activeProvider(ctx.locals, ctx.origin);
+  if (!provider) return [];
+  const area = near && validLat(near.lat) && validLng(near.lng) ? near : undefined;
+  // ~10 km cells: nearby pins share cache entries
+  const key = `${provider.id}|${query.toLowerCase()}|${area ? `${area.lat.toFixed(1)},${area.lng.toFixed(1)}` : ''}`;
+  const now = Date.now();
+  const hit = searchCache.get(key);
+  if (hit && now - hit.at < SEARCH_TTL) {
+    // refresh recency so hot queries survive eviction
+    searchCache.delete(key);
+    searchCache.set(key, hit);
+    return hit.results;
+  }
+  const results = await provider.search(query, { near: area, limit: 5 });
+  for (const [k, entry] of searchCache) if (now - entry.at >= SEARCH_TTL) searchCache.delete(k);
+  searchCache.delete(key);
+  searchCache.set(key, { at: now, results });
+  while (searchCache.size > SEARCH_CACHE_MAX) searchCache.delete(searchCache.keys().next().value!);
+  return results;
+}
+
+/* ---------------- short links ---------------- */
+
+// hosts a short link may be expanded through. consent.google.com is
+// deliberately absent: its continue= parameter is read, never fetched.
+const RESOLVE_HOSTS = new Set(['maps.app.goo.gl', 'goo.gl', 'google.com', 'www.google.com', 'maps.google.com']);
+const RESOLVE_HOPS = 5;
+const RESOLVE_TIMEOUT_MS = 5000;
+
+const pinned = (p: ParsedLocation | null) => p !== null && (p.lat !== null || p.name !== '' || p.address !== '' || p.kind === 'meeting');
+
+/**
+ * Expand (if short) and parse a pasted map link. Redirects are walked by hand
+ * — at most 5 hops, https only, Google map hosts only, 5 s in total — so a
+ * pasted link can't make the server fetch anything else (no SSRF).
+ */
+export async function expandMapLink(input: string): Promise<ParsedLocation | null> {
+  const raw = input.trim();
+  if (!isShortMapLink(raw)) return parseMapLink(raw);
+  const signal = AbortSignal.timeout(RESOLVE_TIMEOUT_MS);
+  let current = raw;
+  for (let hop = 0; hop < RESOLVE_HOPS; hop++) {
+    let u: URL;
+    try { u = new URL(current); } catch { return null; }
+    if (u.hostname === 'consent.google.com') {
+      const next = u.searchParams.get('continue');
+      if (!next) return null;
+      current = next;
+      continue;
+    }
+    if (!isShortMapLink(current)) {
+      const parsed = parseMapLink(current);
+      if (pinned(parsed)) return parsed;
+    }
+    if (u.protocol !== 'https:' || !RESOLVE_HOSTS.has(u.hostname.toLowerCase()) || u.username || u.password || (u.port && u.port !== '443')) return null;
+    let res: Response;
+    try {
+      res = await fetch(u.href, { redirect: 'manual', signal, headers: { 'User-Agent': 'Mozilla/5.0 (compatible; acms-maps/1.0)', Accept: 'text/html' } });
+    } catch {
+      return null;
+    }
+    const loc = res.status >= 300 && res.status < 400 ? res.headers.get('location') : null;
+    // don't keep the body around; only the redirect matters
+    try { await res.body?.cancel(); } catch { /* already consumed */ }
+    if (!loc) return null;
+    try { current = new URL(loc, u.href).href; } catch { return null; }
+  }
+  return null;
+}
+
+/** expand + parse; a pin with no address gets one from the provider when set up */
+export async function resolveMapLink(input: string, ctx: MapsContext = {}): Promise<ParsedLocation | null> {
+  const parsed = await expandMapLink(input);
+  if (!parsed) return null;
+  // keep the short link the person pasted: it's tidier and opens the app
+  if (isShortMapLink(input.trim()) && parsed.kind === 'map') parsed.url = input.trim();
+  if (parsed.kind === 'map' && parsed.lat !== null && parsed.lng !== null && !parsed.address) {
+    const provider = activeProvider(ctx.locals, ctx.origin);
+    if (provider) {
+      try {
+        const hit = await provider.reverse(parsed.lat, parsed.lng);
+        if (hit) {
+          parsed.address = hit.address || (hit.name && hit.name !== parsed.name ? hit.name : '');
+          if (!parsed.name && hit.name && hit.address) parsed.name = hit.name;
+        }
+      } catch (err) {
+        console.warn('[acms maps] reverse lookup failed:', err instanceof Error ? err.message : err);
+      }
+    }
+  }
+  return parsed;
+}
+
+/* ---------------- static map images ---------------- */
+
+export const MAP_WIDTH = 1200;
+export const MAP_HEIGHT = 500;
+
+const fix = (n: number) => n.toFixed(5);
+export const samePin = (a: { lat: number | null; lng: number | null }, b: { lat: number | null; lng: number | null }) =>
+  a.lat !== null && a.lng !== null && b.lat !== null && b.lng !== null && fix(a.lat) === fix(b.lat) && fix(a.lng) === fix(b.lng);
+
+// Map images live in the media library under keys that record what they show:
+//   <uuid>/map-<provider>-<lat>_<lng>-<light|dark>.<ext>
+// so a later save can tell whether they still match the pin (and which
+// provider to credit) without any extra columns.
+const IMAGE_RE = /^\/media\/[0-9a-f-]+\/map-([a-z]+)-(-?\d+\.\d+)_(-?\d+\.\d+)-(light|dark)\.(png|jpe?g|webp)$/;
+
+export function mapImageInfo(url: string): { provider: MapsProviderId; lat: number; lng: number; scheme: 'light' | 'dark' } | null {
+  const m = url.match(IMAGE_RE);
+  if (!m || !(m[1] in PROVIDERS)) return null;
+  return { provider: m[1] as MapsProviderId, lat: Number(m[2]), lng: Number(m[3]), scheme: m[4] as 'light' | 'dark' };
+}
+
+/** the credit line for a stored map image ('' when it isn't one of ours) */
+export function mapAttribution(url: string): string {
+  const info = mapImageInfo(url);
+  return info ? ATTRIBUTION[info.provider] : '';
+}
+
+const EXT: Record<string, string> = { 'image/png': 'png', 'image/jpeg': 'jpg', 'image/webp': 'webp' };
+
+async function storeMapImage(repo: ContentRepository, ctx: MapsContext, provider: MapsProviderId, lat: number, lng: number, scheme: 'light' | 'dark',
+  img: { body: ArrayBuffer; contentType: string }, label: string): Promise<string> {
+  const id = crypto.randomUUID();
+  const ext = EXT[img.contentType] ?? 'png';
+  const key = `${id}/map-${provider}-${fix(lat)}_${fix(lng)}-${scheme}.${ext}`;
+  await getMediaStore(ctx.locals).put(key, img.body, img.contentType);
+  await repo.createMedia({
+    id, key, filename: `map-${slugify(label) || 'pin'}${scheme === 'dark' ? '-dark' : ''}.${ext}`, mime: img.contentType,
+    width: MAP_WIDTH, height: MAP_HEIGHT, size: img.body.byteLength, alt: `Map of ${label || `${fix(lat)}, ${fix(lng)}`}`, variants: [],
+  });
+  return `/media/${key}`;
+}
+
+// Pins whose images just failed (quota, bad key…): editor autosaves resend
+// the location, and each one must not wait on the provider again. Bounded.
+const FAILED_TTL = 10 * 60_000;
+const FAILED_MAX = 50;
+const failedPins = new Map<string, number>();
+const recentlyFailed = (key: string, now: number) => {
+  const at = failedPins.get(key);
+  if (at !== undefined && now - at < FAILED_TTL) return true;
+  failedPins.delete(key);
+  return false;
+};
+const markFailed = (key: string, now: number) => {
+  failedPins.delete(key);
+  failedPins.set(key, now);
+  while (failedPins.size > FAILED_MAX) failedPins.delete(failedPins.keys().next().value!);
+};
+
+type Pinned = Pick<EventLocation, 'name' | 'address' | 'lat' | 'lng' | 'showMap' | 'placeId' | 'mapImage' | 'mapImageDark'>;
+
+/**
+ * Bring a location's cached map images in line with its pin:
+ * - no pin → no images
+ * - showMap off → nothing fetched; images for another pin are dropped
+ * - images already made for this pin → kept
+ * - the saved place it came from has images for this pin → reused
+ * - otherwise light + dark images are fetched once and stored as media
+ * Provider failures never throw: the location comes back without images.
+ */
+export async function ensureMapImages<T extends Pinned>(repo: ContentRepository, loc: T, ctx: MapsContext = {}): Promise<T> {
+  const none = { ...loc, mapImage: '', mapImageDark: '' };
+  if (loc.lat === null || loc.lng === null) return none;
+  const current = mapImageInfo(loc.mapImage);
+  if (current && samePin(current, loc)) {
+    const dark = mapImageInfo(loc.mapImageDark);
+    return { ...loc, mapImageDark: dark && samePin(dark, loc) ? loc.mapImageDark : '' };
+  }
+  if (loc.placeId) {
+    const place = await repo.getPlace(loc.placeId).catch(() => null);
+    const info = place ? mapImageInfo(place.mapImage) : null;
+    if (place && info && samePin(info, loc)) return { ...loc, mapImage: place.mapImage, mapImageDark: place.mapImageDark };
+  }
+  if (!loc.showMap) return none;
+  const provider = activeProvider(ctx.locals, ctx.origin);
+  if (!provider?.staticMap) return none;
+  const label = loc.name || loc.address;
+  const failKey = `${provider.id}|${fix(loc.lat)},${fix(loc.lng)}`;
+  const now = Date.now();
+  if (recentlyFailed(failKey, now)) return none;
+  try {
+    const opts = { width: MAP_WIDTH, height: MAP_HEIGHT };
+    const light = await provider.staticMap(loc.lat, loc.lng, { ...opts, dark: false });
+    if (!light) return none;
+    const id = provider.id as MapsProviderId;
+    const mapImage = await storeMapImage(repo, ctx, id, loc.lat, loc.lng, 'light', light, label);
+    let mapImageDark = '';
+    try {
+      const dark = await provider.staticMap(loc.lat, loc.lng, { ...opts, dark: true });
+      if (dark) mapImageDark = await storeMapImage(repo, ctx, id, loc.lat, loc.lng, 'dark', dark, label);
+    } catch (err) {
+      console.warn('[acms maps] dark map image failed:', err instanceof Error ? err.message : err);
+    }
+    return { ...loc, mapImage, mapImageDark };
+  } catch (err) {
+    console.warn('[acms maps] map image failed:', err instanceof Error ? err.message : err);
+    markFailed(failKey, now);
+    return none;
+  }
+}
+
+/* ---------------- event location input ---------------- */
+
+const MEDIA_MAP = /^\/media\/[0-9a-f-]+\/map-/;
+
+/**
+ * Fill a saved location from what the client sent. Clients that predate maps
+ * send only name/address/url: unchanged text keeps the pin, place link and
+ * images; changed text drops them (the old pin would point elsewhere).
+ * Image fields are only accepted when they are our own map images.
+ */
+export function mergeLocationInput(prev: EventLocation, input: Partial<EventLocation>): EventLocation {
+  const text = {
+    name: input.name ?? prev.name,
+    address: input.address ?? prev.address,
+    url: input.url ?? prev.url,
+  };
+  const sameText = text.name === prev.name && text.address === prev.address && text.url === prev.url;
+  const pinGiven = input.lat !== undefined || input.lng !== undefined;
+  let lat = pinGiven ? input.lat ?? null : sameText ? prev.lat : null;
+  let lng = pinGiven ? input.lng ?? null : sameText ? prev.lng : null;
+  if (!validLat(lat) || !validLng(lng)) { lat = null; lng = null; }
+  const img = (v: string | undefined, fallback: string) => (v === undefined ? fallback : v === '' || MEDIA_MAP.test(v) ? v : fallback);
+  return EventLocation.parse({
+    ...text,
+    lat, lng,
+    placeId: input.placeId !== undefined ? input.placeId : sameText ? prev.placeId : '',
+    showMap: input.showMap ?? prev.showMap,
+    mapImage: img(input.mapImage, prev.mapImage),
+    mapImageDark: img(input.mapImageDark, prev.mapImageDark),
+  });
+}
+
+/** the "directions" link for a pinned location: its map link, else Google Maps search on the pin */
+export function directionsUrl(loc: Pick<EventLocation, 'url' | 'lat' | 'lng' | 'name' | 'address'>): string {
+  const p = loc.url ? parseMapLink(loc.url) : null;
+  if (loc.url && (isShortMapLink(loc.url) || p?.kind === 'map')) return loc.url;
+  if (loc.lat !== null && loc.lng !== null) return `https://www.google.com/maps/search/?api=1&query=${loc.lat},${loc.lng}`;
+  const q = [loc.name, loc.address].filter(Boolean).join(', ');
+  return q ? `https://www.google.com/maps/search/?api=1&query=${encodeURIComponent(q)}` : '';
+}
+
+/** test hook: how many suggestion lists are cached */
+export const searchCacheSize = () => searchCache.size;

package/src/lib/maps/types.ts

@@ -0,0 +1,35 @@
+// Maps support is bring-your-own: acms runs no geocoder or tile server. A site
+// configures a provider (acms({ maps: { provider } }) + MAPS_API_KEY, or
+// MAPS_URL for a self-hosted Photon/Nominatim/Pelias) and gets address
+// suggestions and static map images. With nothing configured, link parsing
+// and saved places still work.
+
+export type MapsProviderId = 'geoapify' | 'google' | 'mapbox' | 'locationiq' | 'stadia' | 'photon' | 'nominatim' | 'pelias';
+
+// one address suggestion / resolved location
+export interface GeoResult {
+  name: string;
+  address: string;
+  lat: number | null;
+  lng: number | null;
+  // a link that opens the place in a map app ('' = build one from lat/lng)
+  url: string;
+}
+
+// what a pasted map link / embed tells us (no network needed except for short links)
+export interface ParsedLocation extends GeoResult {
+  // 'meeting' = Zoom/Meet/Teams…: online, no map
+  kind: 'map' | 'meeting';
+}
+
+// what the editor needs to know about the site's setup
+export interface MapsStatus {
+  // a provider is configured
+  enabled: boolean;
+  provider: MapsProviderId | '';
+  // display name ("Geoapify")
+  label: string;
+  // the provider can search (autofill) / draw static maps
+  search: boolean;
+  staticMaps: boolean;
+}

package/src/lib/mobile/bookings.ts

@@ -18,7 +18,7 @@ export const bookingInput = z.union([
   z.object({ ...common, resource: z.string().min(1).max(200), link: z.string().min(1).max(200),
     minutes: z.number().int().min(1).max(44640).optional(), answers: z.record(z.string().max(2000)).default({}),
   }).strict(),
-  z.object({ ...common, event: z.string().min(1).max(200), seats: z.number().int().min(1).max(1000).default(1) }).strict(),
+  z.object({ ...common, event: z.string().min(1).max(200), seats: z.number().int().min(1).max(1000).default(1), answers: z.record(z.string().max(2000)).default({}), formVersion: z.string().optional() }).strict(),
 ]);
 function canonical(value: unknown): string {
   if (value && typeof value === 'object' && !Array.isArray(value)) return `{${Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k,v]) => `${JSON.stringify(k)}:${canonical(v)}`).join(',')}}`;

package/src/lib/mobile/schemas.ts

@@ -29,7 +29,7 @@ export const Page = ContentSummary.extend({
 export const Event = CalEvent.pick({
   id: true, slug: true, title: true, excerpt: true, status: true, cancelled: true, featured: true, start: true, end: true,
   allDay: true, timezone: true, rrule: true, exdates: true, location: true, cta: true, tags: true, fields: true,
-}).extend({ url: str, icsUrl: str, repeats: str, image: str, imageAlt: str, updatedAt: date,
+}).extend({ rsvp: CalEvent.shape.rsvp.optional(), url: str, icsUrl: str, repeats: str, image: str, imageAlt: str, updatedAt: date,
   calendars: z.array(z.object({ id: str, slug: str, name: str, color: str })),
 });
 export const Events = z.object({ locale, timezone: str, from: date, to: date, pagination: Pagination,
@@ -46,7 +46,7 @@ export const Availability = z.object({ timezone: str, mode: z.enum(['slots', 'da
   days: z.array(z.object({ date: str, slots: z.array(z.object({ start: date, end: date, minutes: z.number() })) })),
 });
 export const BookingResult = z.object({ manageToken: str, booking: Booking.pick({
-  id: true, kind: true, status: true, name: true, email: true, phone: true, seats: true, answers: true, source: true,
+  id: true, kind: true, status: true, name: true, email: true, phone: true, seats: true, answers: true, formResponse: true, source: true,
 }).extend({ start: date, end: date, resourceId: str.nullable(), linkId: str.nullable(), eventId: str.nullable(), createdAt: date }) });
 export const Device = z.object({
   token: str, platform: z.enum(['ios', 'android']), locale: str.nullable(), topics: strings, registeredAt: date, lastSeenAt: date,

package/src/lib/repo/migrations.ts

@@ -5,6 +5,7 @@ import { WEBHOOK_MIGRATION } from '../webhook-sql';
 import { PUSH_MIGRATION } from '../push/migration';
 import { EDITOR_MIGRATION, EDITOR_GRACE_MIGRATION } from '../editor/migration';
 import { CALENDAR_SETTINGS_MIGRATION, ROOM_HOLD_MIGRATION } from '../calendar/migration';
+import { PLACES_MIGRATION } from '../maps/migration';
 // Versioned schema migrations shared by the two SQLite-dialect adapters
 // (D1 and libSQL). Applied versions are recorded in the `migrations` table;
 // each adapter's runner applies whatever is newer, in order, at startup.
@@ -518,6 +519,13 @@ export const MIGRATIONS: Migration[] = [
   { version: 42, statements: [
     `ALTER TABLE settings ADD COLUMN site_logo_dark TEXT NOT NULL DEFAULT ''`,
   ] },
+  PLACES_MIGRATION,
+  { version: 44, statements: [
+    `ALTER TABLE bookings ADD COLUMN form_response TEXT`,
+    `CREATE TABLE forms (id TEXT PRIMARY KEY, name TEXT NOT NULL, kind TEXT NOT NULL, purpose TEXT NOT NULL, status TEXT NOT NULL, definition TEXT NOT NULL, draft TEXT, revision INTEGER NOT NULL DEFAULT 1, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL)`,
+    `CREATE TABLE form_submissions (id TEXT PRIMARY KEY, form_id TEXT NOT NULL, response TEXT NOT NULL, created_at INTEGER NOT NULL)`,
+    `CREATE INDEX form_submissions_form_created ON form_submissions(form_id, created_at)`,
+  ] },
 ];
 
 export const LATEST_VERSION = MIGRATIONS[MIGRATIONS.length - 1].version;

package/src/lib/repo/sql.ts

@@ -1,3 +1,4 @@
+import { FormStore, formInsert, submissionInsert } from '../forms/store';
 import { LiveStore } from '../live/store';
 import { PushStore } from '../push/store';
 import { EditorStore } from '../editor/store';
@@ -5,7 +6,7 @@ import { LiveConfig } from '../live/types';
 import { ApiError } from '../api';
 import { EmailStore, bookingJobs } from '../email/store';
 import type { ContentRepository, DesignVersion, EventUpdate, ImportRecord, ImportRecordKind, ImportRun, SearchResults, Stats } from './types';
-import { DocTranslations, Page, Post, Link, Media, NavItem, Redirect, Settings, Snippet, Tag, User, Calendar, CalEvent, ApiKey, Webhook, WebhookDelivery, Resource, BookingLink, Booking, isInternalTag, normalizeRedirectPath, publicTags, slugify, type WidgetInstance } from '../schema';
+import { DocTranslations, Page, Post, Link, Media, NavItem, Redirect, Settings, Snippet, Tag, User, Calendar, CalEvent, ApiKey, Webhook, WebhookDelivery, Resource, BookingLink, Booking, Place, EventLocation, isInternalTag, normalizeRedirectPath, publicTags, slugify, type WidgetInstance } from '../schema';
 import { designSnapshot, draftNavItems, pickDesignDraft, pickEventDraft, pickPageDraft, pickPostDraft } from '../drafts';
 import { eventInstants, eventTimeZone, normalizeEventTimes } from '../calendar/events';
 import { cleanRrule } from '../calendar/rrule';
@@ -157,7 +158,15 @@ function rowToResource(r: Row): Resource {
     capacity: r.capacity === null || r.capacity === undefined ? null : Number(r.capacity),
     amenities: json(r.amenities, []), timezone: r.timezone ?? '', hours: json(r.hours, {}), overrides: json(r.overrides, []),
     busyFeeds: json(r.busy_feeds, []), notifyEmails: json(r.notify_emails, []), visibility: r.visibility ?? 'public',
-    showOnCalendar: Boolean(r.show_on_calendar), feedToken: r.feed_token ?? '', order: Number(r.ord ?? 0),
+    showOnCalendar: Boolean(r.show_on_calendar), feedToken: r.feed_token ?? '', placeId: r.place_id ?? '', order: Number(r.ord ?? 0),
+    createdAt: Number(r.created_at), updatedAt: Number(r.updated_at),
+  });
+}
+function rowToPlace(r: Row): Place {
+  const n = (v: unknown) => (v === null || v === undefined || v === '' ? null : Number(v));
+  return Place.parse({
+    id: r.id, name: r.name, address: r.address ?? '', url: r.url ?? '', lat: n(r.lat), lng: n(r.lng), notes: r.notes ?? '',
+    isDefault: Boolean(r.is_default), mapImage: r.map_image ?? '', mapImageDark: r.map_image_dark ?? '', order: Number(r.ord ?? 0),
     createdAt: Number(r.created_at), updatedAt: Number(r.updated_at),
   });
 }
@@ -187,6 +196,7 @@ function rowToBooking(r: Row): Booking {
     id: r.id, kind: r.kind ?? 'booking', resourceId: r.resource_id ?? '', linkId: r.link_id ?? '', eventId: r.event_id ?? '',
     status: r.status, start: Number(r.start_at), end: Number(r.end_at), holdStart: Number(r.hold_start), holdEnd: Number(r.hold_end),
     timezone: r.timezone ?? '', name: r.name ?? '', email: r.email ?? '', phone: r.phone ?? '', seats: Number(r.seats ?? 1),
+    formResponse: r.form_response ? json(r.form_response, undefined) : undefined,
     answers: json(r.answers, {}), notes: r.notes ?? '', manageToken: r.manage_token ?? '', source: r.source ?? 'web',
     notificationVersion: Number(r.notification_version ?? 0), reminderSentAt: r.reminder_sent_at === null || r.reminder_sent_at === undefined ? null : Number(r.reminder_sent_at),
     createdAt: Number(r.created_at), updatedAt: Number(r.updated_at),
@@ -248,12 +258,14 @@ export class SqlRepository implements ContentRepository {
   private driver!: SqlDriver;
   private ready: Promise<void>;
   readonly email: EmailStore;
+  readonly forms: FormStore;
   readonly live: LiveStore;
   readonly push: PushStore;
   readonly editor: EditorStore;
 
   constructor(driver: SqlDriver | (() => Promise<SqlDriver>)) {
     this.ready = this.init(driver);
+    this.forms = new FormStore(async () => { await this.ready; return this.driver; });
     this.live = new LiveStore(async () => { await this.ready; return this.driver; });
     this.push = new PushStore(async () => { await this.ready; return this.driver; });
     this.editor = new EditorStore(async () => { await this.ready; return this.driver; });
@@ -424,7 +436,7 @@ export class SqlRepository implements ContentRepository {
     await this.ready;
     // One SELECT snapshots bookings and their retry ledger together. No UI
     // list limit; include tombstones for deleted bookings as well.
-    const columns = ['id','kind','resource_id','link_id','event_id','status','start_at','end_at','hold_start','hold_end','timezone','name','email','phone','seats','answers','notes','manage_token','source','reminder_sent_at','notification_version','created_at','updated_at'];
+    const columns = ['id','kind','resource_id','link_id','event_id','status','start_at','end_at','hold_start','hold_end','timezone','name','email','phone','seats','answers','form_response','notes','manage_token','source','reminder_sent_at','notification_version','created_at','updated_at'];
     const rows = await this.driver.all(`SELECT 'booking' AS type, json_object(${columns.map(c => `'${c}',${c}`).join(',')}) AS data FROM bookings
       UNION ALL SELECT 'request', json_object('keyHash',key_hash,'requestHash',request_hash,'bookingId',booking_id,'createdAt',created_at) FROM mobile_booking_requests`);
     return {
@@ -931,14 +943,88 @@ export class SqlRepository implements ContentRepository {
   }
 
 
+  async setEventLocation(id: string, patch: Parameters<ContentRepository['setEventLocation']>[1]) {
+    await this.ready;
+    const current = await this.getEvent(id);
+    if (!current) return;
+    const stmts: SqlStatement[] = [];
+    if (patch.live) {
+      stmts.push({ sql: 'UPDATE events SET location = ?, updated_at = ? WHERE id = ?', args: [JSON.stringify(EventLocation.parse(patch.live)), Date.now(), id] });
+      if (patch.notify && current.status === 'published') {
+        // same fan-out as updateEvent's location change, minus the time math
+        stmts.push(
+          { sql: `UPDATE bookings SET notification_version=notification_version+1 WHERE event_id=? AND kind='rsvp' AND status IN ('pending','confirmed')`, args: [id] },
+          ...bookingJobs(id, 'updated').map((st) => ({ ...st, sql: st.sql.replace('b.id = ?', `b.event_id = ? AND b.kind='rsvp' AND b.status IN ('pending','confirmed')`) })),
+        );
+      }
+    }
+    if (patch.draft && current.draft) {
+      const draft = { ...current.draft, location: EventLocation.parse(patch.draft) };
+      stmts.push({ sql: 'UPDATE events SET draft = ? WHERE id = ?', args: [JSON.stringify(draft), id] });
+    }
+    if (!stmts.length) return;
+    await this.driver.batch(stmts);
+    if (patch.live) await this.syncEventIndex(id);
+  }
+
+  // ---- places ----
+  private placeInsert(p: Place): SqlStatement {
+    return {
+      sql: `INSERT INTO places (id, name, address, url, lat, lng, notes, is_default, map_image, map_image_dark, ord, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      args: [p.id, p.name, p.address, p.url, p.lat, p.lng, p.notes, p.isDefault ? 1 : 0, p.mapImage, p.mapImageDark, p.order, p.createdAt, p.updatedAt],
+    };
+  }
+  async listPlaces() {
+    await this.ready;
+    return (await this.driver.all('SELECT * FROM places ORDER BY ord ASC, name COLLATE NOCASE ASC')).map(rowToPlace);
+  }
+  async getPlace(id: string) {
+    await this.ready;
+    const r = await this.first('SELECT * FROM places WHERE id = ?', [id]);
+    return r ? rowToPlace(r) : null;
+  }
+  async createPlace(data: Parameters<ContentRepository['createPlace']>[0]) {
+    await this.ready;
+    const now = Date.now();
+    const next = await this.first('SELECT COALESCE(MAX(ord), -1) + 1 AS n FROM places');
+    const p = Place.parse({ ...data, id: crypto.randomUUID(), order: Number(next?.n ?? 0), createdAt: now, updatedAt: now });
+    await this.driver.batch([
+      ...(p.isDefault ? [{ sql: 'UPDATE places SET is_default = 0 WHERE is_default = 1', args: [] }] : []),
+      this.placeInsert(p),
+    ]);
+    return p;
+  }
+  async updatePlace(id: string, data: Parameters<ContentRepository['updatePlace']>[1]) {
+    await this.ready;
+    const cur = await this.getPlace(id);
+    if (!cur) return;
+    const p = Place.parse({ ...cur, ...data, id, createdAt: cur.createdAt, updatedAt: Date.now() });
+    await this.driver.batch([
+      ...(p.isDefault ? [{ sql: 'UPDATE places SET is_default = 0 WHERE id != ? AND is_default = 1', args: [id] }] : []),
+      {
+        sql: `UPDATE places SET name = ?, address = ?, url = ?, lat = ?, lng = ?, notes = ?, is_default = ?, map_image = ?, map_image_dark = ?,
+          ord = ?, updated_at = ? WHERE id = ?`,
+        args: [p.name, p.address, p.url, p.lat, p.lng, p.notes, p.isDefault ? 1 : 0, p.mapImage, p.mapImageDark, p.order, p.updatedAt, id],
+      },
+    ]);
+  }
+  async deletePlace(id: string) {
+    await this.ready;
+    await this.driver.batch([
+      { sql: 'DELETE FROM places WHERE id = ?', args: [id] },
+      { sql: "UPDATE resources SET place_id = '' WHERE place_id = ?", args: [id] },
+    ]);
+  }
+
   // ---- resources + booking links ----
   private resourceInsert(r: Resource): SqlStatement {
     return {
       sql: `INSERT INTO resources (id, slug, name, kind, description, photo, capacity, amenities, timezone, hours, overrides, busy_feeds,
-        notify_emails, visibility, show_on_calendar, feed_token, ord, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        notify_emails, visibility, show_on_calendar, feed_token, ord, created_at, updated_at, place_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       args: [r.id, r.slug, r.name, r.kind, r.description, r.photo, r.capacity, JSON.stringify(r.amenities), r.timezone, JSON.stringify(r.hours),
         JSON.stringify(r.overrides), JSON.stringify(r.busyFeeds), JSON.stringify(r.notifyEmails), r.visibility, r.showOnCalendar ? 1 : 0,
-        r.feedToken || randomToken(), r.order, r.createdAt, r.updatedAt],
+        r.feedToken || randomToken(), r.order, r.createdAt, r.updatedAt, r.placeId],
     };
   }
   private linkInsert(l: BookingLink): SqlStatement {
@@ -955,9 +1041,9 @@ export class SqlRepository implements ContentRepository {
   private bookingInsert(b: Booking): SqlStatement {
     return {
       sql: `INSERT INTO bookings (id, kind, resource_id, link_id, event_id, status, start_at, end_at, hold_start, hold_end, timezone, name, email, phone,
-        seats, answers, notes, manage_token, source, reminder_sent_at, created_at, updated_at, notification_version) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        seats, answers, notes, manage_token, source, reminder_sent_at, created_at, updated_at, notification_version, form_response) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       args: [b.id, b.kind, b.resourceId, b.linkId, b.eventId, b.status, b.start, b.end, b.holdStart, b.holdEnd, b.timezone, b.name, b.email, b.phone,
-        b.seats, JSON.stringify(b.answers), b.notes, b.manageToken, b.source, b.reminderSentAt, b.createdAt, b.updatedAt, b.notificationVersion],
+        b.seats, JSON.stringify(b.answers), b.notes, b.manageToken, b.source, b.reminderSentAt, b.createdAt, b.updatedAt, b.notificationVersion, b.formResponse ? JSON.stringify(b.formResponse) : null],
     };
   }
   async listResources() {
@@ -989,10 +1075,10 @@ export class SqlRepository implements ContentRepository {
     const r = Resource.parse({ ...cur, ...data, id, updatedAt: Date.now() });
     await this.driver.run(
       `UPDATE resources SET slug = ?, name = ?, kind = ?, description = ?, photo = ?, capacity = ?, amenities = ?, timezone = ?, hours = ?,
-        overrides = ?, busy_feeds = ?, notify_emails = ?, visibility = ?, show_on_calendar = ?, feed_token = ?, updated_at = ? WHERE id = ?`,
+        overrides = ?, busy_feeds = ?, notify_emails = ?, visibility = ?, show_on_calendar = ?, feed_token = ?, place_id = ?, updated_at = ? WHERE id = ?`,
       [r.slug, r.name, r.kind, r.description, r.photo, r.capacity, JSON.stringify(r.amenities), r.timezone, JSON.stringify(r.hours),
         JSON.stringify(r.overrides), JSON.stringify(r.busyFeeds), JSON.stringify(r.notifyEmails), r.visibility, r.showOnCalendar ? 1 : 0,
-        r.feedToken, r.updatedAt, id]
+        r.feedToken, r.placeId, r.updatedAt, id]
     );
   }
   async reorderResources(ids: string[]) {
@@ -1615,7 +1701,7 @@ export class SqlRepository implements ContentRepository {
       // Suppression and re-enabling share the restore transaction. A failed
       // restore cannot leave notifications disabled or emit phantom deletes.
       { sql: 'UPDATE webhook_control SET suppressed=1 WHERE id=1' },
-      ...['email_jobs', 'email_attempts', 'email_delivery_events', 'email_tokens', 'posts', 'pages', 'media', 'links', 'tags', 'nav_items', 'users', 'post_authors', 'redirects', 'calendars', 'events', 'resources', 'booking_links', 'bookings', 'mobile_booking_requests', 'import_runs', 'import_records'].map((t) => ({
+      ...['email_jobs', 'email_attempts', 'email_delivery_events', 'email_tokens', 'posts', 'pages', 'media', 'links', 'tags', 'nav_items', 'users', 'post_authors', 'redirects', 'calendars', 'events', 'resources', 'booking_links', 'bookings', 'mobile_booking_requests', 'import_runs', 'import_records', 'places', 'forms', 'form_submissions'].map((t) => ({
         sql: `DELETE FROM ${t}`,
       })),
       ...(content.calendars ?? []).map((c) => ({
@@ -1635,7 +1721,10 @@ export class SqlRepository implements ContentRepository {
           JSON.stringify(e.rsvp ?? {}), JSON.stringify(e.roomHold ?? {}),
         ],
       })),
+      ...(content.forms ?? []).map(formInsert),
+      ...(content.formSubmissions ?? []).map(submissionInsert),
       ...(content.resources ?? []).map((r) => this.resourceInsert(r)),
+      ...(content.places ?? []).map((p) => this.placeInsert(p)),
       ...(content.bookingLinks ?? []).map((l) => this.linkInsert(l)),
       ...(content.bookings ?? []).map((b) => this.bookingInsert(b)),
       ...(content.bookingRequests ?? []).map(r => ({ sql: 'INSERT INTO mobile_booking_requests (key_hash,request_hash,booking_id,created_at) VALUES (?,?,?,?)', args: [r.keyHash,r.requestHash,r.bookingId,r.createdAt] })),

package/src/lib/repo/types.ts

@@ -1,3 +1,5 @@
+import type { FormStore } from '../forms/store';
+import type { SavedForm, FormSubmission } from '../forms/schema';
 import type { LiveStore } from '../live/store';
 import type { BookingRequest } from '../backup/content';
 import type { EmailStore } from '../email/store';
@@ -8,7 +10,7 @@ export type ImportRecordKind = 'post' | 'page' | 'user' | 'tag' | 'media' | 'red
 export interface ImportRecord { runId: string; kind: ImportRecordKind; sourceId: string; acmsId: string; action: 'created' | 'updated'; stamp: number }
 export interface DesignVersion { id: string; createdAt: number; author: string; summary: string; snapshot: Record<string, unknown> }
 
-import type { Page, Post, Link, Media, NavItem, Redirect, Settings, Snippet, Tag, User, Role, WidgetInstance, Calendar, CalEvent, ApiKey, ApiScope, Webhook, WebhookDelivery, Resource, BookingLink, Booking, BookingStatus } from '../schema';
+import type { Page, Post, Link, Media, NavItem, Redirect, Settings, Snippet, Tag, User, Role, WidgetInstance, Calendar, CalEvent, ApiKey, ApiScope, Webhook, WebhookDelivery, Resource, BookingLink, Booking, BookingStatus, Place, EventLocation } from '../schema';
 
 export interface Stats {
   publishedPages: number;
@@ -48,6 +50,7 @@ export type EventUpdate = Partial<
 // this — never a concrete adapter.
 export interface ContentRepository {
   readonly email: EmailStore;
+  readonly forms: FormStore;
   readonly live: LiveStore;
   readonly push: PushStore;
   readonly editor: EditorStore;
@@ -131,6 +134,19 @@ export interface ContentRepository {
   applyEventDraft(id: string): Promise<void>;
   discardEventDraft(id: string): Promise<void>;
   deleteEvent(id: string): Promise<void>;
+  // saved-place sync (lib/maps/places.ts): rewrite just the location of the
+  // live row and/or the staged draft, leaving every other field — and the
+  // draft itself — alone. notify = RSVP guests of a published event get an
+  // "event updated" email (the address changed).
+  setEventLocation(id: string, patch: { live?: EventLocation; draft?: EventLocation; notify?: boolean }): Promise<void>;
+
+  // saved places. Only one can be the default (saving one as default clears
+  // the others). Deleting a place unlinks its rooms; events keep their copy.
+  listPlaces(): Promise<Place[]>;
+  getPlace(id: string): Promise<Place | null>;
+  createPlace(data: Partial<Omit<Place, 'id' | 'createdAt' | 'updatedAt' | 'order'>> & { name: string }): Promise<Place>;
+  updatePlace(id: string, data: Partial<Omit<Place, 'id' | 'createdAt' | 'updatedAt'>>): Promise<void>;
+  deletePlace(id: string): Promise<void>;
 
   // resources (rooms, people, vans…) and their booking links. Deleting a
   // resource deletes its links; its bookings stay as history.
@@ -265,6 +281,10 @@ export interface ContentRepository {
     bookingLinks?: BookingLink[];
     bookings?: Booking[];
     bookingRequests?: BookingRequest[];
+    // added with maps support; older backups restore with none
+    places?: Place[];
+    forms?: SavedForm[];
+    formSubmissions?: FormSubmission[];
   }): Promise<void>;
 
   // imports (lib/import/apply.ts drives these). writeImported is the